| import Mathlib |
| import OAI.Probability.BinarySweep.GridBounds.GridSplit |
| import OAI.Probability.BinarySweep.Trajectories.EndpointEvents |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.GridSplit |
|
|
| section |
| variable {m n h : ℕ} (bits : Fin (m+n) → ℕ) |
|
|
| lemma outside_left (j : Fin m) (x : GridSlot bits) : |
| (leftOutsideEquiv bits j) (fun i => x i.val) = |
| (rightSlot bits x,fun i : {i : Fin m // i≠j} => leftSlot bits x i.val) := rfl |
| lemma outside_right (j : Fin n) (x : GridSlot bits) : |
| (rightOutsideEquiv bits j) (fun i => x i.val) = |
| (leftSlot bits x,fun i : {i : Fin n // i≠j} => rightSlot bits x i.val) := rfl |
|
|
| lemma rowChoices_at (g : GridChoices bits) (x : GridSlot bits) (j : Fin m) : |
| rowChoices bits g (rightSlot bits x) j (fun i => leftSlot bits x i.val) = |
| g (j.castAdd n) (fun i => x i.val) := by |
| unfold rowChoices |
| rw [← outside_left,Equiv.symm_apply_apply] |
|
|
| lemma columnChoices_at (g : GridChoices bits) (x : GridSlot bits) (j : Fin n) : |
| columnChoices bits g (leftSlot bits x) j (fun i => rightSlot bits x i.val) = |
| g (j.natAdd m) (fun i => x i.val) := by |
| unfold columnChoices |
| rw [← outside_right,Equiv.symm_apply_apply] |
|
|
| lemma gridWeight_split (z : ℝ) (g : GridChoices bits) : |
| gridWeight bits z g = |
| (∏y : GridSlot (rightBits bits), gridWeight (leftBits bits) z (rowChoices bits g y)) * |
| (∏x : GridSlot (leftBits bits), gridWeight (rightBits bits) z (columnChoices bits g x)) := by |
| unfold gridWeight |
| rw [Fin.prod_univ_add] |
| congr 1 |
| · rw [Finset.prod_comm] |
| apply Finset.prod_congr rfl |
| intro j _ |
| have he := (leftOutsideEquiv bits j).symm.prod_comp (fun u => lineLaw (bits (j.castAdd n)) z (g (j.castAdd n) u)) |
| rw [Fintype.prod_prod_type] at he |
| exact he.symm |
| · rw [Finset.prod_comm] |
| apply Finset.prod_congr rfl |
| intro j _ |
| have he := (rightOutsideEquiv bits j).symm.prod_comp (fun u => lineLaw (bits (j.natAdd m)) z (g (j.natAdd m) u)) |
| rw [Fintype.prod_prod_type] at he |
| exact he.symm |
|
|
| lemma gridLayer_path_iff {b h : ℕ} {a : Fin b → ℕ} (H : PathFamily a h) |
| (g : GridChoices a) (j : Fin b) (k : Fin h) : |
| gridLayer a g j (H.position j.castSucc k)=H.position j.succ k ↔ |
| g j (fun i => H.position j.castSucc k i.val) (H.position j.castSucc k j)=H.position j.succ k j := by |
| constructor |
| · intro he |
| have hh := congrFun he j |
| rwa [gridLayer_at] at hh |
| · intro he |
| funext i |
| by_cases hi : i=j |
| · subst i; exact (gridLayer_at g j _).trans he |
| · rw [gridLayer_other a g j i hi,H.changes_only_stage j k i hi] |
|
|
| end |
|
|
| variable {m n h : ℕ} (bits : Fin (m+n) → ℕ) (H : PathFamily bits h) |
|
|
| lemma row_stage_iff (g : GridChoices bits) (y : GridSlot (rightBits bits)) |
| (j : Fin m) (a : RowLabels bits H y) : |
| gridLayer (leftBits bits) (rowChoices bits g y) j |
| ((rowFamily bits H y).position j.castSucc (Fintype.equivFin (RowLabels bits H y) a)) = |
| (rowFamily bits H y).position j.succ (Fintype.equivFin (RowLabels bits H y) a) ↔ |
| gridLayer bits g (j.castAdd n) (H.position (leftTime j.castSucc) a.val) = |
| H.position (leftTime j.succ) a.val := by |
| change _ ↔ gridLayer bits g (j.castAdd n) |
| (H.position (j.castAdd n).castSucc a.val)=H.position (j.castAdd n).succ a.val |
| rw [gridLayer_path_iff (rowFamily bits H y), |
| gridLayer_path_iff H g (j.castAdd n) a.val] |
| simp only [rowFamily,Equiv.symm_apply_apply] |
| have hr : rightSlot bits (H.position (leftTime j.castSucc) a.val)=y := |
| (rightSlot_leftTime bits H j.castSucc a.val).trans a.property |
| have hc : rowChoices bits g y j |
| (fun i => leftSlot bits (H.position (leftTime j.castSucc) a.val) i.val) = |
| g (j.castAdd n) (fun i => H.position (leftTime j.castSucc) a.val i.val) := by |
| simpa only [hr] using rowChoices_at bits g (H.position (leftTime j.castSucc) a.val) j |
| rw [hc] |
| rfl |
|
|
| lemma column_stage_iff (g : GridChoices bits) (x : GridSlot (leftBits bits)) |
| (j : Fin n) (a : ColumnLabels bits H x) : |
| gridLayer (rightBits bits) (columnChoices bits g x) j |
| ((columnFamily bits H x).position j.castSucc (Fintype.equivFin (ColumnLabels bits H x) a)) = |
| (columnFamily bits H x).position j.succ (Fintype.equivFin (ColumnLabels bits H x) a) ↔ |
| gridLayer bits g (j.natAdd m) (H.position (rightTime j.castSucc) a.val) = |
| H.position (rightTime j.succ) a.val := by |
| change _ ↔ gridLayer bits g (j.natAdd m) |
| (H.position (j.natAdd m).castSucc a.val)=H.position (j.natAdd m).succ a.val |
| rw [gridLayer_path_iff (columnFamily bits H x), |
| gridLayer_path_iff H g (j.natAdd m) a.val] |
| simp only [columnFamily,Equiv.symm_apply_apply] |
| have hr : leftSlot bits (H.position (rightTime j.castSucc) a.val)=x := |
| (leftSlot_rightTime bits H j.castSucc a.val).trans a.property |
| have hc : columnChoices bits g x j |
| (fun i => rightSlot bits (H.position (rightTime j.castSucc) a.val) i.val) = |
| g (j.natAdd m) (fun i => H.position (rightTime j.castSucc) a.val i.val) := by |
| simpa only [hr] using columnChoices_at bits g (H.position (rightTime j.castSucc) a.val) j |
| rw [hc] |
| rfl |
|
|
| theorem pathEvent_split (g : GridChoices bits) : |
| pathEvent H g ↔ |
| (∀y, pathEvent (rowFamily bits H y) (rowChoices bits g y)) ∧ |
| (∀x, pathEvent (columnFamily bits H x) (columnChoices bits g x)) := by |
| constructor |
| · intro hg |
| constructor |
| · intro y j k |
| obtain ⟨a,rfl⟩ := (Fintype.equivFin (RowLabels bits H y)).surjective k |
| exact (row_stage_iff bits H g y j a).mpr (hg _ _) |
| · intro x j k |
| obtain ⟨a,rfl⟩ := (Fintype.equivFin (ColumnLabels bits H x)).surjective k |
| exact (column_stage_iff bits H g x j a).mpr (hg _ _) |
| · rintro ⟨hL,hR⟩ j k |
| induction j using Fin.addCases with |
| | left j => |
| let y := rightSlot bits (H.position 0 k) |
| let a : RowLabels bits H y := ⟨k,rfl⟩ |
| exact (row_stage_iff bits H g y j a).mp (hL y j _) |
| | right j => |
| let x := leftSlot bits (H.position (rightTime (m:=m) 0) k) |
| let a : ColumnLabels bits H x := ⟨k,rfl⟩ |
| exact (column_stage_iff bits H g x j a).mp (hR x j _) |
|
|
| end BinaryCoordinateSweeps.GridSplit |
|
|
| end |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.GridSplit |
| attribute [local instance] Classical.propDecidable |
| variable {m n h : ℕ} (bits : Fin (m+n) → ℕ) (H : PathFamily bits h) |
|
|
| lemma rowChoices_symm (LR : (GridSlot (rightBits bits) → GridChoices (leftBits bits)) × |
| (GridSlot (leftBits bits) → GridChoices (rightBits bits))) : |
| rowChoices bits ((choicesEquiv bits).symm LR)=LR.1 := |
| congrArg Prod.fst ((choicesEquiv bits).apply_symm_apply LR) |
| lemma columnChoices_symm (LR : (GridSlot (rightBits bits) → GridChoices (leftBits bits)) × |
| (GridSlot (leftBits bits) → GridChoices (rightBits bits))) : |
| columnChoices bits ((choicesEquiv bits).symm LR)=LR.2 := |
| congrArg Prod.snd ((choicesEquiv bits).apply_symm_apply LR) |
|
|
| lemma eventWeight_split (z : ℝ) (g : GridChoices bits) : |
| (if pathEvent H g then gridWeight bits z g else 0) = |
| (∏y, if pathEvent (rowFamily bits H y) (rowChoices bits g y) then |
| gridWeight (leftBits bits) z (rowChoices bits g y) else 0) * |
| (∏x, if pathEvent (columnFamily bits H x) (columnChoices bits g x) then |
| gridWeight (rightBits bits) z (columnChoices bits g x) else 0) := by |
| classical |
| rw [pathEvent_split,gridWeight_split] |
| simp only [Fintype.prod_ite_zero] |
| split_ifs <;> simp_all |
|
|
| theorem conditionalNormalizer_split (z : ℝ) : |
| conditionalNormalizer H z = |
| (∏y, conditionalNormalizer (rowFamily bits H y) z) * |
| (∏x, conditionalNormalizer (columnFamily bits H x) z) := by |
| classical |
| let : Fintype (GridChoices (leftBits bits)) := inferInstance |
| let : Fintype (GridChoices (rightBits bits)) := inferInstance |
| have he := (choicesEquiv bits).symm.sum_comp |
| (fun g => if pathEvent H g then gridWeight bits z g else 0) |
| have hs (LR : (GridSlot (rightBits bits) → GridChoices (leftBits bits)) × |
| (GridSlot (leftBits bits) → GridChoices (rightBits bits))) : |
| (if pathEvent H ((choicesEquiv bits).symm LR) then |
| gridWeight bits z ((choicesEquiv bits).symm LR) else 0) = |
| (∏y, if pathEvent (rowFamily bits H y) (LR.1 y) then |
| gridWeight (leftBits bits) z (LR.1 y) else 0) * |
| (∏x, if pathEvent (columnFamily bits H x) (LR.2 x) then |
| gridWeight (rightBits bits) z (LR.2 x) else 0) := by |
| classical |
| rw [eventWeight_split,rowChoices_symm,columnChoices_symm] |
| simp_rw [hs] at he |
| unfold conditionalNormalizer |
| rw [← he,Fintype.sum_prod_type] |
| simp_rw [← Finset.mul_sum] |
| rw [← Finset.sum_mul] |
| congr 1 |
| · exact (Fintype.prod_sum (fun (y : GridSlot (rightBits bits)) (g : GridChoices (leftBits bits)) => |
| if pathEvent (rowFamily bits H y) g then gridWeight (leftBits bits) z g else 0)).symm |
| · exact (Fintype.prod_sum (fun (x : GridSlot (leftBits bits)) (g : GridChoices (rightBits bits)) => |
| if pathEvent (columnFamily bits H x) g then gridWeight (rightBits bits) z g else 0)).symm |
|
|
| def conditionalChoicesEquiv : ConditionalChoices H ≃ |
| (∀y, ConditionalChoices (rowFamily bits H y)) × |
| (∀x, ConditionalChoices (columnFamily bits H x)) where |
| toFun g := (fun y => ⟨rowChoices bits g.val y,(pathEvent_split bits H g.val).mp g.property |>.1 y⟩, |
| fun x => ⟨columnChoices bits g.val x,(pathEvent_split bits H g.val).mp g.property |>.2 x⟩) |
| invFun LR := ⟨(choicesEquiv bits).symm (fun y => (LR.1 y).val,fun x => (LR.2 x).val), by |
| rw [pathEvent_split,rowChoices_symm,columnChoices_symm] |
| exact ⟨fun y => (LR.1 y).property,fun x => (LR.2 x).property⟩⟩ |
| left_inv g := by |
| classical |
| apply Subtype.ext |
| exact (choicesEquiv bits).symm_apply_apply g.val |
| right_inv LR := by |
| classical |
| apply Prod.ext <;> funext a <;> apply Subtype.ext |
| · exact congrFun (rowChoices_symm bits _) a |
| · exact congrFun (columnChoices_symm bits _) a |
|
|
| theorem conditionalChoiceWeight_split (z : ℝ) (g : ConditionalChoices H) : |
| conditionalChoiceWeight H z g = |
| (∏y, conditionalChoiceWeight (rowFamily bits H y) z |
| ((conditionalChoicesEquiv bits H g).1 y)) * |
| (∏x, conditionalChoiceWeight (columnFamily bits H x) z |
| ((conditionalChoicesEquiv bits H g).2 x)) := by |
| classical |
| unfold conditionalChoiceWeight |
| rw [gridWeight_split,conditionalNormalizer_split] |
| simp only [Finset.prod_div_distrib,conditionalChoicesEquiv] |
| exact mul_div_mul_comm _ _ _ _ |
|
|
| end BinaryCoordinateSweeps.GridSplit |
|
|
| end |
|
|
| end OAI |
|
|
