openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Dense /DenseCompletionProgram.lean
| import OAI.Combinatorics.ContingencyTables.Dense.DenseIntegerProgram | |
| import OAI.Combinatorics.ContingencyTables.Dense.DenseExponentArithmetic | |
| namespace OAI | |
| /-! # Signed dependent entries from binary margin and matrix lists -/ | |
| namespace ContingencyTables.DensePrograms | |
| open MatchingFPRAS.TreeTyped | |
| open scoped BigOperators | |
| abbrev CompletionData := (List ℕ×List ℕ)×MatrixCode | |
| abbrev CompletionCell := CompletionData×(ℕ×ℕ) | |
| /-- Index zero denotes the distinguished dependent row or column. -/ | |
| def completionParts (z : CompletionCell) : ℕ×ℕ := | |
| if z.2.1=0 then | |
| if z.2.2=0 then | |
| (z.1.1.1.headD 0+matrixTotal z.1.2,z.1.1.2.tail.sum) | |
| else (z.1.1.2.getD z.2.2 0,columnTotal (z.1.2,z.2.2-1)) | |
| else if z.2.2=0 then | |
| (z.1.1.1.getD z.2.1 0,rowTotal (z.1.2,z.2.1-1)) | |
| else (matrixEntry (z.1.2,(z.2.1-1,z.2.2-1)),0) | |
| def completionPartsRealizer : Realizer completionParts := by | |
| let R : Realizer (fun z : CompletionCell => z.1.1.1) := | |
| composition (composition first first) first | |
| let C : Realizer (fun z : CompletionCell => z.1.1.2) := | |
| composition (composition first first) second | |
| let Z : Realizer (fun z : CompletionCell => z.1.2) := composition first second | |
| let I : Realizer (fun z : CompletionCell => z.2.1) := composition second first | |
| let J : Realizer (fun z : CompletionCell => z.2.2) := composition second second | |
| let Im := composition (pair I (constant 1)) subtract | |
| let Jm := composition (pair J (constant 1)) subtract | |
| let Rval := composition (pair R I) (getDFast 0) | |
| let Cval := composition (pair C J) (getDFast 0) | |
| let Rsum := composition (pair Z Im) rowTotalRealizer | |
| let Csum := composition (pair Z Jm) columnTotalRealizer | |
| let total := pair | |
| (composition (pair (composition R (head 0)) (composition Z matrixTotalRealizer)) add) | |
| (composition (composition C tail) listSum) | |
| let entry := pair (composition (pair Z (pair Im Jm)) matrixEntryRealizer) (constant 0) | |
| exact (choose (composition (pair I (constant 0)) natEqual) | |
| (choose (composition (pair J (constant 0)) natEqual) total (pair Cval Csum)) | |
| (choose (composition (pair J (constant 0)) natEqual) (pair Rval Rsum) entry)).congr | |
| (by intro z; simp only [Function.comp_apply,decide_eq_true_eq,completionParts]) | |
| theorem polynomial_completionParts : PolynomialTime completionPartsRealizer := by | |
| have hR : PolynomialTime (composition | |
| (composition (first (A := CompletionData) (B := ℕ×ℕ)) first) first) := | |
| polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_first | |
| have hC : PolynomialTime (composition | |
| (composition (first (A := CompletionData) (B := ℕ×ℕ)) first) second) := | |
| polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_second | |
| have hZ : PolynomialTime (composition | |
| (first (A := CompletionData) (B := ℕ×ℕ)) second) := | |
| polynomial_composition polynomial_first polynomial_second | |
| have hI : PolynomialTime (composition | |
| (second (A := CompletionData) (B := ℕ×ℕ)) first) := | |
| polynomial_composition polynomial_second polynomial_first | |
| have hJ : PolynomialTime (composition | |
| (second (A := CompletionData) (B := ℕ×ℕ)) second) := | |
| polynomial_composition polynomial_second polynomial_second | |
| have hi := polynomial_composition (polynomial_pair hI (polynomial_constant 0)) polynomial_natEqual | |
| have hj := polynomial_composition (polynomial_pair hJ (polynomial_constant 0)) polynomial_natEqual | |
| have him := polynomial_composition (polynomial_pair hI (polynomial_constant 1)) polynomial_subtract | |
| have hjm := polynomial_composition (polynomial_pair hJ (polynomial_constant 1)) polynomial_subtract | |
| have hr := polynomial_composition (polynomial_pair hR hI) (polynomial_getDFast 0) | |
| have hc := polynomial_composition (polynomial_pair hC hJ) (polynomial_getDFast 0) | |
| have hrs := polynomial_composition (polynomial_pair hZ him) polynomial_rowTotal | |
| have hcs := polynomial_composition (polynomial_pair hZ hjm) polynomial_columnTotal | |
| have ht := polynomial_pair (polynomial_composition (polynomial_pair | |
| (polynomial_composition hR (polynomial_head 0)) | |
| (polynomial_composition hZ polynomial_matrixTotal)) polynomial_add) | |
| (polynomial_composition (polynomial_composition hC polynomial_tail) polynomial_listSum) | |
| have he := polynomial_pair (polynomial_composition | |
| (polynomial_pair hZ (polynomial_pair him hjm)) polynomial_matrixEntry) (polynomial_constant 0) | |
| unfold completionPartsRealizer | |
| exact polynomial_congr _ (polynomial_choose hi (polynomial_choose hj ht | |
| (polynomial_pair hc hcs)) (polynomial_choose hj (polynomial_pair hr hrs) he)) | |
| def marginCode {m : ℕ} (R : Option (Fin m) → ℕ) : List ℕ := | |
| R none::List.ofFn (fun i => R (some i)) | |
| def optionIndex {m : ℕ} : Option (Fin m) → ℕ | |
| | none => 0 | |
| | some i => i.val+1 | |
| lemma marginCode_getD {m : ℕ} (R : Option (Fin m) → ℕ) (i : Option (Fin m)) : | |
| (marginCode R).getD (optionIndex i) 0=R i := by | |
| cases i with | |
| | none => rfl | |
| | some i => | |
| simp only [marginCode,optionIndex,List.getD_eq_getElem?_getD,List.getElem?_cons_succ, | |
| List.getElem?_ofFn,i.isLt,dite_true,Option.getD_some,Fin.eta] | |
| theorem completionParts_code {m n : ℕ} (R : Option (Fin m) → ℕ) | |
| (P : Option (Fin n) → ℕ) (z : Fin m → Fin n → ℕ) | |
| (i : Option (Fin m)) (j : Option (Fin n)) : | |
| completionParts (((marginCode R,marginCode P),matrixCode z),(optionIndex i,optionIndex j))= | |
| GridBoundary.integerParts R P (fun p => z p.1 p.2) i j := by | |
| cases i with | |
| | none => | |
| cases j with | |
| | none => | |
| simp only [completionParts,optionIndex,ite_true,marginCode,List.headD_cons, | |
| List.tail_cons,List.sum_ofFn,matrixTotal_code,GridBoundary.integerParts] | |
| | some j => | |
| simp only [completionParts,optionIndex,ite_true,Nat.add_one_ne_zero,ite_false, | |
| Nat.add_sub_cancel,columnTotal_code,GridBoundary.integerParts] | |
| exact congrArg (fun a => (a,∑ i,z i j)) (marginCode_getD P (some j)) | |
| | some i => | |
| cases j with | |
| | none => | |
| simp only [completionParts,optionIndex,Nat.add_one_ne_zero,ite_false,ite_true, | |
| Nat.add_sub_cancel,rowTotal_code,GridBoundary.integerParts] | |
| exact congrArg (fun a => (a,∑ j,z i j)) (marginCode_getD R (some i)) | |
| | some j => | |
| simp only [completionParts,optionIndex,Nat.add_one_ne_zero,ite_false, | |
| Nat.add_sub_cancel,matrixEntry_code,GridBoundary.integerParts] | |
| /-- The difference of the computed pair is the exact signed completion entry. -/ | |
| theorem completionParts_signed {m n : ℕ} (R : Option (Fin m) → ℕ) | |
| (P : Option (Fin n) → ℕ) (z : Fin m → Fin n → ℕ) | |
| (i : Option (Fin m)) (j : Option (Fin n)) : | |
| let p := completionParts | |
| (((marginCode R,marginCode P),matrixCode z),(optionIndex i,optionIndex j)) | |
| (p.1 : ℤ)-p.2=DenseAffine.integerTable R P (fun ij => z ij.1 ij.2) i j := by | |
| dsimp only | |
| rw [completionParts_code] | |
| exact GridBoundary.integerParts_sub R P _ i j | |
| end ContingencyTables.DensePrograms | |
| end OAI | |