File size: 6,581 Bytes
e5a97c6 | 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Algorithm.TreeGeneratedUpdate
namespace OAI
namespace MatchingFPRAS.NumericMarking
open TreeTyped TreeFraction TreeTyped.Numbered ExecutableMarking ExecutableStatistics
lemma numeric_observableD_rep {E : Type} [Fintype E] [LinearOrder E]
(s : Finset E) (m : E→Fin 3) (r : E→ℚ) (hr : ∀ e,0≤r e) :
ExecutableMarking.observableD reweight (reweightsRep r,numericMarks s m)=
TreeFraction.repr (if ∀ e∈s,m e=0 then ∏ e∈s,r e else 0) := by
rw [numericMarks_eq,observableD_rep reweight (reweightsRep r) (extend 1 r)
(extend_nonneg r hr) (reweight_rep r)]
apply congrArg TreeFraction.repr
simpa only [scalarD] using scalarD_numbered (fun _ : Fin 1=>s) (fun _ : Fin 1=>m) r 0
end MatchingFPRAS.NumericMarking
namespace MatchingFPRAS.TreeTyped
variable {A B C : Type} [Codec A] [Codec B] [Codec C]
def applyFirst {f : A→C} (F : Realizer f) : Realizer (fun x : A×B=>f x.1) :=
composition first F
lemma polynomial_applyFirst {f : A→C} {F : Realizer f} (hF : PolynomialTime F) :
PolynomialTime (applyFirst (B:=B) F) := polynomial_composition polynomial_first hF
end MatchingFPRAS.TreeTyped
namespace MatchingFPRAS.ExecutableSource
open TreeTyped TreeFraction TreeTyped.Numbered ExecutableBottleneck ExecutableHierarchy ExecutableRefresh Enlargement RealGeometry NumericLadder
open ExecutableMarking ExecutableLadder UnitRefresh Replica.Ladder Transport NumericMarking ExecutableStatistics ExecutableScaling ExecutableAdaptive
attribute [local instance] NumberedHierarchy.labelOrder
attribute [local instance] Transport.sym2Order Transport.bagEdgeOrder Transport.bagEdgeFintype
attribute [local instance] UnitRefresh.Computable.allowedDec Transport.prodOrder Transport.sumOrder
abbrev GeneratedCertificateInput := GeneratedStageData×SampleBits
def generatedCertificate (x : GeneratedCertificateInput) : Fraction :=
ExecutableMarking.observableD reweight (generatedReweights x.1,generatedMarked (x.1.1,x.2))
def certificateSampleArg (x : GeneratedCertificateInput) : GeneratedInput×SampleBits := (x.1.1,x.2)
def certificateSampleArgRealizer : Realizer certificateSampleArg :=
(TreeTyped.pair (first (A:=GeneratedStageData) (B:=SampleBits)).fst second).congr (fun _=>rfl)
lemma polynomial_certificateSampleArg : PolynomialTime certificateSampleArgRealizer :=
polynomial_congr _ (TreeTyped.polynomial_pair (polynomial_fst polynomial_first) polynomial_second)
def certificateSample (x : GeneratedCertificateInput) : ExecutableMarking.Marks ℕ := generatedMarked (certificateSampleArg x)
def certificateSampleRealizer : Realizer certificateSample :=
(composition certificateSampleArgRealizer generatedMarkedRealizer).congr (fun _=>rfl)
lemma polynomial_certificateSample : PolynomialTime certificateSampleRealizer :=
polynomial_congr _ (polynomial_composition polynomial_certificateSampleArg polynomial_generatedMarked)
def certificateReweights (x : GeneratedCertificateInput) : Reweights := generatedReweights x.1
def certificateReweightsRealizer : Realizer certificateReweights :=
applyFirst (B:=SampleBits) generatedReweightsRealizer
lemma polynomial_certificateReweights : PolynomialTime certificateReweightsRealizer :=
polynomial_applyFirst polynomial_generatedReweights
def certificateArgs (x : GeneratedCertificateInput) : Reweights×ExecutableMarking.Marks ℕ :=
(certificateReweights x,certificateSample x)
def certificateArgsRealizer : Realizer certificateArgs :=
(TreeTyped.pair certificateReweightsRealizer certificateSampleRealizer).congr (fun _=>rfl)
lemma polynomial_certificateArgs : PolynomialTime certificateArgsRealizer :=
polynomial_congr _ (TreeTyped.polynomial_pair polynomial_certificateReweights polynomial_certificateSample)
def generatedCertificateRealizer : Realizer generatedCertificate :=
(composition (f:=certificateArgs) (g:=ExecutableMarking.observableD reweight)
certificateArgsRealizer (observableDRealizer reweightRealizer)).congr (fun _=>rfl)
lemma polynomial_generatedCertificate : PolynomialTime generatedCertificateRealizer :=
polynomial_congr _ (polynomial_composition polynomial_certificateArgs (polynomial_observableD polynomial_reweight))
lemma numeric_certificate_source {n : ℕ} [Nontrivial (Fin n)]
(w w₁ : Fin n→Fin n→ℚ) (hw : ∀ a b,0≤w a b) (hw₁ : ∀ a b,0≤w₁ a b)
(K : ℕ) (x : RationalSource.Marked w K) :
ExecutableMarking.observableD reweight (reweightsRep (RationalSource.bagReweight w w₁ K),
numericMarks x.1.val (selectedMarks x.1.val x.2))=
TreeFraction.repr (RationalSource.observableD w w₁ K x) := by
rw [numeric_observableD_rep _ _ _ (reweight_nonneg w w₁ hw hw₁ K)]
apply congrArg TreeFraction.repr
unfold RationalSource.observableD
simp only [selectedMarks_eq]
lemma generatedCertificate_source {n : ℕ} [Nontrivial (Fin n)]
(hn : 2≤n) (he : Even n) (w w₁ : Fin n→Fin n→ℚ)
(hw : ∀ a b,0<w a b) (hw₁ : ∀ a b,0≤w₁ a b) (K D : ℕ) (hD : 0<D)
(hu : ∀ a b,a≠b→BottleneckAlgorithm.edge w a b≤(4:ℚ)^K)
(ft fq : List Bool) (hq : 0<fq.length) {k r km : ℕ}
(bits : Fin r→ScanBits (SourceVertex (Fin n) K) k)
(mb : BagEdge (RationalSource.bags w K)→Fin km→Bool) :
generatedCertificate
(((((((matrixRep w,List.replicate (2*K+2) false),List.range n),List.replicate (2*K) false),D),(ft,fq)),matrixRep w₁),
(List.ofFn (fun z=>(List.ofFn (bits z).1,localBitsRep (bits z).2)),
(List.ofFn (orderedEnum (BagEdge (RationalSource.bags w K)))).map (fun e=>(index e,List.ofFn (mb e)))))=
TreeFraction.repr (RationalSource.observableD w w₁ K
(generatedSourceSample he w hw K D hD hu ft fq hq bits mb)) := by
unfold generatedCertificate generatedReweights
dsimp only
rw [sourceReweights_source hn w w₁ (fun a b=>(hw a b).le) hw₁ K,
generatedMarked_sourceSample hn he w hw K D hD hu ft fq hq bits mb]
exact numeric_certificate_source w w₁ (fun a b=>(hw a b).le) hw₁ K _
open TreePost Turing
theorem generatedCertificate_post : ∃ p : Polynomial ℕ,∀ x : GeneratedCertificateInput,∀ t : ℕ,
p.eval (packed x).length≤t → ∀ coins : Fin t→Bool,
(run (machine generatedCertificateRealizer.program) (packed x) coins).state=none ∧
(run (machine generatedCertificateRealizer.program) (packed x) coins).tape.right₀=
ListBlank.mk (packed (generatedCertificate x)) :=
polynomial_compiles generatedCertificateRealizer polynomial_generatedCertificate
end MatchingFPRAS.ExecutableSource
end OAI
|