openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Sampling /CutSamplerKeyLocalityLemmas.lean
| import OAI.Computability.PerfectCompleteness.Construction.TreeCanonical | |
| import OAI.Computability.PerfectCompleteness.Foundations.CutTerminalZero | |
| import OAI.Computability.PerfectCompleteness.Repetition.CleanCountingLemmas | |
| import OAI.Computability.PerfectCompleteness.Sampling.CutSamplerLocality | |
| namespace OAI | |
| namespace PerfectCompleteness.CutSamplerKeyLocality | |
| open scoped Classical | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces | |
| open CutSamplerLocality | |
| abbrev F2 := ZMod 2 | |
| noncomputable section | |
| universe u | |
| variable {branch : Nat → Nat} {n m t : Nat} | |
| def keptLeaf : {n m : Nat} → Path branch n (m + 1) → | |
| (Fin (branch m) → Prop) → Slots branch n → Prop | |
| | _, _, .refl _, clean, s => ¬ clean s.1 | |
| | _, _, .step i p, clean, s => s.1 ≠ i ∨ keptLeaf p clean s.2 | |
| theorem view_eq_of_keptLeaf (p : Path branch n (m + 1)) : | |
| ∀ (A : Slots branch n → Type u) (clean : Fin (branch m) → Prop) | |
| (x y : Assignment A), | |
| (∀ s, keptLeaf p clean s → x s = y s) → view p A clean x = view p A clean y := by | |
| induction n generalizing m with | |
| | zero => | |
| have h := p.height_le | |
| omega | |
| | succ n ih => | |
| cases p with | |
| | refl => | |
| intro A clean x y hagree | |
| funext i s | |
| exact hagree (i.val, s) i.property | |
| | step i p => | |
| intro A clean x y hagree | |
| apply Prod.ext | |
| · funext j s | |
| exact hagree (j.val, s) (Or.inl j.property) | |
| · apply ih p (childFamily A i) clean | |
| (childRestriction A i x) (childRestriction A i y) | |
| intro s hs | |
| exact hagree (i, s) (Or.inr hs) | |
| theorem keptLeaf_at_cut (p : Path branch n (m + 1)) | |
| (clean : Fin (branch m) → Prop) (i : Fin (branch m)) (s : Slots branch m) : | |
| keptLeaf p clean (p.slotEmbedding (i, s)) ↔ ¬ clean i := by | |
| induction n generalizing m with | |
| | zero => | |
| have h := p.height_le | |
| omega | |
| | succ n ih => | |
| cases p with | |
| | refl => rfl | |
| | step j p => | |
| change (j ≠ j ∨ keptLeaf p clean (p.slotEmbedding (i, s))) ↔ ¬ clean i | |
| simpa only [ne_self_iff_false, false_or] using ih p clean i s | |
| def numberedKeep (p : Path branch n (m + 1)) (clean : Fin (branch m) → Prop) : | |
| Fin (TreeCanonical.locationCount branch n t) → Prop := | |
| fun j => keptLeaf p clean ((TreeCanonical.numbering branch n t).symm j).1 | |
| theorem not_numberedKeep_clean (p : Path branch n (m + 1)) | |
| (clean : Fin (branch m) → Prop) (i : Fin (branch m)) (hi : clean i) | |
| (s : Slots branch m) (k : Fin t) : | |
| ¬ numberedKeep p clean | |
| (TreeCanonical.numbering branch n t (p.slotEmbedding (i, s), k)) := by | |
| intro h | |
| have hkeep : keptLeaf p clean (p.slotEmbedding (i, s)) := by | |
| simpa only [numberedKeep, Equiv.symm_apply_apply] using h | |
| exact (keptLeaf_at_cut p clean i s).mp hkeep hi | |
| theorem view_eq_of_numbered_retained (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) (clean : Fin (branch m) → Prop) | |
| (x y : Domain slots) | |
| (hret : CleanKeyErasure.retain (TreeCanonical.numberedSlots slots) (numberedKeep p clean) | |
| (TreeCanonical.assignmentEquiv slots x) = | |
| CleanKeyErasure.retain (TreeCanonical.numberedSlots slots) (numberedKeep p clean) | |
| (TreeCanonical.assignmentEquiv slots y)) : | |
| view p (LeafDomain slots) clean x = view p (LeafDomain slots) clean y := by | |
| apply view_eq_of_keptLeaf p (LeafDomain slots) clean x y | |
| intro s hs | |
| funext k | |
| let j := TreeCanonical.numbering branch n t (s, k) | |
| have hj : numberedKeep p clean j := by | |
| simpa only [numberedKeep, j, Equiv.symm_apply_apply] using hs | |
| have hvalue := congrFun hret ⟨j, hj⟩ | |
| exact Eq.mp (congrArg (fun sk : TreeCanonical.Location branch n t => | |
| x sk.1 sk.2 = y sk.1 sk.2) | |
| ((TreeCanonical.numbering branch n t).symm_apply_apply (s, k))) hvalue | |
| theorem view_eq_of_retained (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) (clean : Fin (branch m) → Prop) | |
| (x y : MixedSupport.Assignment (TreeCanonical.numberedSlots slots)) | |
| (hret : CleanKeyErasure.retain (TreeCanonical.numberedSlots slots) (numberedKeep p clean) x = | |
| CleanKeyErasure.retain (TreeCanonical.numberedSlots slots) (numberedKeep p clean) y) : | |
| view p (LeafDomain slots) clean ((TreeCanonical.assignmentEquiv slots).symm x) = | |
| view p (LeafDomain slots) clean ((TreeCanonical.assignmentEquiv slots).symm y) := by | |
| apply view_eq_of_numbered_retained p slots clean | |
| simpa only [Equiv.apply_symm_apply] using hret | |
| variable {J : Type*} | |
| (repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) (clean : Fin (branch m) → Prop) | |
| (tapes : J → CutSamplerRefinement.Tape F2 repeats p (LeafDomain slots)) | |
| def rowQuery : Domain slots → J → F2 := | |
| fun x j => (CutSamplerRefinement.evaluate F2 repeats p (LeafDomain slots) (tapes j)).val x | |
| def numberedRows : MixedSupport.Assignment (TreeCanonical.numberedSlots slots) → J → F2 := | |
| TreeCanonical.numberedFunction slots (rowQuery repeats p slots tapes) | |
| def allRowsZero : Prop := | |
| ∀ j, ZeroAtClean F2 repeats p (LeafDomain slots) clean (tapes j) | |
| theorem numberedRows_constant (hzero : allRowsZero repeats p slots clean tapes) | |
| (x y : MixedSupport.Assignment (TreeCanonical.numberedSlots slots)) | |
| (hret : CleanKeyErasure.retain (TreeCanonical.numberedSlots slots) (numberedKeep p clean) x = | |
| CleanKeyErasure.retain (TreeCanonical.numberedSlots slots) (numberedKeep p clean) y) : | |
| numberedRows repeats p slots tapes x = numberedRows repeats p slots tapes y := by | |
| funext j | |
| exact evaluate_eq_of_view_eq F2 repeats p (LeafDomain slots) clean (tapes j) (hzero j) | |
| _ _ (view_eq_of_retained p slots clean x y hret) | |
| def retainedRows : CleanKeyErasure.Retained (TreeCanonical.numberedSlots slots) | |
| (numberedKeep p clean) → J → F2 := | |
| numberedRows repeats p slots tapes ∘ | |
| CleanKeyFactorization.fill (TreeCanonical.numberedSlots slots) (numberedKeep p clean) | |
| theorem retainedRows_eq_of_extension (hzero : allRowsZero repeats p slots clean tapes) | |
| (x : CleanKeyErasure.Retained (TreeCanonical.numberedSlots slots) (numberedKeep p clean)) | |
| (y : MixedSupport.Assignment (TreeCanonical.numberedSlots slots)) | |
| (hy : CleanKeyErasure.retain (TreeCanonical.numberedSlots slots) (numberedKeep p clean) y = x) : | |
| retainedRows repeats p slots clean tapes x = numberedRows repeats p slots tapes y := by | |
| apply numberedRows_constant repeats p slots clean tapes hzero | |
| exact (CleanKeyFactorization.retain_fill (TreeCanonical.numberedSlots slots) | |
| (numberedKeep p clean) x).trans hy.symm | |
| theorem numberedRows_factor (hzero : allRowsZero repeats p slots clean tapes) : | |
| numberedRows repeats p slots tapes = retainedRows repeats p slots clean tapes ∘ | |
| CleanKeyErasure.retain (TreeCanonical.numberedSlots slots) (numberedKeep p clean) := by | |
| funext x | |
| exact (retainedRows_eq_of_extension repeats p slots clean tapes hzero _ x rfl).symm | |
| theorem clean_position_dropped (hzero : allRowsZero repeats p slots clean tapes) | |
| (i : Fin (branch m)) (hi : clean i) (s : Slots branch m) (k : Fin t) : | |
| MixedSupport.keyFields (TreeCanonical.numberedSlots slots) (numberedRows repeats p slots tapes) | |
| (TreeCanonical.numbering branch n t (p.slotEmbedding (i, s), k)) = .dropped := | |
| CleanKeyErasure.keyFields_dropped_of_retained (TreeCanonical.numberedSlots slots) | |
| (numberedKeep p clean) (numberedRows repeats p slots tapes) | |
| (numberedRows_constant repeats p slots clean tapes hzero) _ | |
| (not_numberedKeep_clean p clean i hi s k) | |
| theorem key_eq_retained (hzero : allRowsZero repeats p slots clean tapes) | |
| (side : CanonicalKeys.Side) : | |
| CanonicalKeys.key side (TreeCanonical.numberedSlots slots) (numberedRows repeats p slots tapes) = | |
| CleanKeyFactorization.retainedKey side (numberedKeep p clean) | |
| (CleanKeyFactorization.retainedSlots (TreeCanonical.numberedSlots slots) (numberedKeep p clean)) | |
| (retainedRows repeats p slots clean tapes) := by | |
| rw [numberedRows_factor repeats p slots clean tapes hzero] | |
| exact CleanKeyFactorization.key_factor side (TreeCanonical.numberedSlots slots) | |
| (numberedKeep p clean) (retainedRows repeats p slots clean tapes) | |
| theorem label_eq_retained (hzero : allRowsZero repeats p slots clean tapes) | |
| (labeling : KeyStrategy.Strategy (TreeCanonical.locationCount branch n t)) | |
| (side : CanonicalKeys.Side) : | |
| (KeyStrategy.label labeling side (TreeCanonical.numberedSlots slots) | |
| (numberedRows repeats p slots tapes)).val = | |
| (labeling (CleanKeyFactorization.retainedQueryKey side (numberedKeep p clean) | |
| (CleanKeyFactorization.retainedSlots (TreeCanonical.numberedSlots slots) (numberedKeep p clean)) | |
| (retainedRows repeats p slots clean tapes))).val := by | |
| rw [numberedRows_factor repeats p slots clean tapes hzero] | |
| exact CleanKeyFactorization.label_factor labeling side (TreeCanonical.numberedSlots slots) | |
| (numberedKeep p clean) (retainedRows repeats p slots clean tapes) | |
| theorem response_eq_retained (hzero : allRowsZero repeats p slots clean tapes) | |
| (labeling : KeyStrategy.Strategy (TreeCanonical.locationCount branch n t)) | |
| (side : CanonicalKeys.Side) : | |
| KeyStrategy.response labeling side (TreeCanonical.numberedSlots slots) | |
| (numberedRows repeats p slots tapes) = | |
| CleanKeyFactorization.retainedResponse labeling side (numberedKeep p clean) | |
| (CleanKeyFactorization.retainedSlots (TreeCanonical.numberedSlots slots) (numberedKeep p clean)) | |
| (retainedRows repeats p slots clean tapes) := by | |
| rw [numberedRows_factor repeats p slots clean tapes hzero] | |
| exact CleanKeyFactorization.response_factor labeling side (TreeCanonical.numberedSlots slots) | |
| (numberedKeep p clean) (retainedRows repeats p slots clean tapes) | |
| end | |
| end PerfectCompleteness.CutSamplerKeyLocality | |
| namespace PerfectCompleteness.CutSamplerReplay | |
| open scoped BigOperators Classical | |
| open RecursiveSpaces DescendantSpaces RecursiveSampler PointwiseSpaces | |
| noncomputable section | |
| universe u w | |
| variable {branch : Nat → Nat} {n m : Nat} | |
| def Tape (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) : | |
| {n m : Nat} → (p : Path branch n (m + 1)) → (A : Slots branch n → Type u) → | |
| (clean : Fin (branch m) → Prop) → Type (max u w) | |
| | _, m, .refl _, A, clean => | |
| (i : {i : Fin (branch m) // ¬ clean i}) → | |
| squareSpace (space 𝕜 branch m (childFamily A i.val)) | |
| | n + 1, _, .step i p, A, clean => | |
| ((j : OffPath i) → squareSpace (space 𝕜 branch n (childFamily A j.val))) × | |
| ((call : Fin (repeats (n + 1)) × Bool) → Tape 𝕜 repeats p (childFamily A i) clean) | |
| def erase (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) : | |
| {n m : Nat} → (p : Path branch n (m + 1)) → (A : Slots branch n → Type u) → | |
| (clean : Fin (branch m) → Prop) → CutSamplerRefinement.Tape 𝕜 repeats p A → | |
| Tape 𝕜 repeats p A clean | |
| | _, _, .refl _, _, _, tape => fun i => tape () i.val | |
| | _, _, .step i p, A, clean, tape => | |
| (fun j => tape (.inl j), fun call => erase 𝕜 repeats p (childFamily A i) clean | |
| (CutSamplerLocality.subTape 𝕜 repeats i p A tape call.1 call.2)) | |
| def evaluate (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) : | |
| {n m : Nat} → (p : Path branch n (m + 1)) → (A : Slots branch n → Type u) → | |
| (clean : Fin (branch m) → Prop) → Tape 𝕜 repeats p A clean → Assignment A → 𝕜 | |
| | _, m, .refl _, A, clean, tape, x => | |
| ∑ i : {i : Fin (branch m) // ¬ clean i}, (tape i).val (childRestriction A i.val x) | |
| | n + 1, _, .step i p, A, clean, tape, x => | |
| (∑ j : OffPath i, (tape.1 j).val (childRestriction A j.val x)) + | |
| ∑ h : Fin (repeats (n + 1)), | |
| evaluate 𝕜 repeats p (childFamily A i) clean (tape.2 (h, false)) (childRestriction A i x) * | |
| evaluate 𝕜 repeats p (childFamily A i) clean (tape.2 (h, true)) (childRestriction A i x) | |
| theorem evaluate_refl (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) | |
| (A : Slots branch (m + 1) → Type u) (clean : Fin (branch m) → Prop) | |
| (tape : Tape 𝕜 repeats (.refl (m + 1)) A clean) (x : Assignment A) : | |
| evaluate 𝕜 repeats (.refl (m + 1)) A clean tape x = | |
| ∑ i : {i : Fin (branch m) // ¬ clean i}, (tape i).val (childRestriction A i.val x) := rfl | |
| theorem evaluate_step (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) | |
| (i : Fin (branch n)) (p : Path branch n (m + 1)) | |
| (A : Slots branch (n + 1) → Type u) (clean : Fin (branch m) → Prop) | |
| (tape : Tape 𝕜 repeats (.step i p) A clean) (x : Assignment A) : | |
| evaluate 𝕜 repeats (.step i p) A clean tape x = | |
| (∑ j : OffPath i, (tape.1 j).val (childRestriction A j.val x)) + | |
| ∑ h : Fin (repeats (n + 1)), | |
| evaluate 𝕜 repeats p (childFamily A i) clean (tape.2 (h, false)) (childRestriction A i x) * | |
| evaluate 𝕜 repeats p (childFamily A i) clean (tape.2 (h, true)) | |
| (childRestriction A i x) := rfl | |
| theorem evaluate_erase (𝕜 : Type w) [Field 𝕜] | |
| (repeats : Nat → Nat) (p : Path branch n (m + 1)) : | |
| ∀ (A : Slots branch n → Type u) (clean : Fin (branch m) → Prop) | |
| (tape : CutSamplerRefinement.Tape 𝕜 repeats p A), | |
| CutSamplerLocality.ZeroAtClean 𝕜 repeats p A clean tape → | |
| ∀ x : Assignment A, | |
| evaluate 𝕜 repeats p A clean (erase 𝕜 repeats p A clean tape) x = | |
| (CutSamplerRefinement.evaluate 𝕜 repeats p A tape).val x := by | |
| induction n generalizing m with | |
| | zero => | |
| have h := p.height_le | |
| omega | |
| | succ n ih => | |
| cases p with | |
| | refl => | |
| intro A clean tape hzero x | |
| have heval : | |
| (UniformChildSum.recursiveSum (𝕜 := 𝕜) A (tape ())).val x = | |
| ∑ i : Fin (branch n), (tape () i).val (childRestriction A i x) := by | |
| have hsum := congrFun | |
| (UniformChildSum.childSum_apply (𝕜 := 𝕜) (childRestriction A) | |
| (fun i => space 𝕜 branch n (childFamily A i)) (tape ())) x | |
| simp only [Finset.sum_apply, PointwiseSpaces.pullback_apply] at hsum | |
| refine hsum.trans ?_ | |
| refine Finset.sum_congr (ι := Fin (branch n)) ?_ ?_ | |
| · ext i | |
| simp only [Finset.mem_univ] | |
| · intro i _ | |
| rfl | |
| rw [evaluate_refl, CutSamplerLocality.evaluate_refl, heval] | |
| simp only [erase] | |
| rw [← Fintype.sum_subtype_add_sum_subtype clean | |
| (fun i => (tape () i).val (childRestriction A i x))] | |
| have hz : (∑ i : {i : Fin (branch n) // clean i}, | |
| (tape () i.val).val (childRestriction A i.val x)) = 0 := by | |
| apply Finset.sum_eq_zero | |
| intro i _ | |
| rw [hzero i.val i.property] | |
| rfl | |
| rw [hz, zero_add] | |
| | step i p => | |
| intro A clean tape hzero x | |
| rw [evaluate_step, CutSamplerLocality.evaluate_step] | |
| simp only [erase, RecursiveSampler.combine, RecursiveSampler.combineFunction, | |
| Finset.sum_apply, Pi.add_apply, Pi.mul_apply, PointwiseSpaces.pullback_apply] | |
| apply congrArg (fun z => | |
| (∑ j : OffPath i, (tape (.inl j)).val (childRestriction A j.val x)) + z) | |
| apply Finset.sum_congr rfl | |
| intro h _ | |
| rw [ih p (childFamily A i) clean | |
| (CutSamplerLocality.subTape 𝕜 repeats i p A tape h false) (hzero h false), | |
| ih p (childFamily A i) clean | |
| (CutSamplerLocality.subTape 𝕜 repeats i p A tape h true) (hzero h true)] | |
| theorem evaluate_erase_of_split_zero (𝕜 : Type w) [Field 𝕜] | |
| (repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (A : Slots branch n → Type u) (clean : Fin (branch m) → Prop) | |
| (tape : CutSamplerRefinement.Tape 𝕜 repeats p A) | |
| (hzero : ∀ terminal i, clean i → | |
| (CutTerminalSplit.splitTape 𝕜 repeats p A tape).1 terminal i = 0) | |
| (x : Assignment A) : | |
| evaluate 𝕜 repeats p A clean (erase 𝕜 repeats p A clean tape) x = | |
| (CutSamplerRefinement.evaluate 𝕜 repeats p A tape).val x := | |
| evaluate_erase 𝕜 repeats p A clean tape | |
| ((CutTerminalZero.zeroAtClean_iff 𝕜 repeats p A clean tape).mp hzero) x | |
| end | |
| end PerfectCompleteness.CutSamplerReplay | |
| namespace PerfectCompleteness.CutSamplerReplayGrouping | |
| open RecursiveSpaces DescendantSpaces RecursiveSampler TerminalCalls PointwiseSpaces | |
| noncomputable section | |
| universe u w | |
| variable {branch : Nat → Nat} {n m : Nat} | |
| abbrev RetainedTerminal (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) (A : Slots branch n → Type u) | |
| (clean : Fin (branch m) → Prop) := | |
| TerminalIndex repeats p → (i : {i : Fin (branch m) // ¬ clean i}) → | |
| squareSpace (space 𝕜 branch m (childFamily (p.family A) i.val)) | |
| def exteriorStepIndex (repeats : Nat → Nat) (i : Fin (branch n)) | |
| (p : Path branch n (m + 1)) (call : Fin (repeats (n + 1)) × Bool) | |
| (j : CutTerminalSplit.ExteriorIndex repeats p) : | |
| CutTerminalSplit.ExteriorIndex repeats (.step i p) := | |
| ⟨.inr (call, j.val), j.property⟩ | |
| def subExterior (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) | |
| (i : Fin (branch n)) (p : Path branch n (m + 1)) | |
| (A : Slots branch (n + 1) → Type u) (call : Fin (repeats (n + 1)) × Bool) | |
| (exterior : CutTerminalSplit.ExteriorTape 𝕜 repeats (.step i p) A) : | |
| CutTerminalSplit.ExteriorTape 𝕜 repeats p (childFamily A i) := | |
| fun j => exterior (exteriorStepIndex repeats i p call j) | |
| theorem subExterior_splitTape (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) | |
| (i : Fin (branch n)) (p : Path branch n (m + 1)) | |
| (A : Slots branch (n + 1) → Type u) | |
| (tape : CutSamplerRefinement.Tape 𝕜 repeats (.step i p) A) | |
| (h : Fin (repeats (n + 1))) (b : Bool) : | |
| subExterior 𝕜 repeats i p A (h, b) | |
| (CutTerminalSplit.splitTape 𝕜 repeats (.step i p) A tape).2 = | |
| (CutTerminalSplit.splitTape 𝕜 repeats p (childFamily A i) | |
| (CutSamplerLocality.subTape 𝕜 repeats i p A tape h b)).2 := by | |
| funext j | |
| rfl | |
| def assemble (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) : | |
| {n m : Nat} → (p : Path branch n (m + 1)) → (A : Slots branch n → Type u) → | |
| (clean : Fin (branch m) → Prop) → | |
| CutTerminalSplit.ExteriorTape 𝕜 repeats p A → | |
| RetainedTerminal 𝕜 repeats p A clean → CutSamplerReplay.Tape 𝕜 repeats p A clean | |
| | _, _, .refl _, _, _, _, terminal => terminal () | |
| | _, _, .step i p, A, clean, exterior, terminal => | |
| (fun j => exterior ⟨.inl j, not_isTerminal_ordinary repeats i p j⟩, | |
| fun call => assemble 𝕜 repeats p (childFamily A i) clean | |
| (subExterior 𝕜 repeats i p A call exterior) | |
| (fun location child => terminal (call, location) child)) | |
| theorem assemble_splitTape (𝕜 : Type w) [Field 𝕜] | |
| (repeats : Nat → Nat) (p : Path branch n (m + 1)) : | |
| ∀ (A : Slots branch n → Type u) (clean : Fin (branch m) → Prop) | |
| (tape : CutSamplerRefinement.Tape 𝕜 repeats p A), | |
| assemble 𝕜 repeats p A clean (CutTerminalSplit.splitTape 𝕜 repeats p A tape).2 | |
| (fun terminal child => | |
| (CutTerminalSplit.splitTape 𝕜 repeats p A tape).1 terminal child.val) = | |
| CutSamplerReplay.erase 𝕜 repeats p A clean tape := by | |
| induction n generalizing m with | |
| | zero => | |
| have h := p.height_le | |
| omega | |
| | succ n ih => | |
| cases p with | |
| | refl => | |
| intro A clean tape | |
| rfl | |
| | step i p => | |
| intro A clean tape | |
| apply Prod.ext | |
| · funext j | |
| rfl | |
| · funext call | |
| rcases call with ⟨h, b⟩ | |
| change assemble 𝕜 repeats p (childFamily A i) clean | |
| (subExterior 𝕜 repeats i p A (h, b) | |
| (CutTerminalSplit.splitTape 𝕜 repeats (.step i p) A tape).2) | |
| (fun terminal child => | |
| (CutTerminalSplit.splitTape 𝕜 repeats (.step i p) A tape).1 | |
| ((h, b), terminal) child.val) = | |
| CutSamplerReplay.erase 𝕜 repeats p (childFamily A i) clean | |
| (CutSamplerLocality.subTape 𝕜 repeats i p A tape h b) | |
| rw [subExterior_splitTape] | |
| simp_rw [CutTerminalZero.splitTape_terminal_step] | |
| exact ih p (childFamily A i) clean | |
| (CutSamplerLocality.subTape 𝕜 repeats i p A tape h b) | |
| theorem evaluate_assemble_splitTape (𝕜 : Type w) [Field 𝕜] | |
| (repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (A : Slots branch n → Type u) (clean : Fin (branch m) → Prop) | |
| (tape : CutSamplerRefinement.Tape 𝕜 repeats p A) | |
| (hzero : CutSamplerLocality.ZeroAtClean 𝕜 repeats p A clean tape) (x : Assignment A) : | |
| CutSamplerReplay.evaluate 𝕜 repeats p A clean | |
| (assemble 𝕜 repeats p A clean (CutTerminalSplit.splitTape 𝕜 repeats p A tape).2 | |
| (fun terminal child => | |
| (CutTerminalSplit.splitTape 𝕜 repeats p A tape).1 terminal child.val)) x = | |
| (CutSamplerRefinement.evaluate 𝕜 repeats p A tape).val x := by | |
| rw [assemble_splitTape] | |
| exact CutSamplerReplay.evaluate_erase 𝕜 repeats p A clean tape hzero x | |
| end | |
| end PerfectCompleteness.CutSamplerReplayGrouping | |
| end OAI | |