| import Mathlib |
| import OAI.Probability.BinarySweep.FiniteLaws.SumDite |
| import OAI.Probability.BinarySweep.Trajectories.PathExtension |
| import OAI.Probability.BinarySweep.Conditional.PlacementBlocks |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.Irrep |
| open Representation |
|
|
| variable {A B X Y : Type*} [Fintype A] [Fintype B] [Fintype X] |
|
|
| def complementMap (f : X ≃ Y) (x : B ↪ X) (y : B ↪ Y) |
| (hf : x.trans f.toEmbedding=y) : PlacementComplement x ≃ PlacementComplement y where |
| toFun u := ⟨f u.val,by |
| rintro ⟨b,hb⟩ |
| apply u.property |
| refine ⟨b,f.injective ?_⟩ |
| exact (congrArg (fun y : B ↪ Y => y b) hf).trans hb⟩ |
| invFun u := ⟨f.symm u.val,by |
| rintro ⟨b,hb⟩ |
| apply u.property |
| refine ⟨b,?_⟩ |
| exact (congrArg (fun y : B ↪ Y => y b) hf).symm.trans |
| ((congrArg f hb).trans (f.apply_symm_apply _))⟩ |
| left_inv u := Subtype.ext (f.symm_apply_apply _) |
| right_inv u := Subtype.ext (f.apply_symm_apply _) |
|
|
| omit [Fintype B] [Fintype X] in |
| lemma complementMap_val (f : X ≃ Y) (x : B ↪ X) (y : B ↪ Y) |
| (hf : x.trans f.toEmbedding=y) (u : PlacementComplement x) : |
| (complementMap f x y hf u).val=f u.val := rfl |
|
|
| omit [Fintype B] [Fintype X] in |
| lemma placement_inverse_event (a : Equiv.Perm X) (x y : B ↪ X) |
| (he : x.trans a.toEmbedding=y) : y.trans a.symm.toEmbedding=x := by |
| ext b |
| change a.symm (y b)=x b |
| rw [← he] |
| exact a.symm_apply_apply _ |
|
|
| omit [Fintype A] [Fintype B] [Fintype X] in |
| lemma blockPerm_inl (e : A ⊕ B ≃ X) (a : Equiv.Perm A) (u : A) : |
| blockPerm e a (e (Sum.inl u))=e (Sum.inl (a u)) := by |
| change e (Equiv.sumCongr a (1:Equiv.Perm B) (e.symm (e (Sum.inl u))))=_ |
| rw [e.symm_apply_apply] |
| rfl |
|
|
| omit [Fintype X] in |
| lemma placement_subgroup_complement (e : A ⊕ B ≃ X) (a : Equiv.Perm X) |
| (x y : B ↪ X) (he : x.trans a.toEmbedding=y) : |
| ((cosetEquiv (blockPerm e) (fun x => (placementSection e x)⁻¹) |
| (placement_cosets_bijective e)).symm ((placementSection e y)⁻¹*a)).1 = |
| ((placementComplementEquiv e x).trans (complementMap a x y he)).trans |
| (placementComplementEquiv e y).symm := by |
| have hh := placementCoset_subgroup e a y |
| rw [placement_inverse_event a x y he] at hh |
| ext u |
| apply (placementComplementEquiv e y).injective |
| apply Subtype.ext |
| have hu := congrArg (placementSection e y) (Equiv.congr_fun hh (e (Sum.inl u))) |
| simp only [blockPerm_inl,Equiv.Perm.mul_apply,Equiv.Perm.inv_def, |
| Equiv.apply_symm_apply] at hu |
| simp only [Equiv.trans_apply, Equiv.apply_symm_apply] |
| change placementSection e y (e (Sum.inl _)) = a (placementSection e x (e (Sum.inl u))) |
| simpa only [Equiv.Perm.inv_def] using hu |
|
|
| end BinaryCoordinateSweeps.Irrep |
|
|
| end |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps |
| attribute [local instance] Classical.propDecidable |
| variable {b h h' : ℕ} {bits : Fin b → ℕ} |
| variable {H : PathFamily bits h} {H' : PathFamily bits h'} |
|
|
| def PathExtension.restrictChoice (E : PathExtension H H') |
| (g : ConditionalChoices H') : ConditionalChoices H := |
| ⟨g.val,E.pathEvent_mono g.property⟩ |
|
|
| lemma PathExtension.choiceWeight (E : PathExtension H H') (z : ℝ) |
| (hpos : conditionalNormalizer H' z ≠ 0) (g : ConditionalChoices H') : |
| conditionalChoiceWeight H z (E.restrictChoice g) = |
| (conditionalNormalizer H' z / conditionalNormalizer H z) * |
| conditionalChoiceWeight H' z g := by |
| unfold conditionalChoiceWeight PathExtension.restrictChoice |
| simp only |
| field_simp |
|
|
| lemma PathExtension.sum_restrict {V : Type*} [AddCommMonoid V] |
| (E : PathExtension H H') (f : ConditionalChoices H' → V) : |
| (∑g : ConditionalChoices H, |
| if hg : pathEvent H' g.val then f ⟨g.val,hg⟩ else 0) = |
| ∑g : ConditionalChoices H',f g := by |
| have hL := sum_dite_zero (pathEvent H) |
| (fun (g : GridChoices bits) (_ : pathEvent H g) => |
| if hg' : pathEvent H' g then f ⟨g,hg'⟩ else 0) |
| have hR := sum_dite_zero (pathEvent H') (fun g hg => f ⟨g,hg⟩) |
| refine Eq.trans ?_ (Eq.trans hL.symm (Eq.trans ?_ (Eq.trans hR ?_))) |
| · apply Finset.sum_congr |
| · ext g; simp only [Finset.mem_univ] |
| intro g _ |
| split_ifs <;> rfl |
| · apply Finset.sum_congr rfl |
| intro g _ |
| by_cases hg : pathEvent H' g |
| · simp only [hg,E.pathEvent_mono hg,dite_eq_left] |
| · simp [hg] |
| · apply Finset.sum_congr |
| · ext g; simp only [Finset.mem_univ] |
| intro g _ |
| rfl |
| |
| lemma PathExtension.conditional_sum {V : Type*} [AddCommGroup V] [Module ℝ V] |
| (E : PathExtension H H') (z : ℝ) (hpos : conditionalNormalizer H' z ≠ 0) |
| (f : ConditionalChoices H' → V) : |
| (∑g : ConditionalChoices H, |
| if hg : pathEvent H' g.val then conditionalChoiceWeight H z g • f ⟨g.val,hg⟩ else 0) = |
| (conditionalNormalizer H' z / conditionalNormalizer H z) • |
| ∑g : ConditionalChoices H', conditionalChoiceWeight H' z g • f g := by |
| rw [Finset.smul_sum] |
| simp_rw [← mul_smul] |
| rw [← E.sum_restrict (fun g => |
| ((conditionalNormalizer H' z / conditionalNormalizer H z) * |
| conditionalChoiceWeight H' z g) • f g)] |
| apply Finset.sum_congr rfl |
| intro g _ |
| split_ifs with hg |
| · rw [← E.choiceWeight z hpos ⟨g.val,hg⟩] |
| rfl |
| · rfl |
|
|
| end BinaryCoordinateSweeps |
|
|
| end |
|
|
| end OAI |
|
|
