Download data/lean/OAI/Computability/PerfectCompleteness/Decoding/CleanLeftDecoderLemmas.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 26.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/PerfectCompleteness/Decoding/CleanLeftDecoderLemmas.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/PerfectCompleteness/Decoding/CleanLeftDecoderLemmas.lean
-
curl -L -o CleanLeftDecoderLemmas.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/PerfectCompleteness/Decoding/CleanLeftDecoderLemmas.lean
26.2 kB
| import OAI.Computability.PerfectCompleteness.Decoding.DecoderSourcePullback | |
| import OAI.Computability.PerfectCompleteness.Decoding.HierarchicalLeftDecoder | |
| import OAI.Computability.PerfectCompleteness.Decoding.RightDecoderLemmas | |
| import OAI.Computability.PerfectCompleteness.Decoding.TwoResponseCollisionLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.WholeCutReplayLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.WholeReplaySubtreeLemmas | |
| import OAI.Computability.PerfectCompleteness.Repetition.CleanEndpointSlots | |
| import OAI.Computability.PerfectCompleteness.Sampling.RecursiveSamplerLaws | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.CleanLeftDecoder | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays PointwiseSpaces | |
| open UniqueGamesTheorem.Foundations.Games | |
| structure Exposed (branch rows repeats : Nat β Nat) (n h t v m : Nat) [NeZero m] where | |
| clauses : Fin m β SourceClause.NormalizedClause v | |
| designated : Fin (branch h) β Slots branch h | |
| clean : Fin (branch h) β Prop | |
| visible : SourceQuestionReconstruction.Visible | |
| (E := SourceQuestionReconstruction.SourceTuple m t) designated clean | |
| path : Path branch n (h + 1) | |
| outside : Slots branch n β Fin t β MixedSupport.Slot | |
| tape : WholeCutReplay.Tape rows repeats path | |
| (CutSlotAssembly.fill path outside | |
| (CleanEndpointSlots.leftReference clauses designated clean visible)) clean | |
| variable {branch rows repeats : Nat β Nat} {n h t v m : Nat} [NeZero m] | |
| (E : Exposed branch rows repeats n h t v m) | |
| abbrev Own := {i : Fin (branch h) // E.clean i} β Fin t β Fin m | |
| instance ownFintype : Fintype (Own E) := Fintype.ofFinite _ | |
| def slots (own : Own E) : Slots branch n β Fin t β MixedSupport.Slot := | |
| CleanEndpointSlots.leftSlots E.clauses E.designated E.clean E.visible E.path E.outside own | |
| def replay (own : Own E) : WholeCutReplay.Tape rows repeats E.path (slots E own) E.clean := | |
| CleanEndpointSlots.leftReplay E.clauses E.designated E.clean E.visible | |
| rows repeats E.path E.outside E.tape own | |
| def arrays (own : Own E) : Arrays (slots E own) rows := | |
| WholeCutReplay.evaluateArrays rows repeats E.path (slots E own) E.clean (replay E own) | |
| variable (upper : Nodes branch n) (lowerLevel : Nat) | |
| def background (own : Own E) : | |
| HierarchicalMatrixTable.Background (rows := rows) (slots E own) upper := | |
| HierarchicalMatrixTable.backgroundOf (slots E own) upper (arrays E own) | |
| def upperMatrix (own : Own E) : | |
| HierarchicalMatrixTable.Matrix (rows := rows) (slots E own) upper := | |
| NodeEmbedding.matrix (arrays E own) upper | |
| def quotientMatrix (own : Own E) : | |
| HierarchicalFrozenTables.QuotientMatrix (slots E own) upper lowerLevel | |
| (background E upper own) := | |
| MatrixRowQuotient.projectMatrix | |
| (HierarchicalFrozenTables.knownRows (slots E own) upper lowerLevel (background E upper own)) | |
| (upperMatrix E upper own) | |
| abbrev QuotientAdvice (r : Nat) (own : Own E) := | |
| Module.Dual F2 (NodeEmbedding.RowSpace (slots E own) upper β§Έ | |
| HierarchicalFrozenTables.knownRows (slots E own) upper lowerLevel (background E upper own)) | |
| ββ[F2] (Fin r β F2) | |
| def advice (r : Nat) (A : ManyGoodRows.RowMap (Block rows upper) r) (own : Own E) : | |
| ManyGoodRows.RowMap (Block rows upper) r Γ QuotientAdvice E upper lowerLevel r own := | |
| (A, A.comp (quotientMatrix E upper lowerLevel own)) | |
| abbrev UpperAnswer (own : Own E) := Module.Dual F2 (NodeEmbedding.RowSpace (slots E own) upper) | |
| local instance rowSpaceFintype (own : Own E) (node : Nodes branch n) : | |
| Fintype (NodeEmbedding.RowSpace (slots E own) node) := Fintype.ofFinite _ | |
| local instance nodeSpaceFintype (own : Own E) (node : Nodes branch n) : | |
| Fintype (NodeEmbedding.NodeH (slots E own) node) := Fintype.ofFinite _ | |
| instance upperAnswerFintype (own : Own E) : Fintype (UpperAnswer E upper own) := | |
| LeftDecoder.dualFintype (V := NodeEmbedding.RowSpace (slots E own) upper) | |
| abbrev Useful := (own : Own E) β | |
| HierarchicalFrozenTables.QuotientMatrix (slots E own) upper lowerLevel | |
| (background E upper own) β Prop | |
| variable (Ο : KeyStrategy.Strategy (TreeCanonical.locationCount branch n t)) | |
| (useful : Useful E upper lowerLevel) | |
| def law (r : Nat) (Ο : β) (A : ManyGoodRows.RowMap (Block rows upper) r) (own : Own E) : | |
| FiniteDistribution (UpperAnswer E upper own) := | |
| HierarchicalLeftDecoder.adviceLaw (slots E own) upper lowerLevel (background E upper own) | |
| Ο (useful own) r Ο (advice E upper lowerLevel r A own).1 | |
| (advice E upper lowerLevel r A own).2 | |
| abbrev Seed := (own : Own E) β UpperAnswer E upper own | |
| def seedLaw (r : Nat) (Ο : β) (A : ManyGoodRows.RowMap (Block rows upper) r) : | |
| FiniteDistribution (Seed E upper) := | |
| FiniteProduct.law (I := Own E) (Ξ© := UpperAnswer E upper) | |
| (law E upper lowerLevel Ο useful r Ο A) | |
| theorem seedLaw_marginal (r : Nat) (Ο : β) | |
| (A : ManyGoodRows.RowMap (Block rows upper) r) (own : Own E) : | |
| (seedLaw E upper lowerLevel Ο useful r Ο A).pushforward (fun seed => seed own) = | |
| law E upper lowerLevel Ο useful r Ο A own := | |
| FiniteProduct.eval_pushforward (I := Own E) (Ξ© := UpperAnswer E upper) | |
| (law E upper lowerLevel Ο useful r Ο A) own | |
| theorem supported_row (r : Nat) (Ο : β) | |
| (A : ManyGoodRows.RowMap (Block rows upper) r) (seed : Seed E upper) | |
| (hsupport : (seedLaw E upper lowerLevel Ο useful r Ο A).weight seed β 0) | |
| (own : Own E) : (law E upper lowerLevel Ο useful r Ο A own).weight (seed own) β 0 := by | |
| intro hz | |
| apply hsupport | |
| change (β q, (law E upper lowerLevel Ο useful r Ο A q).weight (seed q)) = 0 | |
| exact Finset.prod_eq_zero (Finset.mem_univ own) hz | |
| variable (hbranch : β k < n, 0 < branch k) | |
| theorem law_valid (r : Nat) (Ο : β) (hΟ : 0 < Ο) | |
| (A : ManyGoodRows.RowMap (Block rows upper) r) (own : Own E) : | |
| (law E upper lowerLevel Ο useful r Ο A own).probability | |
| (fun q => decide (HierarchicalLeftDecoder.Valid (slots E own) upper lowerLevel | |
| hbranch (background E upper own) q)) = 1 := | |
| HierarchicalLeftDecoder.adviceLaw_valid (slots E own) upper lowerLevel hbranch | |
| (background E upper own) Ο (useful own) r Ο hΟ | |
| (advice E upper lowerLevel r A own).1 (advice E upper lowerLevel r A own).2 | |
| theorem supported_seed_valid (r : Nat) (Ο : β) (hΟ : 0 < Ο) | |
| (A : ManyGoodRows.RowMap (Block rows upper) r) (seed : Seed E upper) | |
| (hsupport : (seedLaw E upper lowerLevel Ο useful r Ο A).weight seed β 0) | |
| (own : Own E) : | |
| HierarchicalLeftDecoder.Valid (slots E own) upper lowerLevel hbranch | |
| (background E upper own) (seed own) := by | |
| exact of_decide_eq_true (DecoderTableAdmissibility.event_of_probability_one | |
| (law E upper lowerLevel Ο useful r Ο A own) | |
| (fun q => decide (HierarchicalLeftDecoder.Valid (slots E own) upper lowerLevel | |
| hbranch (background E upper own) q)) | |
| (law_valid E upper lowerLevel Ο useful hbranch r Ο hΟ A own) (seed own) | |
| (supported_row E upper lowerLevel Ο useful r Ο A seed hsupport own)) | |
| theorem seedLaw_valid (r : Nat) (Ο : β) (hΟ : 0 < Ο) | |
| (A : ManyGoodRows.RowMap (Block rows upper) r) : | |
| (seedLaw E upper lowerLevel Ο useful r Ο A).probability | |
| (fun seed => decide (β own : Own E, | |
| HierarchicalLeftDecoder.Valid (slots E own) upper lowerLevel hbranch | |
| (background E upper own) (seed own))) = 1 := by | |
| apply DecoderTableAdmissibility.probability_one_of_support | |
| intro seed hs | |
| exact decide_eq_true (supported_seed_valid E upper lowerLevel Ο useful hbranch | |
| r Ο hΟ A seed hs) | |
| abbrev LowerH (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) (own : Own E) := | |
| NodeEmbedding.NodeH (slots E own) (HierarchicalLeftDecoder.LowerNode upper lowerLevel d) | |
| abbrev LowerAnswer (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) (own : Own E) := | |
| Module.Dual F2 (squareSpace (LowerH E upper lowerLevel d own)) | |
| instance lowerAnswerFintype (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) | |
| (own : Own E) : Fintype (LowerAnswer E upper lowerLevel d own) := | |
| LeftDecoder.dualFintype (V := squareSpace (LowerH E upper lowerLevel d own)) | |
| def output (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) (own : Own E) | |
| (q : UpperAnswer E upper own) : LowerAnswer E upper lowerLevel d own := | |
| HierarchicalLeftDecoder.output (slots E own) upper lowerLevel hbranch d q | |
| def form (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) (own : Own E) | |
| (q : UpperAnswer E upper own) : | |
| LowerH E upper lowerLevel d own ββ[F2] LowerH E upper lowerLevel d own ββ[F2] F2 := | |
| OddListExtraction.multiplicationForm (LowerH E upper lowerLevel d own) | |
| (output E upper lowerLevel hbranch d own q) | |
| def formFamily (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) (seed : Seed E upper) : | |
| (own : Own E) β | |
| LowerH E upper lowerLevel d own ββ[F2] LowerH E upper lowerLevel d own ββ[F2] F2 := | |
| fun own => form E upper lowerLevel hbranch d own (seed own) | |
| def outputLaw (r : Nat) (Ο : β) (A : ManyGoodRows.RowMap (Block rows upper) r) | |
| (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) (own : Own E) : | |
| FiniteDistribution (LowerAnswer E upper lowerLevel d own) := | |
| (law E upper lowerLevel Ο useful r Ο A own).pushforward | |
| (output E upper lowerLevel hbranch d own) | |
| theorem seedLaw_output_marginal (r : Nat) (Ο : β) | |
| (A : ManyGoodRows.RowMap (Block rows upper) r) | |
| (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) (own : Own E) : | |
| (seedLaw E upper lowerLevel Ο useful r Ο A).pushforward | |
| (fun seed => output E upper lowerLevel hbranch d own (seed own)) = | |
| outputLaw E upper lowerLevel Ο useful hbranch r Ο A d own := by | |
| calc | |
| _ = ((seedLaw E upper lowerLevel Ο useful r Ο A).pushforward | |
| (fun seed : Seed E upper => seed own)).pushforward | |
| (output E upper lowerLevel hbranch d own) := | |
| (FiniteDistribution.pushforward_comp (seedLaw E upper lowerLevel Ο useful r Ο A) | |
| (fun seed : Seed E upper => seed own) (output E upper lowerLevel hbranch d own)).symm | |
| _ = _ := by rw [seedLaw_marginal]; rfl | |
| theorem supported_output_normalized (r : Nat) (Ο : β) (hΟ : 0 < Ο) | |
| (A : ManyGoodRows.RowMap (Block rows upper) r) (seed : Seed E upper) | |
| (hsupport : (seedLaw E upper lowerLevel Ο useful r Ο A).weight seed β 0) | |
| (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) (own : Own E) : | |
| output E upper lowerLevel hbranch d own (seed own) | |
| (HierarchicalLeftDecoder.lowerOne (slots E own) upper lowerLevel hbranch d) = 1 := | |
| (supported_seed_valid E upper lowerLevel Ο useful hbranch r Ο hΟ A seed hsupport own d).1 | |
| theorem supported_form_tested_rank (r : Nat) (Ο : β) (hΟ : 0 < Ο) | |
| (A : ManyGoodRows.RowMap (Block rows upper) r) (seed : Seed E upper) | |
| (hsupport : (seedLaw E upper lowerLevel Ο useful r Ο A).weight seed β 0) | |
| (d : HierarchicalFrozenTables.LowerNodes upper lowerLevel) (own : Own E) : | |
| (LowerAffineSliceRank.testedGram | |
| (FunctionSpaceLowerRank.matrixForm (LowerH E upper lowerLevel d own) | |
| (formFamily E upper lowerLevel hbranch d seed own)) | |
| (HierarchicalLeftDecoder.testedMatrix (slots E own) upper lowerLevel | |
| (background E upper own) d)).rank β€ 1 := | |
| (supported_seed_valid E upper lowerLevel Ο useful hbranch r Ο hΟ A seed hsupport own d).2 | |
| end | |
| end PerfectCompleteness.CleanLeftDecoder | |
| end | |
| section | |
| namespace PerfectCompleteness.CleanRightDecoder | |
| open scoped Classical | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays | |
| open UniqueGamesTheorem.Foundations.Games | |
| abbrev F2 := ZMod 2 | |
| noncomputable section | |
| variable {branch : Nat β Nat} {N h : Nat} | |
| def suffix (upper lower : Nodes branch N) (cut : OwnInputReference.Cut upper lower) | |
| (hlower : Nodes.height lower = h + 1) : Path branch (Nodes.height upper) (h + 1) := | |
| hlower βΈ cut.path | |
| theorem suffix_proper (upper lower : Nodes branch N) | |
| (cut : OwnInputReference.Cut upper lower) (hlower : Nodes.height lower = h + 1) : | |
| h + 1 < Nodes.height upper := by | |
| simpa only [hlower] using cut.proper | |
| def fullPath (upper lower : Nodes branch N) (cut : OwnInputReference.Cut upper lower) | |
| (hlower : Nodes.height lower = h + 1) : Path branch N (h + 1) := | |
| (Nodes.path upper).append (suffix upper lower cut hlower) | |
| variable {t v m : Nat} | |
| abbrev OwnQuestions (clean : Fin (branch h) β Prop) := | |
| {i : Fin (branch h) // clean i} β Fin t β Fin v | |
| variable [NeZero m] | |
| (clauses : Fin m β SourceClause.NormalizedClause v) | |
| (designated : Fin (branch h) β Slots branch h) | |
| (clean : Fin (branch h) β Prop) | |
| (visible : SourceQuestionReconstruction.Visible | |
| (E := SourceQuestionReconstruction.SourceTuple m t) designated clean) | |
| (projected : Fin (branch h) β Bool) | |
| (upper lower : Nodes branch N) (cut : OwnInputReference.Cut upper lower) | |
| (hlower : Nodes.height lower = h + 1) | |
| (outside : Slots branch N β Fin t β MixedSupport.Slot) | |
| def slots (own : OwnQuestions (t := t) (v := v) clean) : | |
| Slots branch N β Fin t β MixedSupport.Slot := | |
| CleanEndpointSlots.rightSlots clauses designated clean visible | |
| (fullPath upper lower cut hlower) outside projected own | |
| variable (rows repeats : Nat β Nat) | |
| abbrev Record := WholeCutReplay.Tape rows repeats (fullPath upper lower cut hlower) | |
| (CutSlotAssembly.fill (fullPath upper lower cut hlower) outside | |
| (CleanEndpointSlots.rightReference clauses designated clean visible projected)) clean | |
| variable (record : Record clauses designated clean visible projected | |
| upper lower cut hlower outside rows repeats) | |
| def replay (own : OwnQuestions (t := t) (v := v) clean) : | |
| WholeCutReplay.Tape rows repeats (fullPath upper lower cut hlower) | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) clean := | |
| CleanEndpointSlots.rightReplay clauses designated clean visible rows repeats | |
| (fullPath upper lower cut hlower) outside projected record own | |
| def arrays (own : OwnQuestions (t := t) (v := v) clean) : | |
| Arrays (slots clauses designated clean visible projected upper lower cut hlower outside own) rows := | |
| WholeCutReplay.evaluateArrays rows repeats (fullPath upper lower cut hlower) | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) clean | |
| (replay clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record own) | |
| def exterior (own : OwnQuestions (t := t) (v := v) clean) : | |
| OwnInputReference.Exterior | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) | |
| rows upper lower where | |
| otherArrays node := arrays clauses designated clean visible projected | |
| upper lower cut hlower outside rows repeats record own node.val | |
| lowerRows := arrays clauses designated clean visible projected | |
| upper lower cut hlower outside rows repeats record own lower | |
| variable (W : Submodule F2 (OwnInputReference.UpperVector rows upper)) | |
| (a : OwnInputReference.LowerVector rows lower) | |
| def knownBuckets (own : OwnQuestions (t := t) (v := v) clean) : | |
| HiddenBucketBias.VisibleDirection W β | |
| OwnInputReference.UpperSpace | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) upper := | |
| WholeReplaySubtree.knownBucketsAtNode rows repeats | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) | |
| upper (suffix upper lower cut hlower) (suffix_proper upper lower cut hlower) clean W | |
| (replay clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record own) | |
| def input (own : OwnQuestions (t := t) (v := v) clean) : | |
| OwnInputReference.Input | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) | |
| rows upper lower W a := | |
| OwnInputReference.readInput | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) | |
| rows upper lower W a id | |
| (knownBuckets clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W own, | |
| exterior clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record own) | |
| @[simp] theorem input_knownBuckets (own : OwnQuestions (t := t) (v := v) clean) : | |
| (input clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a own).knownBuckets = | |
| knownBuckets clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W own := rfl | |
| @[simp] theorem input_otherArrays (own : OwnQuestions (t := t) (v := v) clean) | |
| (node : OwnInputReference.OtherNodes upper lower) : | |
| (input clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a own).otherArrays node = | |
| arrays clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record own node.val := rfl | |
| @[simp] theorem input_lowerQuotient (own : OwnQuestions (t := t) (v := v) clean) | |
| (x : Domain (nodeSlots | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) lower)) : | |
| (input clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a own).lowerQuotient x = | |
| DirectionQuotient.proj a (fun row => | |
| (arrays clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record own lower row).val x) := rfl | |
| abbrev Answer (own : OwnQuestions (t := t) (v := v) clean) := | |
| Module.Dual F2 (OwnInputReference.UpperSpace | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) upper) | |
| local instance answerFintype (own : OwnQuestions (t := t) (v := v) clean) : | |
| Fintype (Answer clauses designated clean visible projected upper lower cut hlower outside own) := | |
| RightDecoder.scalarFintype | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) upper | |
| variable (labeling : KeyStrategy.Strategy (TreeCanonical.locationCount branch N t)) | |
| (threshold : β) | |
| def kernel (own : OwnQuestions (t := t) (v := v) clean) : | |
| FiniteDistribution (Answer clauses designated clean visible projected | |
| upper lower cut hlower outside own) := | |
| RightDecoder.law | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) | |
| rows upper lower W a repeats cut labeling | |
| (input clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a own) threshold | |
| abbrev Seed := (own : OwnQuestions (t := t) (v := v) clean) β | |
| Answer clauses designated clean visible projected upper lower cut hlower outside own | |
| def seedLaw : FiniteDistribution | |
| (Seed clauses designated clean visible projected upper lower cut hlower outside) := | |
| FiniteProduct.law | |
| (kernel clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a labeling threshold) | |
| theorem seedLaw_eval (own : OwnQuestions (t := t) (v := v) clean) : | |
| (seedLaw clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a labeling threshold).pushforward (fun seed => seed own) = | |
| kernel clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a labeling threshold own := | |
| FiniteProduct.eval_pushforward | |
| (kernel clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a labeling threshold) own | |
| variable (hbranch : β k < Nodes.height upper, 0 < branch k) | |
| abbrev Form (own : OwnQuestions (t := t) (v := v) clean) := | |
| RightDecoderDescendant.Form | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) lower | |
| local instance formFintype (own : OwnQuestions (t := t) (v := v) clean) : | |
| Fintype (Form clauses designated clean visible projected upper lower cut hlower outside own) := | |
| RightDecoderDescendant.formFintype | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) lower | |
| def forms (seed : Seed clauses designated clean visible projected upper lower cut hlower outside) | |
| (own : OwnQuestions (t := t) (v := v) clean) : | |
| Form clauses designated clean visible projected upper lower cut hlower outside own := | |
| RightDecoderDescendant.form | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) | |
| upper lower cut hbranch (seed own) | |
| def formKernel (own : OwnQuestions (t := t) (v := v) clean) : | |
| FiniteDistribution (Form clauses designated clean visible projected | |
| upper lower cut hlower outside own) := | |
| RightDecoderDescendant.formLaw | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) | |
| upper lower cut hbranch rows W a repeats labeling | |
| (input clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a own) threshold | |
| theorem seedLaw_forms (own : OwnQuestions (t := t) (v := v) clean) : | |
| (seedLaw clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a labeling threshold).pushforward | |
| (fun seed => forms clauses designated clean visible projected upper lower cut hlower outside | |
| hbranch seed own) = | |
| formKernel clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a labeling threshold hbranch own := by | |
| let decode := RightDecoderDescendant.form | |
| (slots clauses designated clean visible projected upper lower cut hlower outside own) | |
| upper lower cut hbranch | |
| change (seedLaw clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a labeling threshold).pushforward | |
| (fun seed => decode (seed own)) = _ | |
| rw [β FiniteDistribution.pushforward_comp | |
| (seedLaw clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a labeling threshold) | |
| (fun seed : Seed clauses designated clean visible projected | |
| upper lower cut hlower outside => seed own) decode, | |
| seedLaw_eval clauses designated clean visible projected upper lower cut hlower outside | |
| rows repeats record W a labeling threshold own] | |
| rfl | |
| end | |
| end PerfectCompleteness.CleanRightDecoder | |
| end | |
| section | |
| namespace PerfectCompleteness.CleanDecoderContext | |
| noncomputable section | |
| open scoped Classical | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays | |
| abbrev F2 := ZMod 2 | |
| variable {branch : Nat β Nat} {n h : Nat} | |
| theorem lowerHeight (upper : Nodes branch n) | |
| (d : HierarchicalFrozenTables.LowerNodes upper (h + 1)) : | |
| Nodes.height (HierarchicalLeftDecoder.LowerNode upper (h + 1) d) = h + 1 := | |
| (RelativeDescendantProducts.relativeNode_height upper d.val.val).trans d.property | |
| structure Exposed (branch rows repeats : Nat β Nat) (n h t v m : Nat) [NeZero m] | |
| (upper : Nodes branch n) (d : HierarchicalFrozenTables.LowerNodes upper (h + 1)) where | |
| clauses : Fin m β SourceClause.NormalizedClause v | |
| designated : Fin (branch h) β Slots branch h | |
| clean : Fin (branch h) β Prop | |
| visible : SourceQuestionReconstruction.Visible | |
| (E := SourceQuestionReconstruction.SourceTuple m t) designated clean | |
| projected : Fin (branch h) β Bool | |
| cleanProjected : β i, clean i β projected i = true | |
| cut : OwnInputReference.Cut upper (HierarchicalLeftDecoder.LowerNode upper (h + 1) d) | |
| outside : Slots branch n β Fin t β MixedSupport.Slot | |
| leftTape : WholeCutReplay.Tape rows repeats | |
| (CleanRightDecoder.fullPath upper (HierarchicalLeftDecoder.LowerNode upper (h + 1) d) | |
| cut (lowerHeight upper d)) | |
| (CutSlotAssembly.fill | |
| (CleanRightDecoder.fullPath upper (HierarchicalLeftDecoder.LowerNode upper (h + 1) d) | |
| cut (lowerHeight upper d)) outside | |
| (CleanEndpointSlots.leftReference clauses designated clean visible)) clean | |
| rightTape : CleanRightDecoder.Record clauses designated clean visible projected upper | |
| (HierarchicalLeftDecoder.LowerNode upper (h + 1) d) cut (lowerHeight upper d) | |
| outside rows repeats | |
| variable {rows repeats : Nat β Nat} {t v m : Nat} [NeZero m] | |
| {upper : Nodes branch n} {d : HierarchicalFrozenTables.LowerNodes upper (h + 1)} | |
| (E : Exposed branch rows repeats n h t v m upper d) | |
| abbrev lower (_E : Exposed branch rows repeats n h t v m upper d) := | |
| HierarchicalLeftDecoder.LowerNode upper (h + 1) d | |
| def path : Path branch n (h + 1) := | |
| CleanRightDecoder.fullPath upper (lower E) E.cut (lowerHeight upper d) | |
| abbrev CleanChildren := {i : Fin (branch h) // E.clean i} | |
| abbrev LeftOwn := CleanChildren E β Fin t β Fin m | |
| abbrev RightOwn := CleanChildren E β Fin t β Fin v | |
| def leftExposed : CleanLeftDecoder.Exposed branch rows repeats n h t v m where | |
| clauses := E.clauses | |
| designated := E.designated | |
| clean := E.clean | |
| visible := E.visible | |
| path := path E | |
| outside := E.outside | |
| tape := E.leftTape | |
| abbrev leftSlots (own : LeftOwn E) := CleanLeftDecoder.slots (leftExposed E) own | |
| abbrev rightSlots (own : RightOwn E) := | |
| CleanRightDecoder.slots E.clauses E.designated E.clean E.visible E.projected | |
| upper (lower E) E.cut (lowerHeight upper d) E.outside own | |
| abbrev LeftSeed := CleanLeftDecoder.Seed (leftExposed E) upper | |
| abbrev RightSeed := CleanRightDecoder.Seed E.clauses E.designated E.clean E.visible | |
| E.projected upper (lower E) E.cut (lowerHeight upper d) E.outside | |
| variable (hbranch : β k < n, 0 < branch k) | |
| def leftOutput (seed : LeftSeed E) (own : LeftOwn E) := | |
| CleanLeftDecoder.output (leftExposed E) upper (h + 1) hbranch d own (seed own) | |
| def leftForm (seed : LeftSeed E) (own : LeftOwn E) := | |
| CleanLeftDecoder.form (leftExposed E) upper (h + 1) hbranch d own (seed own) | |
| def rightForm (seed : RightSeed E) (own : RightOwn E) := | |
| CleanRightDecoder.forms E.clauses E.designated E.clean E.visible E.projected | |
| upper (lower E) E.cut (lowerHeight upper d) E.outside | |
| (DecoderSourcePullback.upperBranch upper hbranch) seed own | |
| end | |
| end PerfectCompleteness.CleanDecoderContext | |
| end | |
| end OAI | |