File size: 5,464 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 121 | import OAI.Combinatorics.ContingencyTables.Machines.PreparedTransitionCache
import OAI.Combinatorics.ContingencyTables.Machines.MatrixCodeEquality
import OAI.Combinatorics.ContingencyTables.Sampling.OuterTrialProgram
namespace OAI
/-! # Exact terminal counts from the retained dense-completion cache -/
namespace ContingencyTables.ProfilePrograms
open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms
abbrev TerminalOutputInput := (ProfileCheckData×ℕ)×(Option MatrixCode×ℕ)
def terminalOutputEntry (z : TerminalOutputInput) : Option MatrixCode×ℕ :=
(z.2.1.bind (fun X => outerTrial (z.1,X)),z.2.2)
def terminalOutputEntryRealizer : Realizer terminalOutputEntry :=
(pair (composition (pair first (composition second first))
(optionCases (constant none) outerTrialRealizer)) (composition second second)).congr (by
rintro ⟨p,⟨o,n⟩⟩
cases o <;> rfl)
lemma polynomial_terminalOutputEntry : PolynomialTime terminalOutputEntryRealizer := by
unfold terminalOutputEntryRealizer
apply polynomial_congr
exact polynomial_pair (polynomial_composition (polynomial_pair polynomial_first
(polynomial_composition polynomial_second polynomial_first))
(polynomial_optionCases (polynomial_constant none) polynomial_outerTrial))
(polynomial_composition polynomial_second polynomial_second)
def terminalOutputs (z : TransitionCache) : List (Option MatrixCode×ℕ) :=
z.2.2.map (fun entry => terminalOutputEntry (z.1.1,entry))
def terminalOutputsRealizer : Realizer terminalOutputs :=
composition (pair (composition first first) (composition second second))
(mapWith terminalOutputEntryRealizer)
lemma polynomial_terminalOutputs : PolynomialTime terminalOutputsRealizer :=
polynomial_composition (polynomial_pair
(polynomial_composition polynomial_first polynomial_first)
(polynomial_composition polynomial_second polynomial_second))
(polynomial_mapWith polynomial_terminalOutputEntry)
def successfulWeight (z : MatrixCode×(Option MatrixCode×ℕ)) : ℕ :=
z.2.1.elim 0 (fun X => if X=z.1 then z.2.2 else 0)
def successfulWeightRealizer : Realizer successfulWeight := by
let input : Realizer (fun z : MatrixCode×(Option MatrixCode×ℕ) =>
((z.1,z.2.2),z.2.1)) := pair (pair first (composition second second))
(composition second first)
let test : Realizer (fun z : (MatrixCode×ℕ)×MatrixCode => decide (z.2=z.1.1)) :=
composition (pair second (composition first first)) matrixEqual
let result := choose test (composition first second) (constant 0)
exact (composition input (optionCases (constant 0) result)).congr (by
intro z
simp only [Function.comp_apply,decide_eq_true_eq]
rfl)
lemma polynomial_successfulWeight : PolynomialTime successfulWeightRealizer := by
unfold successfulWeightRealizer
apply polynomial_congr
exact polynomial_composition (polynomial_pair (polynomial_pair polynomial_first
(polynomial_composition polynomial_second polynomial_second))
(polynomial_composition polynomial_second polynomial_first))
(polynomial_optionCases (polynomial_constant 0) (polynomial_choose
(polynomial_composition (polynomial_pair polynomial_second
(polynomial_composition polynomial_first polynomial_first)) polynomial_matrixEqual)
(polynomial_composition polynomial_first polynomial_second) (polynomial_constant 0)))
def successfulWeightSum (z : MatrixCode×List (Option MatrixCode×ℕ)) : ℕ :=
(z.2.map (fun entry => successfulWeight (z.1,entry))).sum
def successfulWeightSumRealizer : Realizer successfulWeightSum :=
composition (mapWith successfulWeightRealizer) listSum
lemma polynomial_successfulWeightSum : PolynomialTime successfulWeightSumRealizer :=
polynomial_composition (polynomial_mapWith polynomial_successfulWeight) polynomial_listSum
def terminalCount (z : TransitionCache×MatrixCode) : ℕ :=
z.1.2.1*successfulWeightSum (z.2,terminalOutputs z.1)
def terminalCountRealizer : Realizer terminalCount :=
composition (pair (composition (composition first second) first)
(composition (pair second (composition first terminalOutputsRealizer))
successfulWeightSumRealizer)) multiply
lemma polynomial_terminalCount : PolynomialTime terminalCountRealizer :=
polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_composition polynomial_first polynomial_second) polynomial_first)
(polynomial_composition (polynomial_pair polynomial_second
(polynomial_composition polynomial_first polynomial_terminalOutputs)) polynomial_successfulWeightSum))
polynomial_multiply
end ContingencyTables.ProfilePrograms
namespace ContingencyTables.ProfilePrograms
open DensePrograms
lemma terminalCount_eq (p : ResidualParameters) (M : ℕ)
(entries : List (Option MatrixCode×ℕ)) (target : MatrixCode) :
terminalCount ((p,(M,entries)),target)=
M*(entries.map (fun entry => entry.1.elim 0
(fun X => if outerTrial (p.1,X)=some target then entry.2 else 0))).sum := by
unfold terminalCount terminalOutputs successfulWeightSum
rw [List.map_map]
congr 2
apply List.map_congr_left
rintro ⟨o,n⟩ _
cases o with
| none => rfl
| some X =>
simp only [Function.comp_apply,terminalOutputEntry,Option.bind_some,successfulWeight,
Option.elim_some]
cases outerTrial (p.1,X) with
| none => rfl
| some Y => simp only [Option.elim_some,Option.some.injEq]
end ContingencyTables.ProfilePrograms
end OAI
|