File size: 6,312 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 | import OAI.Combinatorics.ContingencyTables.Counting.CompanionRestartProgram
import OAI.Combinatorics.ContingencyTables.Counting.CompanionRestartInitializer
import OAI.Combinatorics.ContingencyTables.Counting.CompanionPhaseFinishProgram
namespace OAI
/-! # Initialization and all stored-multiplier restart stages
Past entries are stored in chronological order. Entry i contains the
multiplier for restart phase i+1. Initialization and restart stages take
disjoint slices of the supplied word.
-/
namespace ContingencyTables.CompanionInitializedRestartProgram
open MatchingFPRAS MatchingFPRAS.TreeTyped Polynomial
abbrev Prepared := CompanionPhaseContextProgram.Prepared
abbrev Stored := CompanionPhaseFinishProgram.Stored
abbrev Input := (Prepared×List Stored)×List Bool
def reserve (z : Input) : List Bool := z.2.map (fun _ => false)
def reserveRealizer : Realizer reserve := composition second (map (constant false))
lemma polynomial_reserve : PolynomialTime reserveRealizer :=
polynomial_composition polynomial_second (polynomial_map (polynomial_constant false))
def indices (z : Input) : List ℕ := List.range z.1.2.length
def indicesRealizer : Realizer indices :=
composition (composition (composition first second) listLength) range
lemma polynomial_indices : PolynomialTime indicesRealizer := by
apply polynomial_boundedRange
(polynomial_composition (polynomial_composition polynomial_first polynomial_second) polynomial_listLength) X
intro z
simpa only [Function.comp_apply,eval_X] using
(list_length_le_weight z.1.2).trans ((weight_snd z.1).trans (weight_fst z))
def stageAt (z : Input×ℕ) : CompanionRestartProgram.Stage :=
(((z.1.1.1,z.2+1),reserve z.1),(z.1.1.2.getD z.2 default).1)
def stageAtRealizer : Realizer stageAt := by
let prepared : Realizer (fun z : Input×ℕ => z.1.1.1) := composition (composition first first) first
let phase : Realizer (fun z : Input×ℕ => z.2+1) := composition second successor
let marker : Realizer (fun z : Input×ℕ => reserve z.1) :=
composition (f := fun z : Input×ℕ => z.1) (g := reserve) first reserveRealizer
let stored : Realizer (fun z : Input×ℕ => z.1.1.2.getD z.2 (default : Stored)) :=
composition (f := fun z : Input×ℕ => (z.1.1.2,z.2))
(g := fun p : List Stored×ℕ => p.1.getD p.2 default)
(pair (composition (composition first first) second) second) (getDFast default)
exact pair (pair (pair prepared phase) marker) (composition (f := fun z : Input×ℕ =>
z.1.1.2.getD z.2 (default : Stored)) (g := Prod.fst) stored first)
lemma polynomial_stageAt : PolynomialTime stageAtRealizer := by
unfold stageAtRealizer
apply polynomial_pair
· exact polynomial_pair (polynomial_pair
(polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_first)
(polynomial_composition polynomial_second polynomial_successor))
(polynomial_composition polynomial_first polynomial_reserve)
· exact polynomial_composition (polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_second)
polynomial_second) (polynomial_getDFast default)) polynomial_first
def stages (z : Input) : List CompanionRestartProgram.Stage :=
(indices z).map (fun i => stageAt (z,i))
def stagesRealizer : Realizer stages := composition (pair identity indicesRealizer) (mapWith stageAtRealizer)
lemma polynomial_stages : PolynomialTime stagesRealizer :=
polynomial_composition (polynomial_pair polynomial_identity polynomial_indices)
(polynomial_mapWith polynomial_stageAt)
def initialWidth (z : Input) : ℕ := CompanionRestartInitializer.width z.1.1
def initialWidthRealizer : Realizer initialWidth :=
composition (f := fun z : Input => z.1.1) (g := CompanionRestartInitializer.width)
(composition first first) CompanionRestartInitializer.widthRealizer
lemma polynomial_initialWidth : PolynomialTime initialWidthRealizer :=
polynomial_composition (polynomial_composition polynomial_first polynomial_first)
CompanionRestartInitializer.polynomial_width
def initialInput (z : Input) : CompanionRestartInitializer.Input :=
(z.1.1,z.2.take (initialWidth z))
def initialInputRealizer : Realizer initialInput :=
pair (composition first first)
(composition (f := fun z : Input => (z.2,initialWidth z))
(g := fun p : List Bool×ℕ => p.1.take p.2) (pair second initialWidthRealizer) takeFast)
lemma polynomial_initialInput : PolynomialTime initialInputRealizer :=
polynomial_pair (polynomial_composition polynomial_first polynomial_first)
(polynomial_composition (polynomial_pair polynomial_second polynomial_initialWidth) polynomial_takeFast)
def initialCode (z : Input) : List ℕ := CompanionRestartInitializer.output (initialInput z)
def initialCodeRealizer : Realizer initialCode :=
composition (f := initialInput) (g := CompanionRestartInitializer.output)
initialInputRealizer CompanionRestartInitializer.outputRealizer
lemma polynomial_initialCode : PolynomialTime initialCodeRealizer :=
polynomial_composition polynomial_initialInput CompanionRestartInitializer.polynomial_output
attribute [local irreducible] stages initialCode initialWidth
def prepare (z : Input) : CompanionRestartProgram.Input :=
((stages z,initialCode z),z.2.drop (initialWidth z))
def prepareRealizer : Realizer prepare :=
pair (pair stagesRealizer initialCodeRealizer)
(composition (f := fun z : Input => (z.2,initialWidth z))
(g := fun p : List Bool×ℕ => p.1.drop p.2) (pair second initialWidthRealizer) dropFast)
lemma polynomial_prepare : PolynomialTime prepareRealizer :=
polynomial_pair (polynomial_pair polynomial_stages polynomial_initialCode)
(polynomial_composition (polynomial_pair polynomial_second polynomial_initialWidth) polynomial_dropFast)
def output (z : Input) : List ℕ := CompanionRestartProgram.output (prepare z)
def outputRealizer : Realizer output :=
composition (f := prepare) (g := CompanionRestartProgram.output)
prepareRealizer CompanionRestartProgram.outputRealizer
theorem polynomial_output : PolynomialTime outputRealizer :=
polynomial_composition polynomial_prepare CompanionRestartProgram.polynomial_output
end ContingencyTables.CompanionInitializedRestartProgram
end OAI
|