openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Machines /BinIntervalProgram.lean
| import OAI.Combinatorics.ContingencyTables.Machines.SignedFloorProgram | |
| import OAI.Combinatorics.ContingencyTables.Machines.ScaledWordProgram | |
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionBinIntervals | |
| namespace OAI | |
| /-! # Binary evaluation of a bin interval and its bounded quotient draw | |
| The lower endpoint is computed as the negative floor of a negative | |
| rational. Thus the executed arithmetic uses natural quotient/remainder, | |
| without enumerating any of the integers in the interval. | |
| -/ | |
| namespace ContingencyTables.BinIntervalProgram | |
| open MatchingFPRAS MatchingFPRAS.TreeTyped SignedPairProgram ProfilePrograms | |
| /-- `(number of bins, range size, bin index)`. -/ | |
| abbrev Input := (ℕ×ℕ)×ℕ | |
| def negativeInput (z : Input) : SignedFloorProgram.Input := | |
| ((0,z.2*z.1.2),z.1.1) | |
| def negativeInputRealizer : Realizer negativeInput := | |
| pair (pair (constant 0) | |
| (composition (f := fun z : Input => (z.2,z.1.2)) | |
| (g := fun p : ℕ×ℕ => p.1*p.2) | |
| (pair second (composition first second)) multiply)) (composition first first) | |
| lemma polynomial_negativeInput : PolynomialTime negativeInputRealizer := | |
| polynomial_pair (polynomial_pair (polynomial_constant 0) | |
| (polynomial_composition (polynomial_pair polynomial_second | |
| (polynomial_composition polynomial_first polynomial_second)) polynomial_multiply)) | |
| (polynomial_composition polynomial_first polynomial_first) | |
| def endpoint (z : Input) : ℕ := | |
| (SignedPairProgram.normalize (SignedFloorProgram.floorCode (negativeInput z))).2 | |
| def endpointRealizer : Realizer endpoint := | |
| composition (f := fun z : Input => SignedPairProgram.normalize | |
| (SignedFloorProgram.floorCode (negativeInput z))) (g := Prod.snd) | |
| (composition (f := fun z : Input => SignedFloorProgram.floorCode (negativeInput z)) | |
| (g := SignedPairProgram.normalize) | |
| (composition negativeInputRealizer SignedFloorProgram.floorCodeRealizer) | |
| SignedPairProgram.normalizeRealizer) second | |
| theorem polynomial_endpoint : PolynomialTime endpointRealizer := | |
| polynomial_composition (polynomial_composition | |
| (polynomial_composition polynomial_negativeInput SignedFloorProgram.polynomial_floorCode) | |
| SignedPairProgram.polynomial_normalize) polynomial_second | |
| theorem endpoint_eq (K N beta : ℕ) : endpoint ((K,N),beta)=FairBits.endpoint K N beta := by | |
| unfold endpoint negativeInput | |
| rw [SignedPairProgram.normalize_eq,SignedFloorProgram.floorCode_value] | |
| change (-⌊((0:ℚ)-((beta*N:ℕ):ℚ))/K⌋).toNat=FairBits.endpoint K N beta | |
| have he : ((0:ℚ)-((beta*N:ℕ):ℚ))/K= -((beta:ℚ)*N/K) := by | |
| push_cast | |
| ring | |
| rw [he,Int.floor_neg,neg_neg,Int.ceil_toNat] | |
| rfl | |
| def next (z : Input) : Input := (z.1,z.2+1) | |
| def nextRealizer : Realizer next := pair first (composition second successor) | |
| lemma polynomial_next : PolynomialTime nextRealizer := | |
| polynomial_pair polynomial_first (polynomial_composition polynomial_second polynomial_successor) | |
| def intervalSize (z : Input) : ℕ := endpoint (next z)-endpoint z | |
| def intervalSizeRealizer : Realizer intervalSize := | |
| composition (f := fun z : Input => (endpoint (next z),endpoint z)) | |
| (g := fun p : ℕ×ℕ => p.1-p.2) | |
| (pair (composition (f := next) (g := endpoint) nextRealizer endpointRealizer) | |
| endpointRealizer) subtract | |
| theorem polynomial_intervalSize : PolynomialTime intervalSizeRealizer := | |
| polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_next polynomial_endpoint) polynomial_endpoint) | |
| polynomial_subtract | |
| theorem intervalSize_eq (K N beta : ℕ) : | |
| intervalSize ((K,N),beta)=CompanionOracleDensity.intervalSize K N beta := by | |
| unfold intervalSize next | |
| rw [endpoint_eq,endpoint_eq] | |
| rfl | |
| def draw (z : Input×List Bool) : ℕ := | |
| endpoint z.1+scaledWordValue (intervalSize z.1,z.2) | |
| def drawRealizer : Realizer draw := | |
| composition (f := fun z : Input×List Bool => | |
| (endpoint z.1,scaledWordValue (intervalSize z.1,z.2))) | |
| (g := fun p : ℕ×ℕ => p.1+p.2) | |
| (pair (composition (f := fun z : Input×List Bool => z.1) (g := endpoint) | |
| first endpointRealizer) | |
| (composition (f := fun z : Input×List Bool => (intervalSize z.1,z.2)) | |
| (g := scaledWordValue) | |
| (pair (composition (f := fun z : Input×List Bool => z.1) (g := intervalSize) | |
| first intervalSizeRealizer) second) scaledWordRealizer)) add | |
| theorem polynomial_draw : PolynomialTime drawRealizer := | |
| polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first polynomial_endpoint) | |
| (polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first polynomial_intervalSize) polynomial_second) | |
| polynomial_scaledWord)) polynomial_add | |
| theorem draw_mem (K N beta : ℕ) (hK : 0<K) (hN : 0<N) (hb : beta<K) | |
| (hsize : 0<CompanionOracleDensity.intervalSize K N beta) (bits : List Bool) : | |
| draw (((K,N),beta),bits)∈FairBits.fiber K N beta := by | |
| have hd := scaledWordValue_lt (CompanionOracleDensity.intervalSize K N beta) hsize bits | |
| rw [FairBits.fiber_eq_interval hK hN hb,Finset.mem_Ico] | |
| simp only [draw,endpoint_eq,intervalSize_eq] | |
| unfold CompanionOracleDensity.intervalSize at * | |
| omega | |
| theorem draw_ofFn (K N beta k : ℕ) (hK : 0<K) (hN : 0<N) (hb : beta<K) | |
| (hsize : 0<CompanionOracleDensity.intervalSize K N beta) (bits : Fin k → Bool) : | |
| draw (((K,N),beta),List.ofFn bits)= | |
| (CompanionOracleDensity.intervalEquiv K N beta hK hN hb | |
| (FairBits.scaledBitInteger (CompanionOracleDensity.intervalSize K N beta) k hsize bits)).val := by | |
| change draw (((K,N),beta),List.ofFn bits)=FairBits.endpoint K N beta+ | |
| (FairBits.scaledBitInteger (CompanionOracleDensity.intervalSize K N beta) k hsize bits).val | |
| rw [draw,endpoint_eq,intervalSize_eq,scaledWordValue_ofFn _ _ hsize] | |
| end ContingencyTables.BinIntervalProgram | |
| end OAI | |