File size: 5,817 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 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | 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
|