openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Decoding /LowerCutRowsLemmas.lean
| import OAI.Computability.PerfectCompleteness.Decoding.LowerCutScalar | |
| import OAI.Computability.PerfectCompleteness.Foundations.WholeArrayInteriorExteriorLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.WholeCutGrouping | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.LowerCutRows | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays | |
| open WholeCutGrouping | |
| open UniqueGamesTheorem.Foundations.Games | |
| open scoped Classical | |
| abbrev F2 := ZMod 2 | |
| noncomputable section | |
| variable {branch : Nat → Nat} {n m t : Nat} | |
| def reconstruct (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (exterior : Exterior rows repeats p slots) | |
| (raw : CutChildGrouping.Raw (C := WholeCutCalls.Index rows repeats p) | |
| (cutSlots p slots) rows) : Arrays slots rows := | |
| WholeCutSampler.evaluate rows repeats p slots | |
| ((splitTape rows repeats p slots).symm (exterior, raw)) | |
| theorem selectedRows_heq_upperNode (rows : Nat → Nat) | |
| (p : Path branch n (m + 1)) : | |
| ∀ (slots : Slots branch n → Fin t → MixedSupport.Slot) (arrays : Arrays slots rows), | |
| HEq (SelectedArrayReplacement.selectedRows rows p slots arrays) | |
| (arrays (WholeArrayInteriorExterior.upperNode p)) := by | |
| induction n generalizing m with | |
| | zero => cases p | |
| | succ n ih => | |
| cases p with | |
| | refl => intro slots arrays; rfl | |
| | step i p => | |
| intro slots arrays | |
| exact ih p (childSlots slots i) (fun node => arrays (.inr (i, node))) | |
| theorem selectedRows_evaluate_step (rows repeats : Nat → Nat) (i : Fin (branch n)) | |
| (p : Path branch n (m + 1)) | |
| (slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) | |
| (tape : WholeCutSampler.Tape rows repeats (.step i p) slots) : | |
| SelectedArrayReplacement.selectedRows rows (.step i p) slots | |
| (WholeCutSampler.evaluate rows repeats (.step i p) slots tape) = | |
| SelectedArrayReplacement.selectedRows rows p (childSlots slots i) | |
| (WholeCutSampler.evaluate rows repeats p (childSlots slots i) tape.2.1) := by | |
| rw [SelectedArrayReplacement.selectedRows_step] | |
| apply congrArg (SelectedArrayReplacement.selectedRows rows p (childSlots slots i)) | |
| funext node | |
| unfold WholeCutSampler.evaluate | |
| rw [WholeArraySampler.evaluate_selected] | |
| rfl | |
| theorem selectedRows_evaluate (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) : | |
| ∀ (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (tape : WholeCutSampler.Tape rows repeats p slots) (row : Fin (rows (m + 1))), | |
| SelectedArrayReplacement.selectedRows rows p slots | |
| (WholeCutSampler.evaluate rows repeats p slots tape) row = | |
| (CutChildGrouping.assemble (cutSlots p slots) rows | |
| ((splitTape rows repeats p slots tape).2)).1 | |
| (WholeCutCalls.directRow rows repeats p row) := by | |
| induction n generalizing m with | |
| | zero => cases p | |
| | succ n ih => | |
| cases p with | |
| | refl => intro slots tape row; rfl | |
| | step i p => | |
| intro slots tape row | |
| rw [selectedRows_evaluate_step] | |
| exact ih p (childSlots slots i) tape.2.1 row | |
| theorem selectedRows_reconstruct (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (exterior : Exterior rows repeats p slots) | |
| (raw : CutChildGrouping.Raw (C := WholeCutCalls.Index rows repeats p) | |
| (cutSlots p slots) rows) (row : Fin (rows (m + 1))) : | |
| SelectedArrayReplacement.selectedRows rows p slots | |
| (reconstruct rows repeats p slots exterior raw) row = | |
| (CutChildGrouping.assemble (cutSlots p slots) rows raw).1 | |
| (WholeCutCalls.directRow rows repeats p row) := by | |
| unfold reconstruct | |
| rw [selectedRows_evaluate, Equiv.apply_symm_apply] | |
| def selectRows (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) : | |
| CutChildGrouping.Assembled (C := WholeCutCalls.Index rows repeats p) | |
| (cutSlots p slots) rows →ₗ[F2] | |
| (Fin (rows (m + 1)) → H (cutSlots p slots)) where | |
| toFun x row := x.1 (WholeCutCalls.directRow rows repeats p row) | |
| map_add' _ _ := rfl | |
| map_smul' _ _ := rfl | |
| @[simp] theorem selectRows_apply (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (x : CutChildGrouping.Assembled (C := WholeCutCalls.Index rows repeats p) | |
| (cutSlots p slots) rows) (row : Fin (rows (m + 1))) : | |
| selectRows rows repeats p slots x row = | |
| x.1 (WholeCutCalls.directRow rows repeats p row) := rfl | |
| theorem selectRows_surjective (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) : | |
| Function.Surjective (selectRows rows repeats p slots) := by | |
| intro fresh | |
| refine ⟨(Function.extend (WholeCutCalls.directRow rows repeats p) fresh (fun _ => 0), | |
| fun _ _ _ => 0), ?_⟩ | |
| funext row | |
| exact (WholeCutCalls.directRow_injective rows repeats p).extend_apply fresh | |
| (fun _ => 0) row | |
| theorem selectedRows_reconstruct_eq (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (exterior : Exterior rows repeats p slots) | |
| (raw : CutChildGrouping.Raw (C := WholeCutCalls.Index rows repeats p) | |
| (cutSlots p slots) rows) : | |
| SelectedArrayReplacement.selectedRows rows p slots | |
| (reconstruct rows repeats p slots exterior raw) = | |
| selectRows rows repeats p slots | |
| (CutChildGrouping.assemble (cutSlots p slots) rows raw) := by | |
| funext row | |
| exact selectedRows_reconstruct rows repeats p slots exterior raw row | |
| end | |
| end PerfectCompleteness.LowerCutRows | |
| end | |
| section | |
| namespace PerfectCompleteness.LowerCutAssembled | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays | |
| open WholeCutGrouping | |
| open scoped Classical | |
| abbrev F2 := ZMod 2 | |
| noncomputable section | |
| variable {branch : Nat → Nat} {n m t : Nat} | |
| abbrev Assembled (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) := | |
| CutChildGrouping.Assembled (C := WholeCutCalls.Index rows repeats p) | |
| (cutSlots p slots) rows | |
| def reconstructBuckets (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (values : BucketSampler.Direction (rows n) → | |
| TerminalCalls.TerminalIndex repeats p → H (cutSlots p slots)) | |
| (exterior : BucketSampler.Direction (rows n) → | |
| CutTerminalSplit.ExteriorTape F2 repeats p (LeafDomain slots)) : | |
| Fin (rows n) → H slots := | |
| BucketSampler.evaluate (rows n) (id : H slots → H slots) (fun direction => | |
| LowerCutScalar.reconstruct F2 repeats p (LeafDomain slots) | |
| (values direction) (exterior direction)) | |
| def reconstruct (rows repeats : Nat → Nat) : | |
| {n m : Nat} → (p : Path branch n (m + 1)) → | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) → | |
| Exterior rows repeats p slots → Assembled rows repeats p slots → Arrays slots rows | |
| | _, _, .refl _, slots, _, assembled => | |
| WholeArraySampler.assemble slots rows assembled.1 assembled.2 | |
| | _, _, .step i p, slots, exterior, assembled => | |
| WholeArraySampler.assemble slots rows | |
| (reconstructBuckets rows repeats (.step i p) slots | |
| (fun direction terminal => assembled.1 (.inl (direction, terminal))) exterior.1) | |
| (WholeArraySampler.childrenAt slots rows i | |
| (reconstruct rows repeats p (childSlots slots i) exterior.2.1 | |
| (fun call => assembled.1 (.inr call), assembled.2)) exterior.2.2) | |
| theorem selectedRows_reconstruct (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) : | |
| ∀ (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (exterior : Exterior rows repeats p slots) (assembled : Assembled rows repeats p slots), | |
| SelectedArrayReplacement.selectedRows rows p slots | |
| (reconstruct rows repeats p slots exterior assembled) = | |
| LowerCutRows.selectRows rows repeats p slots assembled := by | |
| induction n generalizing m with | |
| | zero => cases p | |
| | succ n ih => | |
| cases p with | |
| | refl => intro slots exterior assembled; rfl | |
| | step i p => | |
| intro slots exterior assembled | |
| rw [reconstruct, SelectedArrayReplacement.selectedRows_assemble_step] | |
| exact ih p (childSlots slots i) exterior.2.1 | |
| (fun call => assembled.1 (.inr call), assembled.2) | |
| theorem reconstruct_splitTape (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) : | |
| ∀ (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (tape : WholeCutSampler.Tape rows repeats p slots), | |
| reconstruct rows repeats p slots (splitTape rows repeats p slots tape).1 | |
| (CutChildGrouping.assemble (cutSlots p slots) rows | |
| (splitTape rows repeats p slots tape).2) = | |
| WholeCutSampler.evaluate rows repeats p slots tape := by | |
| induction n generalizing m with | |
| | zero => cases p | |
| | succ n ih => | |
| cases p with | |
| | refl => intro slots tape; rfl | |
| | step i p => | |
| intro slots tape | |
| apply congrArg₂ (WholeArraySampler.assemble slots rows) | |
| · apply congrArg (BucketSampler.evaluate (rows (n + 1)) (id : H slots → H slots)) | |
| funext direction | |
| exact LowerCutScalar.reconstruct_splitTape F2 repeats (.step i p) | |
| (LeafDomain slots) (tape.1 direction) | |
| · exact congrArg (fun selected : Arrays (childSlots slots i) rows => | |
| WholeArraySampler.childrenAt slots rows i selected tape.2.2) | |
| (ih p (childSlots slots i) tape.2.1) | |
| theorem reconstruct_assemble (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (exterior : Exterior rows repeats p slots) | |
| (raw : CutChildGrouping.Raw (C := WholeCutCalls.Index rows repeats p) | |
| (cutSlots p slots) rows) : | |
| reconstruct rows repeats p slots exterior | |
| (CutChildGrouping.assemble (cutSlots p slots) rows raw) = | |
| LowerCutRows.reconstruct rows repeats p slots exterior raw := by | |
| have h := reconstruct_splitTape rows repeats p slots | |
| ((splitTape rows repeats p slots).symm (exterior, raw)) | |
| rw [Equiv.apply_symm_apply] at h | |
| exact h | |
| theorem reconstruct_congr_replace (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) : | |
| ∀ (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (exterior : Exterior rows repeats p slots) | |
| (x y : Assembled rows repeats p slots), | |
| (∀ call, (∀ row, call ≠ WholeCutCalls.directRow rows repeats p row) → | |
| y.1 call = x.1 call) → y.2 = x.2 → | |
| reconstruct rows repeats p slots exterior y = | |
| SelectedArrayReplacement.replace rows p slots | |
| (reconstruct rows repeats p slots exterior x) | |
| (LowerCutRows.selectRows rows repeats p slots y) := by | |
| induction n generalizing m with | |
| | zero => cases p | |
| | succ n ih => | |
| cases p with | |
| | refl => | |
| intro slots exterior x y hcalls harrays | |
| change WholeArraySampler.assemble slots rows y.1 y.2 = | |
| WholeArraySampler.assemble slots rows y.1 x.2 | |
| rw [harrays] | |
| | step i p => | |
| intro slots exterior x y hcalls harrays | |
| simp only [reconstruct, SelectedArrayReplacement.replace_assemble_step] | |
| apply congrArg₂ (WholeArraySampler.assemble slots rows) | |
| · unfold reconstructBuckets | |
| apply congrArg (BucketSampler.evaluate (rows (n + 1)) (id : H slots → H slots)) | |
| funext direction | |
| apply congrArg (fun values => LowerCutScalar.reconstruct F2 repeats (.step i p) | |
| (LeafDomain slots) values (exterior.1 direction)) | |
| funext terminal | |
| apply hcalls (.inl (direction, terminal)) | |
| intro row h | |
| cases h | |
| · apply congrArg (fun selected : Arrays (childSlots slots i) rows => | |
| WholeArraySampler.childrenAt slots rows i selected exterior.2.2) | |
| apply ih p (childSlots slots i) exterior.2.1 | |
| (fun call => x.1 (.inr call), x.2) | |
| (fun call => y.1 (.inr call), y.2) | |
| · intro call hcall | |
| apply hcalls (.inr call) | |
| intro row h | |
| exact hcall row (Sum.inr.inj h) | |
| · exact harrays | |
| theorem reconstruct_congr_outside (rows repeats : Nat → Nat) | |
| (p : Path branch n (m + 1)) | |
| (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| (exterior : Exterior rows repeats p slots) (x y : Assembled rows repeats p slots) | |
| (hcalls : ∀ call, (∀ row, call ≠ WholeCutCalls.directRow rows repeats p row) → | |
| y.1 call = x.1 call) (harrays : y.2 = x.2) | |
| (node : Nodes branch n) (hnode : node ≠ WholeArrayInteriorExterior.upperNode p) : | |
| reconstruct rows repeats p slots exterior y node = | |
| reconstruct rows repeats p slots exterior x node := by | |
| rw [reconstruct_congr_replace rows repeats p slots exterior x y hcalls harrays] | |
| exact SelectedArrayReplacement.replace_outside rows p slots | |
| (reconstruct rows repeats p slots exterior x) | |
| (LowerCutRows.selectRows rows repeats p slots y) node hnode | |
| end | |
| end PerfectCompleteness.LowerCutAssembled | |
| end | |
| section | |
| namespace PerfectCompleteness.LowerCutCallSplit | |
| open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays | |
| open WholeCutGrouping | |
| open scoped Classical | |
| abbrev F2 := ZMod 2 | |
| noncomputable section | |
| variable {branch : Nat → Nat} {n m t : Nat} | |
| (rows repeats : Nat → Nat) (p : Path branch n (m + 1)) | |
| abbrev OtherCall := | |
| {q : WholeCutCalls.Index rows repeats p // | |
| ∀ row : Fin (rows (m + 1)), q ≠ WholeCutCalls.directRow rows repeats p row} | |
| variable (slots : Slots branch n → Fin t → MixedSupport.Slot) | |
| abbrev ChildArrays := | |
| (i : Fin (branch m)) → Arrays (childSlots (cutSlots p slots) i) rows | |
| abbrev Complement := | |
| (OtherCall rows repeats p → H (cutSlots p slots)) × ChildArrays rows p slots | |
| abbrev NativeRows := Fin (rows (m + 1)) → H (cutSlots p slots) | |
| abbrev Assembled := | |
| CutChildGrouping.Assembled (C := WholeCutCalls.Index rows repeats p) (cutSlots p slots) rows | |
| instance complementFintype : Fintype (Complement rows repeats p slots) := Fintype.ofFinite _ | |
| def complement (x : Assembled rows repeats p slots) : Complement rows repeats p slots := | |
| (fun q => x.1 q.val, x.2) | |
| def splitAssembled : Assembled rows repeats p slots →ₗ[F2] | |
| Complement rows repeats p slots × NativeRows rows p slots where | |
| toFun x := (complement rows repeats p slots x, LowerCutRows.selectRows rows repeats p slots x) | |
| map_add' _ _ := rfl | |
| map_smul' _ _ := rfl | |
| @[simp] theorem splitAssembled_complement (x : Assembled rows repeats p slots) : | |
| (splitAssembled rows repeats p slots x).1 = complement rows repeats p slots x := rfl | |
| @[simp] theorem splitAssembled_rows (x : Assembled rows repeats p slots) : | |
| (splitAssembled rows repeats p slots x).2 = LowerCutRows.selectRows rows repeats p slots x := rfl | |
| @[simp] theorem complement_call (x : Assembled rows repeats p slots) | |
| (q : OtherCall rows repeats p) : | |
| (complement rows repeats p slots x).1 q = x.1 q.val := rfl | |
| @[simp] theorem complement_arrays (x : Assembled rows repeats p slots) : | |
| (complement rows repeats p slots x).2 = x.2 := rfl | |
| def merge (bg : Complement rows repeats p slots) (fresh : NativeRows rows p slots) : | |
| Assembled rows repeats p slots := | |
| (fun q => if h : ∃ row, q = WholeCutCalls.directRow rows repeats p row then | |
| fresh (Classical.choose h) | |
| else bg.1 ⟨q, fun row hq => h ⟨row, hq⟩⟩, | |
| bg.2) | |
| @[simp] theorem merge_directRow (bg : Complement rows repeats p slots) | |
| (fresh : NativeRows rows p slots) (row : Fin (rows (m + 1))) : | |
| (merge rows repeats p slots bg fresh).1 (WholeCutCalls.directRow rows repeats p row) = | |
| fresh row := by | |
| have hex : ∃ j, WholeCutCalls.directRow rows repeats p row = | |
| WholeCutCalls.directRow rows repeats p j := ⟨row, rfl⟩ | |
| change (if h : ∃ j, WholeCutCalls.directRow rows repeats p row = | |
| WholeCutCalls.directRow rows repeats p j then fresh (Classical.choose h) else _) = fresh row | |
| rw [dite_eq_left hex] | |
| apply congrArg fresh | |
| exact (WholeCutCalls.directRow_injective rows repeats p (Classical.choose_spec hex)).symm | |
| @[simp] theorem merge_otherCall (bg : Complement rows repeats p slots) | |
| (fresh : NativeRows rows p slots) (q : OtherCall rows repeats p) : | |
| (merge rows repeats p slots bg fresh).1 q.val = bg.1 q := by | |
| have hnot : ¬ ∃ row, q.val = WholeCutCalls.directRow rows repeats p row := by | |
| rintro ⟨row, hrow⟩ | |
| exact q.property row hrow | |
| simp only [merge, dite_eq_right hnot] | |
| @[simp] theorem merge_arrays (bg : Complement rows repeats p slots) | |
| (fresh : NativeRows rows p slots) : | |
| (merge rows repeats p slots bg fresh).2 = bg.2 := rfl | |
| @[simp] theorem split_merge (bg : Complement rows repeats p slots) | |
| (fresh : NativeRows rows p slots) : | |
| splitAssembled rows repeats p slots (merge rows repeats p slots bg fresh) = (bg, fresh) := by | |
| apply Prod.ext | |
| · apply Prod.ext | |
| · funext q | |
| exact merge_otherCall rows repeats p slots bg fresh q | |
| · rfl | |
| · funext row | |
| exact merge_directRow rows repeats p slots bg fresh row | |
| @[simp] theorem merge_split (x : Assembled rows repeats p slots) : | |
| merge rows repeats p slots (splitAssembled rows repeats p slots x).1 | |
| (splitAssembled rows repeats p slots x).2 = x := by | |
| apply Prod.ext | |
| · funext q | |
| by_cases h : ∃ row, q = WholeCutCalls.directRow rows repeats p row | |
| · rcases h with ⟨row, rfl⟩ | |
| exact merge_directRow rows repeats p slots _ _ row | |
| · exact merge_otherCall rows repeats p slots _ _ ⟨q, fun row hq => h ⟨row, hq⟩⟩ | |
| · rfl | |
| def splitEquiv : Assembled rows repeats p slots ≃ₗ[F2] | |
| Complement rows repeats p slots × NativeRows rows p slots where | |
| toFun := splitAssembled rows repeats p slots | |
| invFun z := merge rows repeats p slots z.1 z.2 | |
| left_inv := merge_split rows repeats p slots | |
| right_inv z := split_merge rows repeats p slots z.1 z.2 | |
| map_add' := (splitAssembled rows repeats p slots).map_add | |
| map_smul' := (splitAssembled rows repeats p slots).map_smul | |
| @[simp] theorem splitEquiv_apply (x : Assembled rows repeats p slots) : | |
| splitEquiv rows repeats p slots x = splitAssembled rows repeats p slots x := rfl | |
| @[simp] theorem splitEquiv_symm_apply | |
| (z : Complement rows repeats p slots × NativeRows rows p slots) : | |
| (splitEquiv rows repeats p slots).symm z = merge rows repeats p slots z.1 z.2 := rfl | |
| theorem splitAssembled_surjective : Function.Surjective (splitAssembled rows repeats p slots) := | |
| (splitEquiv rows repeats p slots).surjective | |
| theorem splitAssembled_injective : Function.Injective (splitAssembled rows repeats p slots) := | |
| (splitEquiv rows repeats p slots).injective | |
| @[simp] theorem complement_merge (bg : Complement rows repeats p slots) | |
| (fresh : NativeRows rows p slots) : | |
| complement rows repeats p slots (merge rows repeats p slots bg fresh) = bg := | |
| congrArg Prod.fst (split_merge rows repeats p slots bg fresh) | |
| @[simp] theorem selectRows_merge (bg : Complement rows repeats p slots) | |
| (fresh : NativeRows rows p slots) : | |
| LowerCutRows.selectRows rows repeats p slots (merge rows repeats p slots bg fresh) = fresh := | |
| congrArg Prod.snd (split_merge rows repeats p slots bg fresh) | |
| theorem complement_eq_iff (x y : Assembled rows repeats p slots) : | |
| complement rows repeats p slots x = complement rows repeats p slots y ↔ | |
| (∀ q : OtherCall rows repeats p, x.1 q.val = y.1 q.val) ∧ x.2 = y.2 := by | |
| constructor | |
| · intro h | |
| exact ⟨fun q => congrArg (fun z : Complement rows repeats p slots => z.1 q) h, | |
| congrArg (fun z : Complement rows repeats p slots => z.2) h⟩ | |
| · rintro ⟨hcalls, harrays⟩ | |
| exact Prod.ext (funext hcalls) harrays | |
| end | |
| end PerfectCompleteness.LowerCutCallSplit | |
| end | |
| end OAI | |