openAI-math-dataset / lean /OAI /Combinatorics /MatchingCount /Algorithm /TreeGeneratedCertificate.lean
| 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 | |