openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Decoding /CleanDecoderSeedLawLemmas.lean
| import OAI.Computability.PerfectCompleteness.Decoding.CleanLeftDecoderLemmas | |
| import OAI.Computability.PerfectCompleteness.Decoding.DependentDecoderSampling | |
| import OAI.Computability.PerfectCompleteness.Foundations.HierarchicalFrozenTablesLemmas | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.CleanDecoderSeedLaw | |
| noncomputable section | |
| open scoped Classical | |
| open TreeSourceSpaces HierarchicalArrays CleanDecoderContext | |
| open UniqueGamesTheorem.Foundations.Games | |
| abbrev F2 := ZMod 2 | |
| variable {branch rows repeats : Nat → Nat} {n h 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 LeftAnswer (own : LeftOwn E) := | |
| CleanLeftDecoder.UpperAnswer (leftExposed E) upper own | |
| abbrev RightAnswer (own : RightOwn E) := | |
| CleanRightDecoder.Answer E.clauses E.designated E.clean E.visible E.projected | |
| upper (lower E) E.cut (lowerHeight upper d) E.outside own | |
| local instance leftOwnFintype : Fintype (LeftOwn E) := | |
| CleanLeftDecoder.ownFintype (leftExposed E) | |
| local instance rightOwnFintype : Fintype (RightOwn E) := | |
| inferInstanceAs (Fintype ({i : Fin (branch h) // E.clean i} → Fin t → Fin v)) | |
| local instance leftAnswerFintype (own : LeftOwn E) : Fintype (LeftAnswer E own) := | |
| CleanLeftDecoder.upperAnswerFintype (leftExposed E) upper own | |
| local instance rightAnswerFintype (own : RightOwn E) : Fintype (RightAnswer E own) := | |
| RightDecoder.scalarFintype (rightSlots E own) upper | |
| abbrev Seed := LeftSeed E × RightSeed E | |
| instance seedFintype : Fintype (Seed E) := | |
| inferInstanceAs (Fintype | |
| (((own : LeftOwn E) → LeftAnswer E own) × | |
| ((own : RightOwn E) → RightAnswer E own))) | |
| variable (σ : KeyStrategy.Strategy (TreeCanonical.locationCount branch n t)) | |
| (useful : CleanLeftDecoder.Useful (leftExposed E) upper (h + 1)) | |
| (r : Nat) (ρ : ℝ) (A : ManyGoodRows.RowMap (Block rows upper) r) | |
| (W : Submodule F2 (OwnInputReference.UpperVector rows upper)) | |
| (a : OwnInputReference.LowerVector rows (lower E)) (threshold : ℝ) | |
| def leftKernel (own : LeftOwn E) : FiniteDistribution (LeftAnswer E own) := | |
| CleanLeftDecoder.law (leftExposed E) upper (h + 1) σ useful r ρ A own | |
| def rightKernel (own : RightOwn E) : FiniteDistribution (RightAnswer E own) := | |
| CleanRightDecoder.kernel E.clauses E.designated E.clean E.visible E.projected | |
| upper (lower E) E.cut (lowerHeight upper d) E.outside | |
| rows repeats E.rightTape W a σ threshold own | |
| def leftSeedLaw : FiniteDistribution (LeftSeed E) := | |
| CleanLeftDecoder.seedLaw (leftExposed E) upper (h + 1) σ useful r ρ A | |
| def rightSeedLaw : FiniteDistribution (RightSeed E) := | |
| CleanRightDecoder.seedLaw E.clauses E.designated E.clean E.visible E.projected | |
| upper (lower E) E.cut (lowerHeight upper d) E.outside | |
| rows repeats E.rightTape W a σ threshold | |
| def seedLaw : FiniteDistribution (Seed E) := | |
| (leftSeedLaw E σ useful r ρ A).product (rightSeedLaw E σ W a threshold) | |
| theorem seedLaw_eq_dependent : | |
| seedLaw E σ useful r ρ A W a threshold = | |
| DependentDecoderSampling.seedLaw | |
| (leftKernel E σ useful r ρ A) (rightKernel E σ W a threshold) := rfl | |
| theorem read_law (left : LeftOwn E) (right : RightOwn E) : | |
| (seedLaw E σ useful r ρ A W a threshold).pushforward | |
| (fun seed => (seed.1 left, seed.2 right)) = | |
| (leftKernel E σ useful r ρ A left).product | |
| (rightKernel E σ W a threshold right) := | |
| DependentDecoderSampling.read_law | |
| (leftKernel E σ useful r ρ A) (rightKernel E σ W a threshold) left right | |
| theorem probability_read (left : LeftOwn E) (right : RightOwn E) | |
| (event : LeftAnswer E left → RightAnswer E right → Bool) : | |
| (seedLaw E σ useful r ρ A W a threshold).probability | |
| (fun seed => event (seed.1 left) (seed.2 right)) = | |
| ((leftKernel E σ useful r ρ A left).product | |
| (rightKernel E σ W a threshold right)).probability | |
| (fun answer => event answer.1 answer.2) := by | |
| have hread := FiniteDistribution.probability_pushforward | |
| (seedLaw E σ useful r ρ A W a threshold) | |
| (fun seed : Seed E => (seed.1 left, seed.2 right)) | |
| (fun answer => event answer.1 answer.2) | |
| rw [read_law] at hread | |
| exact hread.symm | |
| theorem supported_left (seed : Seed E) | |
| (hs : (seedLaw E σ useful r ρ A W a threshold).weight seed ≠ 0) : | |
| (leftSeedLaw E σ useful r ρ A).weight seed.1 ≠ 0 := by | |
| intro hz | |
| apply hs | |
| change (leftSeedLaw E σ useful r ρ A).weight seed.1 * | |
| (rightSeedLaw E σ W a threshold).weight seed.2 = 0 | |
| rw [hz, zero_mul] | |
| theorem supported_right (seed : Seed E) | |
| (hs : (seedLaw E σ useful r ρ A W a threshold).weight seed ≠ 0) : | |
| (rightSeedLaw E σ W a threshold).weight seed.2 ≠ 0 := by | |
| intro hz | |
| apply hs | |
| change (leftSeedLaw E σ useful r ρ A).weight seed.1 * | |
| (rightSeedLaw E σ W a threshold).weight seed.2 = 0 | |
| rw [hz, mul_zero] | |
| theorem supported_left_row (seed : Seed E) | |
| (hs : (seedLaw E σ useful r ρ A W a threshold).weight seed ≠ 0) | |
| (own : LeftOwn E) : | |
| (leftKernel E σ useful r ρ A own).weight (seed.1 own) ≠ 0 := | |
| CleanLeftDecoder.supported_row (leftExposed E) upper (h + 1) σ useful r ρ A | |
| seed.1 (supported_left E σ useful r ρ A W a threshold seed hs) own | |
| theorem supported_right_row (seed : Seed E) | |
| (hs : (seedLaw E σ useful r ρ A W a threshold).weight seed ≠ 0) | |
| (own : RightOwn E) : | |
| (rightKernel E σ W a threshold own).weight (seed.2 own) ≠ 0 := | |
| DependentDecoderSampling.supported_right | |
| (leftKernel E σ useful r ρ A) (rightKernel E σ W a threshold) seed hs own | |
| variable (hbranch : ∀ k < n, 0 < branch k) | |
| theorem supported_output_normalized (hρ : 0 < ρ) (seed : Seed E) | |
| (hs : (seedLaw E σ useful r ρ A W a threshold).weight seed ≠ 0) | |
| (own : LeftOwn E) : | |
| leftOutput E hbranch seed.1 own | |
| (HierarchicalLeftDecoder.lowerOne (leftSlots E own) upper (h + 1) hbranch d) = 1 := | |
| CleanLeftDecoder.supported_output_normalized (leftExposed E) upper (h + 1) σ useful | |
| hbranch r ρ hρ A seed.1 | |
| (supported_left E σ useful r ρ A W a threshold seed hs) d own | |
| theorem supported_form_tested_rank (hρ : 0 < ρ) (seed : Seed E) | |
| (hs : (seedLaw E σ useful r ρ A W a threshold).weight seed ≠ 0) | |
| (own : LeftOwn E) : | |
| (LowerAffineSliceRank.testedGram | |
| (FunctionSpaceLowerRank.matrixForm | |
| (CleanLeftDecoder.LowerH (leftExposed E) upper (h + 1) d own) | |
| (leftForm E hbranch seed.1 own)) | |
| (HierarchicalLeftDecoder.testedMatrix (leftSlots E own) upper (h + 1) | |
| (CleanLeftDecoder.background (leftExposed E) upper own) d)).rank ≤ 1 := | |
| CleanLeftDecoder.supported_form_tested_rank (leftExposed E) upper (h + 1) σ useful | |
| hbranch r ρ hρ A seed.1 | |
| (supported_left E σ useful r ρ A W a threshold seed hs) d own | |
| end | |
| end PerfectCompleteness.CleanDecoderSeedLaw | |
| end | |
| section | |
| namespace PerfectCompleteness.OriginalDecoderMark | |
| noncomputable section | |
| open scoped Classical | |
| open TreeSourceSpaces HierarchicalArrays | |
| open UniqueGamesTheorem.Foundations.Games | |
| abbrev SlotFamily (branch : Nat → Nat) (n t : Nat) := | |
| RecursiveSpaces.Slots branch n → Fin t → MixedSupport.Slot | |
| structure Family (branch rows : Nat → Nat) (n t : Nat) | |
| (Sample : SlotFamily branch n t → Type*) [∀ slots, Fintype (Sample slots)] where | |
| original : (slots : SlotFamily branch n t) → FiniteDistribution (Sample slots) | |
| arrays : (slots : SlotFamily branch n t) → Sample slots → Arrays slots rows | |
| lowerEvent : (slots : SlotFamily branch n t) → Sample slots → Bool | |
| variable {branch rows : Nat → Nat} {n t : Nat} | |
| {Sample : SlotFamily branch n t → Type*} [∀ slots, Fintype (Sample slots)] | |
| (F : Family branch rows n t Sample) (upper : Nodes branch n) (lowerLevel : Nat) (κ : ℝ) | |
| def mark (slots : SlotFamily branch n t) | |
| (background : HierarchicalMatrixTable.Background (rows := rows) slots upper) | |
| (X : HierarchicalFrozenTables.QuotientMatrix slots upper lowerLevel background) : Prop := | |
| HierarchicalUsefulness.mark slots upper lowerLevel | |
| (F.original slots) (F.arrays slots) (F.lowerEvent slots) κ ⟨background, X⟩ = true | |
| theorem mark_heq {slots₁ slots₂ : SlotFamily branch n t} (hs : slots₁ = slots₂) | |
| {background₁ : HierarchicalMatrixTable.Background (rows := rows) slots₁ upper} | |
| {background₂ : HierarchicalMatrixTable.Background (rows := rows) slots₂ upper} | |
| (hb : HEq background₁ background₂) : | |
| HEq (mark F upper lowerLevel κ slots₁ background₁) | |
| (mark F upper lowerLevel κ slots₂ background₂) := by | |
| cases hs | |
| have hb' : background₁ = background₂ := eq_of_heq hb | |
| cases hb' | |
| rfl | |
| theorem mark_congr {slots₁ slots₂ : SlotFamily branch n t} (hs : slots₁ = slots₂) | |
| {background₁ : HierarchicalMatrixTable.Background (rows := rows) slots₁ upper} | |
| {background₂ : HierarchicalMatrixTable.Background (rows := rows) slots₂ upper} | |
| (hb : HEq background₁ background₂) | |
| {X₁ : HierarchicalFrozenTables.QuotientMatrix slots₁ upper lowerLevel background₁} | |
| {X₂ : HierarchicalFrozenTables.QuotientMatrix slots₂ upper lowerLevel background₂} | |
| (hX : HEq X₁ X₂) : | |
| mark F upper lowerLevel κ slots₁ background₁ X₁ ↔ | |
| mark F upper lowerLevel κ slots₂ background₂ X₂ := by | |
| cases hs | |
| have hb' : background₁ = background₂ := eq_of_heq hb | |
| cases hb' | |
| have hX' : X₁ = X₂ := eq_of_heq hX | |
| cases hX' | |
| rfl | |
| theorem table_eq_original (slots : SlotFamily branch n t) | |
| (background : HierarchicalMatrixTable.Background (rows := rows) slots upper) | |
| (σ : KeyStrategy.Strategy (TreeCanonical.locationCount branch n t)) : | |
| HierarchicalFrozenTables.table slots upper lowerLevel background σ | |
| (mark F upper lowerLevel κ slots background) = | |
| HierarchicalUsefulness.table slots upper lowerLevel (F.original slots) | |
| (F.arrays slots) (F.lowerEvent slots) κ σ background := rfl | |
| variable {repeats : Nat → Nat} {h v m : Nat} [NeZero m] | |
| def useful (E : CleanLeftDecoder.Exposed branch rows repeats n h t v m) : | |
| CleanLeftDecoder.Useful E upper lowerLevel := | |
| fun own X => mark F upper lowerLevel κ | |
| (CleanLeftDecoder.slots E own) (CleanLeftDecoder.background E upper own) X | |
| theorem useful_heq | |
| (E₁ E₂ : CleanLeftDecoder.Exposed branch rows repeats n h t v m) | |
| (own₁ : CleanLeftDecoder.Own E₁) (own₂ : CleanLeftDecoder.Own E₂) | |
| (hs : CleanLeftDecoder.slots E₁ own₁ = CleanLeftDecoder.slots E₂ own₂) | |
| (hb : HEq (CleanLeftDecoder.background E₁ upper own₁) | |
| (CleanLeftDecoder.background E₂ upper own₂)) : | |
| HEq (useful F upper lowerLevel κ E₁ own₁) (useful F upper lowerLevel κ E₂ own₂) := | |
| mark_heq F upper lowerLevel κ hs hb | |
| theorem useful_at_quotientMatrix | |
| (E : CleanLeftDecoder.Exposed branch rows repeats n h t v m) | |
| (own : CleanLeftDecoder.Own E) : | |
| useful F upper lowerLevel κ E own (CleanLeftDecoder.quotientMatrix E upper lowerLevel own) ↔ | |
| HierarchicalUsefulness.mark (CleanLeftDecoder.slots E own) upper lowerLevel | |
| (F.original (CleanLeftDecoder.slots E own)) (F.arrays (CleanLeftDecoder.slots E own)) | |
| (F.lowerEvent (CleanLeftDecoder.slots E own)) κ | |
| (HierarchicalUsefulness.observe (CleanLeftDecoder.slots E own) upper lowerLevel | |
| (CleanLeftDecoder.arrays E own)) = true := Iff.rfl | |
| theorem law_eq_adviceLaw | |
| (E : CleanLeftDecoder.Exposed branch rows repeats n h t v m) | |
| (σ : KeyStrategy.Strategy (TreeCanonical.locationCount branch n t)) | |
| (r : Nat) (ρ : ℝ) (A : ManyGoodRows.RowMap (Block rows upper) r) | |
| (own : CleanLeftDecoder.Own E) : | |
| CleanLeftDecoder.law E upper lowerLevel σ (useful F upper lowerLevel κ E) r ρ A own = | |
| HierarchicalLeftDecoder.adviceLaw (CleanLeftDecoder.slots E own) upper lowerLevel | |
| (CleanLeftDecoder.background E upper own) σ | |
| (mark F upper lowerLevel κ (CleanLeftDecoder.slots E own) | |
| (CleanLeftDecoder.background E upper own)) r ρ A | |
| (A.comp (CleanLeftDecoder.quotientMatrix E upper lowerLevel own)) := rfl | |
| end | |
| end PerfectCompleteness.OriginalDecoderMark | |
| end | |
| end OAI | |