math / data /lean /OAI /Probability /CoordinateSweeps /Conditioning.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
48.6 kB
import Mathlib import OAI.Probability.CoordinateSweeps.Grid import OAI.RepresentationTheory.Unitary.Basic import OAI.Analysis.Matrix.TensorMoment namespace OAI noncomputable section open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder attribute [local instance] Classical.propDecidable noncomputable section open scoped BigOperators ComplexConjugate Matrix.Norms.L2Operator attribute [local instance] Classical.propDecidable noncomputable section open scoped BigOperators ComplexOrder MatrixOrder attribute [local instance] Classical.propDecidable noncomputable section open scoped BigOperators ENNReal open MeasureTheory noncomputable section open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder noncomputable section open scoped BigOperators attribute [local instance] Classical.propDecidable noncomputable section open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder attribute [local instance] Classical.propDecidable namespace CoordinateSweeps.Grid /- Concatenation of the *ordered* coordinate sequences. -/ def concat (A B : Grid) : Grid where b := A.b+B.b positive := Nat.add_pos_left A.positive _ bits := Fin.addCases A.bits B.bits @[simp] lemma concat_bits_left (A B : Grid) (i : Fin A.b) : (concat A B).bits (Fin.castAdd B.b i)=A.bits i := by simp [concat] @[simp] lemma concat_bits_right (A B : Grid) (i : Fin B.b) : (concat A B).bits (Fin.natAdd A.b i)=B.bits i := by simp [concat] /- Literal Cartesian identification for the split, retaining all bit labels. -/ def splitSlots (A B : Grid) : (concat A B).Slot ≃ A.Slot × B.Slot := ((Equiv.prodPiEquivSumPi (fun i => Cube (A.bits i)) (fun j => Cube (B.bits j))).trans (Equiv.piCongr finSumFinEquiv (fun i => by cases i with | inl i => exact Equiv.cast (by simp [concat]) | inr j => exact Equiv.cast (by simp [concat])))).symm @[simp] lemma splitSlots_left (A B : Grid) (x : (concat A B).Slot) (i : Fin A.b) : (splitSlots A B x).1 i = (Equiv.cast (by simp : Cube ((concat A B).bits (Fin.castAdd B.b i))=Cube (A.bits i))) (x (Fin.castAdd B.b i)) := by rfl @[simp] lemma splitSlots_right (A B : Grid) (x : (concat A B).Slot) (j : Fin B.b) : (splitSlots A B x).2 j = (Equiv.cast (by simp : Cube ((concat A B).bits (Fin.natAdd A.b j))=Cube (B.bits j))) (x (Fin.natAdd A.b j)) := by rfl lemma concat_size (A B : Grid) : (concat A B).size=A.size*B.size := by change (∏ j : Fin (A.b+B.b), 2^Fin.addCases A.bits B.bits j)=A.size*B.size rw [Fin.prod_univ_add] simp [size] lemma concat_allowed (A B : Grid) (r : ℕ) : (concat A B).Allowed r ↔ A.Allowed r ∧ B.Allowed r := by constructor · intro h exact ⟨fun i => by simpa using h (Fin.castAdd B.b i), fun i => by simpa using h (Fin.natAdd A.b i)⟩ · rintro ⟨hA,hB⟩ i induction i using Fin.addCases with | left i => simpa using hA i | right i => simpa using hB i end CoordinateSweeps.Grid noncomputable section attribute [local instance] Classical.propDecidable namespace CoordinateSweeps /- Deleting a head coordinate commutes with the literal Fin concatenation. -/ def finDeleteLeft {m n : ℕ} (i : Fin m) : ({j : Fin m // j ≠ i} ⊕ Fin n) ≃ {j : Fin (m+n) // j ≠ Fin.castAdd n i} where toFun z := match z with | Sum.inl j => ⟨Fin.castAdd n j.val,by simpa using j.property⟩ | Sum.inr j => ⟨Fin.natAdd m j,by intro h; have ht := congrArg Fin.val h; simp at ht; omega⟩ invFun z := Fin.addCases (motive := fun j : Fin (m+n) => j ≠ Fin.castAdd n i → ({j : Fin m // j ≠ i} ⊕ Fin n)) (fun j (h : Fin.castAdd n j ≠ Fin.castAdd n i) => Sum.inl ⟨j,by simpa using h⟩) (fun j (_h : Fin.natAdd m j ≠ Fin.castAdd n i) => Sum.inr j) z.val z.property left_inv z := by cases z <;> simp right_inv z := by rcases z with ⟨j,hj⟩ induction j using Fin.addCases with | left j => simp | right j => simp @[simp] lemma finDeleteLeft_inl {m n : ℕ} (i : Fin m) (j : {j : Fin m // j ≠ i}) : (finDeleteLeft (n := n) i (Sum.inl j)).val=Fin.castAdd n j.val := rfl @[simp] lemma finDeleteLeft_inr {m n : ℕ} (i : Fin m) (j : Fin n) : (finDeleteLeft (n := n) i (Sum.inr j)).val=Fin.natAdd m j := rfl /- Deleting a tail coordinate, in the same original head-then-tail order. -/ def finDeleteRight {m n : ℕ} (i : Fin n) : (Fin m ⊕ {j : Fin n // j ≠ i}) ≃ {j : Fin (m+n) // j ≠ Fin.natAdd m i} where toFun z := match z with | Sum.inl j => ⟨Fin.castAdd n j,by intro h; have ht := congrArg Fin.val h; simp at ht; omega⟩ | Sum.inr j => ⟨Fin.natAdd m j.val,by simpa using j.property⟩ invFun z := Fin.addCases (motive := fun j : Fin (m+n) => j ≠ Fin.natAdd m i → (Fin m ⊕ {j : Fin n // j ≠ i})) (fun j (_h : Fin.castAdd n j ≠ Fin.natAdd m i) => Sum.inl j) (fun j (h : Fin.natAdd m j ≠ Fin.natAdd m i) => Sum.inr ⟨j,by simpa using h⟩) z.val z.property left_inv z := by cases z <;> simp right_inv z := by rcases z with ⟨j,hj⟩ induction j using Fin.addCases with | left j => simp | right j => simp @[simp] lemma finDeleteRight_inl {m n : ℕ} (i : Fin n) (j : Fin m) : (finDeleteRight (m := m) i (Sum.inl j)).val=Fin.castAdd n j := rfl @[simp] lemma finDeleteRight_inr {m n : ℕ} (i : Fin n) (j : {j : Fin n // j ≠ i}) : (finDeleteRight (m := m) i (Sum.inr j)).val=Fin.natAdd m j.val := rfl end CoordinateSweeps namespace CoordinateSweeps.Grid /- Row line chart: the other head coordinates and the fixed tail row label. -/ def rowLines (A B : Grid) (i : Fin A.b) : (A.Line i × B.Slot) ≃ (concat A B).Line (Fin.castAdd B.b i) := (Equiv.prodPiEquivSumPi (fun j : {j : Fin A.b // j ≠ i} => Cube (A.bits j)) (fun k => Cube (B.bits k))).trans (Equiv.piCongr (finDeleteLeft (n := B.b) i) (fun j => by cases j with | inl j => exact Equiv.cast (by change Cube (A.bits j)=Cube (Fin.addCases A.bits B.bits (Fin.castAdd B.b j)) simp) | inr k => exact Equiv.cast (by change Cube (B.bits k)=Cube (Fin.addCases A.bits B.bits (Fin.natAdd A.b k)) simp))) /- Column line chart: the fixed head label and the other tail coordinates. -/ def columnLines (A B : Grid) (i : Fin B.b) : (A.Slot × B.Line i) ≃ (concat A B).Line (Fin.natAdd A.b i) := (Equiv.prodPiEquivSumPi (fun j => Cube (A.bits j)) (fun k : {k : Fin B.b // k ≠ i} => Cube (B.bits k))).trans (Equiv.piCongr (finDeleteRight (m := A.b) i) (fun j => by cases j with | inl j => exact Equiv.cast (by change Cube (A.bits j)=Cube (Fin.addCases A.bits B.bits (Fin.castAdd B.b j)) simp) | inr k => exact Equiv.cast (by change Cube (B.bits k)=Cube (Fin.addCases A.bits B.bits (Fin.natAdd A.b k)) simp))) lemma rowLines_evaluation (A B : Grid) (i : Fin A.b) (x : (concat A B).Slot) : (rowLines A B i).symm (fun j => x j.val)= ((fun j : {j : Fin A.b // j ≠ i} => (splitSlots A B x).1 j.val),(splitSlots A B x).2) := by apply Prod.ext · funext j rfl · funext j rfl lemma columnLines_evaluation (A B : Grid) (i : Fin B.b) (x : (concat A B).Slot) : (columnLines A B i).symm (fun j => x j.val)= ((splitSlots A B x).1,(fun j : {j : Fin B.b // j ≠ i} => (splitSlots A B x).2 j.val)) := by apply Prod.ext · funext j rfl · funext j rfl end CoordinateSweeps.Grid namespace CoordinateSweeps.Grid def leftCube (A B : Grid) (i : Fin A.b) : Cube ((concat A B).bits (Fin.castAdd B.b i)) ≃ Cube (A.bits i) := Equiv.cast (by simp) def rightCube (A B : Grid) (j : Fin B.b) : Cube ((concat A B).bits (Fin.natAdd A.b j)) ≃ Cube (B.bits j) := Equiv.cast (by simp) def prefixFiber (A B : Grid) (i : Fin A.b) : ((concat A B).Line (Fin.castAdd B.b i) → Equiv.Perm (Cube ((concat A B).bits (Fin.castAdd B.b i)))) ≃ (B.Slot → A.Line i → Equiv.Perm (Cube (A.bits i))) := (Equiv.arrowCongr ((rowLines A B i).symm.trans (Equiv.prodComm _ _)) (leftCube A B i).permCongr).trans (Equiv.curry _ _ _) def suffixFiber (A B : Grid) (i : Fin B.b) : ((concat A B).Line (Fin.natAdd A.b i) → Equiv.Perm (Cube ((concat A B).bits (Fin.natAdd A.b i)))) ≃ (A.Slot → B.Line i → Equiv.Perm (Cube (B.bits i))) := (Equiv.arrowCongr (columnLines A B i).symm (rightCube A B i).permCongr).trans (Equiv.curry _ _ _) /- Exact two-part choice-space equivalence, not just an equality in law. -/ def choicesSplit (A B : Grid) : (concat A B).Choices ≃ ((B.Slot → A.Choices) × (A.Slot → B.Choices)) := ((Equiv.prodCongr (Equiv.piComm (fun (_y : B.Slot) (i : Fin A.b) => A.Line i → Equiv.Perm (Cube (A.bits i)))) (Equiv.piComm (fun (_x : A.Slot) (i : Fin B.b) => B.Line i → Equiv.Perm (Cube (B.bits i))))).trans ((Equiv.prodPiEquivSumPi (fun i : Fin A.b => B.Slot → A.Line i → Equiv.Perm (Cube (A.bits i))) (fun i : Fin B.b => A.Slot → B.Line i → Equiv.Perm (Cube (B.bits i)))).trans (Equiv.piCongr finSumFinEquiv (fun i => by cases i with | inl i => exact (prefixFiber A B i).symm | inr j => exact (suffixFiber A B j).symm)))).symm def rowChoices (A B : Grid) (ω : (concat A B).Choices) (y : B.Slot) : A.Choices := (choicesSplit A B ω).1 y def columnChoices (A B : Grid) (ω : (concat A B).Choices) (x : A.Slot) : B.Choices := (choicesSplit A B ω).2 x lemma rowChoices_apply (A B : Grid) (ω : (concat A B).Choices) (y : B.Slot) (i : Fin A.b) (L : A.Line i) : rowChoices A B ω y i L=(leftCube A B i).permCongr (ω (Fin.castAdd B.b i) (rowLines A B i (L,y))) := by rfl lemma columnChoices_apply (A B : Grid) (ω : (concat A B).Choices) (x : A.Slot) (i : Fin B.b) (L : B.Line i) : columnChoices A B ω x i L=(rightCube A B i).permCongr (ω (Fin.natAdd A.b i) (columnLines A B i (x,L))) := by rfl end CoordinateSweeps.Grid namespace CoordinateSweeps.Grid lemma rowLines_at_slot (A B : Grid) (i : Fin A.b) (x : (concat A B).Slot) : rowLines A B i ((fun j => (splitSlots A B x).1 j.val),(splitSlots A B x).2)= (fun (j : {j : Fin (concat A B).b // j ≠ Fin.castAdd B.b i}) => x j.val) := by have hh := congrArg (rowLines A B i) (rowLines_evaluation A B i x) simpa using hh.symm lemma columnLines_at_slot (A B : Grid) (i : Fin B.b) (x : (concat A B).Slot) : columnLines A B i ((splitSlots A B x).1,(fun j => (splitSlots A B x).2 j.val))= (fun (j : {j : Fin (concat A B).b // j ≠ Fin.natAdd A.b i}) => x j.val) := by have hh := congrArg (columnLines A B i) (columnLines_evaluation A B i x) simpa using hh.symm /- A head stage really acts by independent row stages in the Cartesian chart. -/ theorem stage_split_left (A B : Grid) (ω : (concat A B).Choices) (i : Fin A.b) (x : (concat A B).Slot) : splitSlots A B ((concat A B).stage ω (Fin.castAdd B.b i) x)= (A.stage (rowChoices A B ω (splitSlots A B x).2) i (splitSlots A B x).1, (splitSlots A B x).2) := by apply Prod.ext · funext j by_cases h : j=i · subst j change leftCube A B i ((concat A B).stage ω (Fin.castAdd B.b i) x (Fin.castAdd B.b i))=A.stage (rowChoices A B ω (splitSlots A B x).2) i (splitSlots A B x).1 i erw [stage_apply_same,stage_apply_same,rowChoices_apply] simp only [Equiv.permCongr_apply,rowLines_at_slot] change leftCube A B i (ω _ _ (x _))=leftCube A B i (ω _ _ ((leftCube A B i).symm (leftCube A B i (x _)))) rw [Equiv.symm_apply_apply] · change leftCube A B j ((concat A B).stage ω (Fin.castAdd B.b i) x (Fin.castAdd B.b j))=A.stage (rowChoices A B ω (splitSlots A B x).2) i (splitSlots A B x).1 j erw [stage_apply_ne _ _ _ _ h] change leftCube A B j ((concat A B).stage ω (Fin.castAdd B.b i) x (Fin.castAdd B.b j))=leftCube A B j (x _) erw [stage_apply_ne _ _ _ _ (by intro hh; apply h; apply Fin.ext; have := congrArg Fin.val hh; simp at this; omega)] · funext j change rightCube A B j ((concat A B).stage ω (Fin.castAdd B.b i) x (Fin.natAdd A.b j))=rightCube A B j (x _) erw [stage_apply_ne _ _ _ _ (by intro h; have hh := congrArg Fin.val h; simp at hh; omega)] /- A tail stage really acts by independent column stages. -/ theorem stage_split_right (A B : Grid) (ω : (concat A B).Choices) (i : Fin B.b) (x : (concat A B).Slot) : splitSlots A B ((concat A B).stage ω (Fin.natAdd A.b i) x)= ((splitSlots A B x).1,B.stage (columnChoices A B ω (splitSlots A B x).1) i (splitSlots A B x).2) := by apply Prod.ext · funext j change leftCube A B j ((concat A B).stage ω (Fin.natAdd A.b i) x (Fin.castAdd B.b j))=leftCube A B j (x _) erw [stage_apply_ne _ _ _ _ (by intro h; have hh := congrArg Fin.val h; simp at hh; omega)] · funext j by_cases h : j=i · subst j change rightCube A B i ((concat A B).stage ω (Fin.natAdd A.b i) x (Fin.natAdd A.b i))=B.stage (columnChoices A B ω (splitSlots A B x).1) i (splitSlots A B x).2 i erw [stage_apply_same,stage_apply_same,columnChoices_apply] simp only [Equiv.permCongr_apply,columnLines_at_slot] change rightCube A B i (ω _ _ (x _))=rightCube A B i (ω _ _ ((rightCube A B i).symm (rightCube A B i (x _)))) rw [Equiv.symm_apply_apply] · change rightCube A B j ((concat A B).stage ω (Fin.natAdd A.b i) x (Fin.natAdd A.b j))=B.stage (columnChoices A B ω (splitSlots A B x).1) i (splitSlots A B x).2 j erw [stage_apply_ne _ _ _ _ h] change rightCube A B j ((concat A B).stage ω (Fin.natAdd A.b i) x (Fin.natAdd A.b j))=rightCube A B j (x _) erw [stage_apply_ne _ _ _ _ (by intro hh; apply h; apply Fin.ext; have := congrArg Fin.val hh; simp at this; omega)] end CoordinateSweeps.Grid namespace CoordinateSweeps.Grid lemma boundary_split_prefix (A B : Grid) (ω : (concat A B).Choices) (x : (concat A B).Slot) (t : ℕ) (ht : t≤A.b) : splitSlots A B ((concat A B).boundary ω t x)= (A.boundary (rowChoices A B ω (splitSlots A B x).2) t (splitSlots A B x).1, (splitSlots A B x).2) := by induction t with | zero => simp | succ t ih => have ha : t<A.b := by omega have hc : t<(concat A B).b := by change t<A.b+B.b; omega have hi : (⟨t,hc⟩ : Fin (concat A B).b)=Fin.castAdd B.b (⟨t,ha⟩ : Fin A.b) := rfl rw [(concat A B).boundary_succ ω hc,A.boundary_succ _ ha] simp only [Equiv.Perm.mul_apply] rw [hi,stage_split_left,ih (by omega)] lemma boundary_split_suffix (A B : Grid) (ω : (concat A B).Choices) (x : (concat A B).Slot) (t : ℕ) (ht : t≤B.b) : splitSlots A B ((concat A B).boundary ω (A.b+t) x)= (A.sweep (rowChoices A B ω (splitSlots A B x).2) (splitSlots A B x).1, B.boundary (columnChoices A B ω (A.sweep (rowChoices A B ω (splitSlots A B x).2) (splitSlots A B x).1)) t (splitSlots A B x).2) := by induction t with | zero => simpa [sweep] using boundary_split_prefix A B ω x A.b le_rfl | succ t ih => have hb : t<B.b := by omega have hc : A.b+t<(concat A B).b := by change A.b+t<A.b+B.b; omega have hi : (⟨A.b+t,hc⟩ : Fin (concat A B).b)=Fin.natAdd A.b (⟨t,hb⟩ : Fin B.b) := rfl rw [Nat.add_succ,(concat A B).boundary_succ ω hc,B.boundary_succ _ hb] simp only [Equiv.Perm.mul_apply] rw [hi,stage_split_right,ih (by omega)] /- Actual ordered permutation factorization: row sweeps, then column sweeps. -/ theorem sweep_split (A B : Grid) (ω : (concat A B).Choices) (x : (concat A B).Slot) : splitSlots A B ((concat A B).sweep ω x)= (A.sweep (rowChoices A B ω (splitSlots A B x).2) (splitSlots A B x).1, B.sweep (columnChoices A B ω (A.sweep (rowChoices A B ω (splitSlots A B x).2) (splitSlots A B x).1)) (splitSlots A B x).2) := boundary_split_suffix A B ω x B.b le_rfl end CoordinateSweeps.Grid namespace CoordinateSweeps.Grid def prefixTime (A B : Grid) (t : Fin (A.b+1)) : Fin ((concat A B).b+1) := ⟨t.val,by change t.val<A.b+B.b+1; have := t.isLt; omega⟩ def suffixTime (A B : Grid) (t : Fin (B.b+1)) : Fin ((concat A B).b+1) := ⟨A.b+t.val,by change A.b+t.val<A.b+B.b+1; have := t.isLt; omega⟩ namespace Holes variable {A B : Grid} {h : ℕ} (H : (concat A B).Holes h) def rowOf (i : Fin h) : B.Slot := (splitSlots A B (H.path i 0)).2 def columnOf (i : Fin h) : A.Slot := (splitSlots A B (H.path i (suffixTime A B 0))).1 lemma row_constant (i : Fin h) (t : Fin (A.b+1)) : (splitSlots A B (H.path i (prefixTime A B t))).2=H.rowOf i := by obtain ⟨ω,hω⟩ := H.feasible_of_disjoint rw [← hω i (prefixTime A B t)] change (splitSlots A B ((concat A B).boundary ω t.val (H.path i 0))).2=_ rw [boundary_split_prefix A B ω _ t.val (by have := t.isLt; omega)] rfl lemma column_constant (i : Fin h) (t : Fin (B.b+1)) : (splitSlots A B (H.path i (suffixTime A B t))).1=H.columnOf i := by obtain ⟨ω,hω⟩ := H.feasible_of_disjoint unfold columnOf rw [← hω i (suffixTime A B t),← hω i (suffixTime A B 0)] change (splitSlots A B ((concat A B).boundary ω (A.b+t.val) (H.path i 0))).1= (splitSlots A B ((concat A B).boundary ω (A.b+0) (H.path i 0))).1 rw [boundary_split_suffix A B ω _ t.val (by have := t.isLt; omega), boundary_split_suffix A B ω _ 0 (Nat.zero_le _)] abbrev RowCard (y : B.Slot) := {i : Fin h // H.rowOf i=y} abbrev ColumnCard (x : A.Slot) := {i : Fin h // H.columnOf i=x} def rowCount (y : B.Slot) : ℕ := Fintype.card (H.RowCard y) def columnCount (x : A.Slot) : ℕ := Fintype.card (H.ColumnCard x) def rowCards (y : B.Slot) : Fin (H.rowCount y) ≃ H.RowCard y := (Fintype.equivFin _).symm def columnCards (x : A.Slot) : Fin (H.columnCount x) ≃ H.ColumnCard x := (Fintype.equivFin _).symm /- All holes in one actual row, with the inherited ordered trajectories. -/ def rowHoles (y : B.Slot) : A.Holes (H.rowCount y) where path i t := (splitSlots A B (H.path (H.rowCards y i).val (prefixTime A B t))).1 disjoint t := by intro i j hij apply (H.rowCards y).injective apply Subtype.ext apply H.disjoint (prefixTime A B t) apply (splitSlots A B).injective apply Prod.ext hij exact (H.row_constant _ t).trans ((H.rowCards y i).property.trans ((H.rowCards y j).property.symm.trans (H.row_constant _ t).symm)) coordinate_step i j k hk := by change leftCube A B k (H.path (H.rowCards y i).val (Fin.castAdd B.b j).succ (Fin.castAdd B.b k))= leftCube A B k (H.path (H.rowCards y i).val (Fin.castAdd B.b j).castSucc (Fin.castAdd B.b k)) apply congrArg apply H.coordinate_step intro hh apply hk apply Fin.ext exact congrArg (fun u : Fin (A.b+B.b) => u.val) hh /- All holes in one junction column, with the inherited tail trajectories. -/ def columnHoles (x : A.Slot) : B.Holes (H.columnCount x) where path i t := (splitSlots A B (H.path (H.columnCards x i).val (suffixTime A B t))).2 disjoint t := by intro i j hij apply (H.columnCards x).injective apply Subtype.ext apply H.disjoint (suffixTime A B t) apply (splitSlots A B).injective apply Prod.ext _ hij exact (H.column_constant _ t).trans ((H.columnCards x i).property.trans ((H.columnCards x j).property.symm.trans (H.column_constant _ t).symm)) coordinate_step i j k hk := by change rightCube A B k (H.path (H.columnCards x i).val (Fin.natAdd A.b j).succ (Fin.natAdd A.b k))= rightCube A B k (H.path (H.columnCards x i).val (Fin.natAdd A.b j).castSucc (Fin.natAdd A.b k)) apply congrArg apply H.coordinate_step intro hh apply hk apply Fin.ext have := congrArg Fin.val hh simp at this omega lemma sum_rowCount : ∑ y, H.rowCount y=h := by unfold rowCount rw [← Fintype.card_sigma] exact (Fintype.card_congr (Equiv.sigmaFiberEquiv H.rowOf)).trans (Fintype.card_fin h) lemma sum_columnCount : ∑ x, H.columnCount x=h := by unfold columnCount rw [← Fintype.card_sigma] exact (Fintype.card_congr (Equiv.sigmaFiberEquiv H.columnOf)).trans (Fintype.card_fin h) end Holes end CoordinateSweeps.Grid namespace CoordinateSweeps.Grid.Holes variable {A B : Grid} {h : ℕ} (H : (concat A B).Holes h) lemma row_step_iff (y : B.Slot) (τ : A.Choices) : (H.rowHoles y).StepCompatible τ ↔ ∀ i : Fin h, H.rowOf i=y → ∀ j : Fin A.b, A.stage τ j (splitSlots A B (H.path i (prefixTime A B j.castSucc))).1= (splitSlots A B (H.path i (prefixTime A B j.succ))).1 := by constructor · intro hs i hi j obtain ⟨k,hk⟩ := (H.rowCards y).surjective ⟨i,hi⟩ have he := hs k j change A.stage τ j (splitSlots A B (H.path (H.rowCards y k).val (prefixTime A B j.castSucc))).1= (splitSlots A B (H.path (H.rowCards y k).val (prefixTime A B j.succ))).1 at he simpa only [hk] using he · intro hs k j exact hs (H.rowCards y k).val (H.rowCards y k).property j lemma column_step_iff (x : A.Slot) (τ : B.Choices) : (H.columnHoles x).StepCompatible τ ↔ ∀ i : Fin h, H.columnOf i=x → ∀ j : Fin B.b, B.stage τ j (splitSlots A B (H.path i (suffixTime A B j.castSucc))).2= (splitSlots A B (H.path i (suffixTime A B j.succ))).2 := by constructor · intro hs i hi j obtain ⟨k,hk⟩ := (H.columnCards x).surjective ⟨i,hi⟩ have he := hs k j change B.stage τ j (splitSlots A B (H.path (H.columnCards x k).val (suffixTime A B j.castSucc))).2= (splitSlots A B (H.path (H.columnCards x k).val (suffixTime A B j.succ))).2 at he simpa only [hk] using he · intro hs k j exact hs (H.columnCards x k).val (H.columnCards x k).property j /- The trajectory event is exactly the product of all child trajectory events. -/ theorem compatible_split (ω : (concat A B).Choices) : H.Compatible ω ↔ (∀ y : B.Slot, (H.rowHoles y).Compatible (rowChoices A B ω y)) ∧ (∀ x : A.Slot, (H.columnHoles x).Compatible (columnChoices A B ω x)) := by constructor · intro hω have hs := (H.compatible_iff_step ω).mp hω constructor · intro y apply ((H.rowHoles y).compatible_iff_step _).mpr apply (H.row_step_iff y _).mpr intro i hi j have he := congrArg (fun x => (splitSlots A B x).1) (hs i (Fin.castAdd B.b j)) rw [stage_split_left] at he change A.stage (rowChoices A B ω (splitSlots A B (H.path i (prefixTime A B j.castSucc))).2) j (splitSlots A B (H.path i (prefixTime A B j.castSucc))).1= (splitSlots A B (H.path i (prefixTime A B j.succ))).1 at he rw [H.row_constant i j.castSucc,hi] at he exact he · intro x apply ((H.columnHoles x).compatible_iff_step _).mpr apply (H.column_step_iff x _).mpr intro i hi j have he := congrArg (fun x => (splitSlots A B x).2) (hs i (Fin.natAdd A.b j)) rw [stage_split_right] at he change B.stage (columnChoices A B ω (splitSlots A B (H.path i (suffixTime A B j.castSucc))).1) j (splitSlots A B (H.path i (suffixTime A B j.castSucc))).2= (splitSlots A B (H.path i (suffixTime A B j.succ))).2 at he rw [H.column_constant i j.castSucc,hi] at he exact he · rintro ⟨hR,hC⟩ have hr (y : B.Slot) := (H.row_step_iff y _).mp (((H.rowHoles y).compatible_iff_step _).mp (hR y)) have hc (x : A.Slot) := (H.column_step_iff x _).mp (((H.columnHoles x).compatible_iff_step _).mp (hC x)) apply (H.compatible_iff_step ω).mpr intro i j change Fin (A.b+B.b) at j induction j using Fin.addCases with | left j => apply (splitSlots A B).injective rw [stage_split_left] apply Prod.ext · change A.stage (rowChoices A B ω (splitSlots A B (H.path i (prefixTime A B j.castSucc))).2) j (splitSlots A B (H.path i (prefixTime A B j.castSucc))).1= (splitSlots A B (H.path i (prefixTime A B j.succ))).1 rw [H.row_constant i j.castSucc] exact hr (H.rowOf i) i rfl j · exact (H.row_constant i j.castSucc).trans (H.row_constant i j.succ).symm | right j => apply (splitSlots A B).injective rw [stage_split_right] apply Prod.ext · exact (H.column_constant i j.castSucc).trans (H.column_constant i j.succ).symm · change B.stage (columnChoices A B ω (splitSlots A B (H.path i (suffixTime A B j.castSucc))).1) j (splitSlots A B (H.path i (suffixTime A B j.castSucc))).2= (splitSlots A B (H.path i (suffixTime A B j.succ))).2 rw [H.column_constant i j.castSucc] exact hc (H.columnOf i) i rfl j end CoordinateSweeps.Grid.Holes namespace CoordinateSweeps.Grid /- The literal real line mass, without changing any conditioning. -/ def rawLineWeight (k : ℕ) (z : ℝ) (σ : Equiv.Perm (Cube k)) : ℝ := (1-z)*(Fintype.card (Equiv.Perm (Cube k)) : ℝ)⁻¹ + z*binaryLaw k σ lemma rawLineWeight_cast {k l : ℕ} (h : k=l) (z : ℝ) (σ : Equiv.Perm (Cube k)) : rawLineWeight k z σ=rawLineWeight l z ((Equiv.cast (congrArg Cube h)).permCongr σ) := by subst l rfl lemma prefix_weight (A B : Grid) (ω : (concat A B).Choices) (z : ℝ) (i : Fin A.b) : (∏ L : (concat A B).Line (Fin.castAdd B.b i), rawLineWeight ((concat A B).bits (Fin.castAdd B.b i)) z (ω (Fin.castAdd B.b i) L))= ∏ y : B.Slot, ∏ L : A.Line i, rawLineWeight (A.bits i) z (rowChoices A B ω y i L) := by rw [← (rowLines A B i).prod_comp] rw [Fintype.prod_prod_type,Finset.prod_comm] apply Finset.prod_congr rfl intro y _ apply Finset.prod_congr rfl intro L _ rw [rowChoices_apply] exact rawLineWeight_cast (concat_bits_left A B i) z _ lemma suffix_weight (A B : Grid) (ω : (concat A B).Choices) (z : ℝ) (i : Fin B.b) : (∏ L : (concat A B).Line (Fin.natAdd A.b i), rawLineWeight ((concat A B).bits (Fin.natAdd A.b i)) z (ω (Fin.natAdd A.b i) L))= ∏ x : A.Slot, ∏ L : B.Line i, rawLineWeight (B.bits i) z (columnChoices A B ω x i L) := by rw [← (columnLines A B i).prod_comp] rw [Fintype.prod_prod_type] apply Finset.prod_congr rfl intro x _ apply Finset.prod_congr rfl intro L _ rw [columnChoices_apply] exact rawLineWeight_cast (concat_bits_right A B i) z _ /- Complete independent choice mass factors into literal row and column masses. -/ theorem choiceWeight_split (A B : Grid) (ω : (concat A B).Choices) (z : ℝ) : (concat A B).choiceWeight z ω = (∏ y : B.Slot, A.choiceWeight z (rowChoices A B ω y))* (∏ x : A.Slot, B.choiceWeight z (columnChoices A B ω x)) := by have hr (G : Grid) (τ : G.Choices) : G.choiceWeight z τ= ∏ i : Fin G.b, ∏ L : G.Line i, rawLineWeight (G.bits i) z (τ i L) := by rfl rw [hr] erw [Fin.prod_univ_add] congr 1 · trans ∏ i : Fin A.b, ∏ y : B.Slot, ∏ L : A.Line i, rawLineWeight (A.bits i) z (rowChoices A B ω y i L) · apply Finset.prod_congr rfl intro i _ convert prefix_weight A B ω z i using 1 congr 3 exact Subsingleton.elim _ _ · rw [Finset.prod_comm] rfl · trans ∏ i : Fin B.b, ∏ x : A.Slot, ∏ L : B.Line i, rawLineWeight (B.bits i) z (columnChoices A B ω x i L) · apply Finset.prod_congr rfl intro i _ convert suffix_weight A B ω z i using 1 congr 3 exact Subsingleton.elim _ _ · rw [Finset.prod_comm] rfl end CoordinateSweeps.Grid namespace CoordinateSweeps.Grid.Holes variable {A B : Grid} {h : ℕ} (H : (concat A B).Holes h) def splitCompatibleChoices : {ω : (concat A B).Choices // H.Compatible ω} ≃ ((∀ y : B.Slot, {τ : A.Choices // (H.rowHoles y).Compatible τ}) × (∀ x : A.Slot, {τ : B.Choices // (H.columnHoles x).Compatible τ})) where toFun ω := ((fun y => ⟨rowChoices A B ω.val y,((H.compatible_split ω.val).mp ω.property).1 y⟩), fun x => ⟨columnChoices A B ω.val x,((H.compatible_split ω.val).mp ω.property).2 x⟩) invFun τ := ⟨(choicesSplit A B).symm ((fun y => (τ.1 y).val),(fun x => (τ.2 x).val)),by apply (H.compatible_split _).mpr constructor · intro y change (H.rowHoles y).Compatible ((choicesSplit A B ((choicesSplit A B).symm _)).1 y) rw [Equiv.apply_symm_apply] exact (τ.1 y).property · intro x change (H.columnHoles x).Compatible ((choicesSplit A B ((choicesSplit A B).symm _)).2 x) rw [Equiv.apply_symm_apply] exact (τ.2 x).property⟩ left_inv ω := by apply Subtype.ext change (choicesSplit A B).symm (choicesSplit A B ω.val)=ω.val exact Equiv.symm_apply_apply _ _ right_inv τ := by apply Prod.ext · funext y apply Subtype.ext change ((choicesSplit A B) ((choicesSplit A B).symm _)).1 y=(τ.1 y).val rw [Equiv.apply_symm_apply] · funext x apply Subtype.ext change ((choicesSplit A B) ((choicesSplit A B).symm _)).2 x=(τ.2 x).val rw [Equiv.apply_symm_apply] lemma splitCompatibleChoices_weight (z : ℝ) (τ : (∀ y : B.Slot, {τ : A.Choices // (H.rowHoles y).Compatible τ}) × (∀ x : A.Slot, {τ : B.Choices // (H.columnHoles x).Compatible τ})) : (concat A B).choiceWeight z (H.splitCompatibleChoices.symm τ).val= (∏ y, A.choiceWeight z (τ.1 y).val)*(∏ x, B.choiceWeight z (τ.2 x).val) := by rw [choiceWeight_split] have hr (y : B.Slot) : rowChoices A B (H.splitCompatibleChoices.symm τ).val y=(τ.1 y).val := by change (choicesSplit A B ((choicesSplit A B).symm _)).1 y=_ rw [Equiv.apply_symm_apply] have hc (x : A.Slot) : columnChoices A B (H.splitCompatibleChoices.symm τ).val x=(τ.2 x).val := by change (choicesSplit A B ((choicesSplit A B).symm _)).2 x=_ rw [Equiv.apply_symm_apply] simp_rw [hr,hc] /- Exact product of all child path-event probabilities, for the real law. -/ theorem probability_split (z : ℝ) : H.probability z=(∏ y, (H.rowHoles y).probability z)*(∏ x, (H.columnHoles x).probability z) := by classical let (y : B.Slot) : Fintype {τ : A.Choices // (H.rowHoles y).Compatible τ} := Subtype.fintype _ let (x : A.Slot) : Fintype {τ : B.Choices // (H.columnHoles x).Compatible τ} := Subtype.fintype _ unfold probability rw [← H.splitCompatibleChoices.symm.sum_comp] simp_rw [H.splitCompatibleChoices_weight] rw [Fintype.sum_prod_type] dsimp only rw [← Finset.sum_mul_sum] congr 1 · exact (Fintype.prod_sum (fun y (τ : {τ : A.Choices // (H.rowHoles y).Compatible τ}) => A.choiceWeight z τ.val)).symm · exact (Fintype.prod_sum (fun x (τ : {τ : B.Choices // (H.columnHoles x).Compatible τ}) => B.choiceWeight z τ.val)).symm /- Literal normalized conditional mass factors; no trajectory is reweighted. -/ theorem conditionalWeight_split (z : ℝ) (ω : {ω : (concat A B).Choices // H.Compatible ω}) : (concat A B).choiceWeight z ω.val/H.probability z= (∏ y, A.choiceWeight z (rowChoices A B ω.val y)/(H.rowHoles y).probability z)* (∏ x, B.choiceWeight z (columnChoices A B ω.val x)/(H.columnHoles x).probability z) := by rw [choiceWeight_split,H.probability_split] rw [Finset.prod_div_distrib,Finset.prod_div_distrib] exact mul_div_mul_comm _ _ _ _ end CoordinateSweeps.Grid.Holes namespace CoordinateSweeps.Marked variable {X Y I : Type*} abbrev Free (x : I → X) := {z : X // ∀ i, z ≠ x i} def freeEquiv (x : I → X) (y : I → Y) (e : X ≃ Y) (he : ∀ i, e (x i)=y i) : Free x ≃ Free y := e.subtypeEquiv (by intro z constructor · intro hz i hi apply hz i exact e.injective (hi.trans (he i).symm) · intro hz i hi apply hz i rw [hi,he]) lemma freeEquiv_apply (x : I → X) (y : I → Y) (e : X ≃ Y) (he : ∀ i, e (x i)=y i) (z : Free x) : (freeEquiv x y e he z).val=e z.val := rfl def fix (x : I → X) : Subgroup (Equiv.Perm X) where carrier g := ∀ i, g (x i)=x i one_mem' _ := rfl mul_mem' := by intro g h hg hh i change g (h (x i))=x i rw [hh i,hg i] inv_mem' hg i := (Equiv.symm_apply_eq _).mpr (hg i).symm def freePerm (x : I → X) : fix x →* Equiv.Perm (Free x) where toFun g := freeEquiv x x g.val g.property map_one' := by ext z; rfl map_mul' g h := by ext z; rfl /- The honest symmetric group on the unmarked sites, including empty sets. -/ def freePermEquiv (x : I → X) : fix x ≃* Equiv.Perm (Free x) where toFun := freePerm x invFun σ := ⟨Equiv.Perm.ofSubtype σ,by intro i apply Equiv.Perm.ofSubtype_apply_of_not_mem simp only [not_forall,not_not] exact ⟨i,rfl⟩⟩ left_inv g := by apply Subtype.ext ext z by_cases hz : ∀ i, z ≠ x i · rw [Equiv.Perm.ofSubtype_apply_of_mem _ hz] rfl · rw [Equiv.Perm.ofSubtype_apply_of_not_mem _ hz] push Not at hz rcases hz with ⟨i,rfl⟩ exact (g.property i).symm right_inv σ := by ext z change Equiv.Perm.ofSubtype σ z.val=(σ z).val exact Equiv.Perm.ofSubtype_apply_of_mem _ z.property map_mul' := (freePerm x).map_mul lemma card_free [Fintype X] [Fintype I] (x : I → X) (hx : Function.Injective x) : Fintype.card (Free x)=Fintype.card X-Fintype.card I := by classical let e : Free x ≃ {z : X // ¬ z ∈ Set.range x} := Equiv.subtypeEquivRight (fun z => by simp only [Set.mem_range,not_exists]; simp only [ne_eq,eq_comm]) rw [Fintype.card_congr e,Fintype.card_subtype_compl] congr 1 exact (Fintype.card_congr (Equiv.ofInjective x hx)).symm end CoordinateSweeps.Marked namespace CoordinateSweeps.Grid @[simp] theorem card_slot (G : Grid) : Fintype.card G.Slot=G.size := by simp [Slot,size,Cube,Fintype.card_pi] namespace Holes variable {G : Grid} {h : ℕ} abbrev FreeAt (H : G.Holes h) (t : Fin (G.b+1)) := Marked.Free (fun i => H.path i t) def freeBoundary (H : G.Holes h) (ω : {ω : G.Choices // H.Compatible ω}) (t : Fin (G.b+1)) : H.FreeAt 0 ≃ H.FreeAt t := Marked.freeEquiv _ _ (G.boundary ω.val t.val) (fun i => ω.property i t) lemma card_freeAt (H : G.Holes h) (t : Fin (G.b+1)) : Fintype.card (H.FreeAt t)=G.size-h := by have hh := Marked.card_free (fun i => H.path i t) (H.disjoint t) simp only [card_slot,Fintype.card_fin] at hh convert hh using 1 congr 1 exact Subsingleton.elim _ _ /- Literal target stabilizer isomorphism, not an assumed representation switch. -/ def stabilizerFreeEquiv (H : G.Holes h) : H.stabilizer ≃* Equiv.Perm (H.FreeAt 0) := Marked.freePermEquiv (fun i => H.path i 0) lemma stabilizerFreeEquiv_apply (H : G.Holes h) (g : H.stabilizer) (x : H.FreeAt 0) : (H.stabilizerFreeEquiv g x).val=g.val x.val := rfl end Holes end CoordinateSweeps.Grid namespace CoordinateSweeps.Grid def rowSweep (A B : Grid) (ω : B.Slot → A.Choices) : Equiv.Perm (concat A B).Slot := Equiv.permCongr (splitSlots A B).symm (fiberPerm (fun y => A.sweep (ω y))) def columnSweep (A B : Grid) (ω : A.Slot → B.Choices) : Equiv.Perm (concat A B).Slot := Equiv.permCongr ((splitSlots A B).trans (Equiv.prodComm _ _)).symm (fiberPerm (fun x => B.sweep (ω x))) lemma rowSweep_apply (A B : Grid) (ω : B.Slot → A.Choices) (x : (concat A B).Slot) : splitSlots A B (rowSweep A B ω x)= (A.sweep (ω (splitSlots A B x).2) (splitSlots A B x).1,(splitSlots A B x).2) := by unfold rowSweep simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply] rfl lemma columnSweep_apply (A B : Grid) (ω : A.Slot → B.Choices) (x : (concat A B).Slot) : splitSlots A B (columnSweep A B ω x)= ((splitSlots A B x).1,B.sweep (ω (splitSlots A B x).1) (splitSlots A B x).2) := by unfold columnSweep simp only [Equiv.permCongr_apply,Equiv.symm_trans_apply,Equiv.symm_symm,Equiv.trans_apply, Equiv.apply_symm_apply] rfl theorem sweep_eq_column_mul_row (A B : Grid) (ω : (concat A B).Choices) : (concat A B).sweep ω=columnSweep A B (columnChoices A B ω)*rowSweep A B (rowChoices A B ω) := by apply Equiv.ext intro x apply (splitSlots A B).injective have hr := rowSweep_apply A B (rowChoices A B ω) x have hc := columnSweep_apply A B (columnChoices A B ω) (rowSweep A B (rowChoices A B ω) x) have ht := congrArg (fun t : A.Slot × B.Slot => (t.1,B.sweep (columnChoices A B ω t.1) t.2)) hr exact (sweep_split A B ω x).trans (hc.trans ht).symm theorem rowSweep_eq_boundary (A B : Grid) (ω : (concat A B).Choices) : rowSweep A B (rowChoices A B ω)=(concat A B).boundary ω A.b := by apply Equiv.ext intro x apply (splitSlots A B).injective rw [rowSweep_apply,boundary_split_prefix A B ω x A.b le_rfl] rfl namespace Holes variable {A B : Grid} {h : ℕ} (H : (concat A B).Holes h) abbrev RowChoices := ∀ y : B.Slot, {τ : A.Choices // (H.rowHoles y).Compatible τ} abbrev ColumnChoices := ∀ x : A.Slot, {τ : B.Choices // (H.columnHoles x).Compatible τ} def refPair (hf : H.Feasible) : H.RowChoices × H.ColumnChoices := H.splitCompatibleChoices ⟨H.reference hf,H.reference_compatible hf⟩ def rowAction (τ : H.RowChoices) := rowSweep A B (fun y => (τ y).val) def columnAction (τ : H.ColumnChoices) := columnSweep A B (fun x => (τ x).val) lemma split_choice_sweep (τ : H.RowChoices × H.ColumnChoices) : (concat A B).sweep (H.splitCompatibleChoices.symm τ).val=H.columnAction τ.2*H.rowAction τ.1 := by rw [sweep_eq_column_mul_row] change columnSweep A B ((choicesSplit A B ((choicesSplit A B).symm _)).2)* rowSweep A B ((choicesSplit A B ((choicesSplit A B).symm _)).1)=_ rw [Equiv.apply_symm_apply] rfl lemma rowAction_marked (hf : H.Feasible) (τ : H.RowChoices) (i : Fin h) : H.rowAction τ (H.path i 0)=H.path i (suffixTime A B 0) := by let ω : {ω : (concat A B).Choices // H.Compatible ω} := H.splitCompatibleChoices.symm (τ,(H.refPair hf).2) have he : H.rowAction τ=rowSweep A B (rowChoices A B ω.val) := by change rowSweep A B (fun y => (τ y).val)=rowSweep A B (fun y => ((choicesSplit A B) ((choicesSplit A B).symm _)).1 y) rw [Equiv.apply_symm_apply] rw [he,rowSweep_eq_boundary] exact ω.property i (suffixTime A B 0) lemma columnAction_marked (hf : H.Feasible) (τ : H.ColumnChoices) (i : Fin h) : H.columnAction τ (H.path i (suffixTime A B 0))=H.path i (Fin.last _) := by let ω : {ω : (concat A B).Choices // H.Compatible ω} := H.splitCompatibleChoices.symm ((H.refPair hf).1,τ) have hs := H.split_choice_sweep ((H.refPair hf).1,τ) have hr := H.rowAction_marked hf (H.refPair hf).1 i have he := ω.property i (Fin.last _) change (concat A B).sweep ω.val (H.path i 0)=_ at he rw [hs] at he change H.columnAction τ (H.rowAction (H.refPair hf).1 (H.path i 0))=_ at he rwa [hr] at he abbrev JunctionFix := Marked.fix (fun i => H.path i (suffixTime A B 0)) def rowResidual (hf : H.Feasible) (τ : H.RowChoices) : H.JunctionFix := ⟨H.rowAction τ*(H.rowAction (H.refPair hf).1)⁻¹,by intro i change H.rowAction τ ((H.rowAction (H.refPair hf).1).symm (H.path i (suffixTime A B 0)))=_ rw [← H.rowAction_marked hf (H.refPair hf).1 i,Equiv.symm_apply_apply,H.rowAction_marked hf τ i]⟩ def columnResidual (hf : H.Feasible) (τ : H.ColumnChoices) : H.JunctionFix := ⟨(H.columnAction (H.refPair hf).2)⁻¹*H.columnAction τ,by intro i change (H.columnAction (H.refPair hf).2).symm (H.columnAction τ (H.path i (suffixTime A B 0)))=_ rw [H.columnAction_marked hf τ i,← H.columnAction_marked hf (H.refPair hf).2 i,Equiv.symm_apply_apply]⟩ end Holes end CoordinateSweeps.Grid namespace CoordinateSweeps.Grid.Holes variable {A B : Grid} {h : ℕ} (H : (concat A B).Holes h) /- Move the target's reference identification to the actual junction layer. -/ def junctionEquiv (hf : H.Feasible) : H.stabilizer ≃* H.JunctionFix where toFun g := ⟨H.rowAction (H.refPair hf).1*g.val*(H.rowAction (H.refPair hf).1)⁻¹,by intro i change H.rowAction (H.refPair hf).1 (g.val ((H.rowAction (H.refPair hf).1).symm (H.path i (suffixTime A B 0))))=_ rw [← H.rowAction_marked hf (H.refPair hf).1 i,Equiv.symm_apply_apply,g.property i] exact H.rowAction_marked hf (H.refPair hf).1 i⟩ invFun g := ⟨(H.rowAction (H.refPair hf).1)⁻¹*g.val*H.rowAction (H.refPair hf).1,by intro i change (H.rowAction (H.refPair hf).1).symm (g.val (H.rowAction (H.refPair hf).1 (H.path i 0)))=_ rw [H.rowAction_marked hf (H.refPair hf).1 i,g.property i] exact (Equiv.symm_apply_eq _).mpr (H.rowAction_marked hf (H.refPair hf).1 i).symm⟩ left_inv g := by apply Subtype.ext change (H.rowAction (H.refPair hf).1)⁻¹* (H.rowAction (H.refPair hf).1*g.val*(H.rowAction (H.refPair hf).1)⁻¹)*H.rowAction (H.refPair hf).1=g.val group right_inv g := by apply Subtype.ext change H.rowAction (H.refPair hf).1* ((H.rowAction (H.refPair hf).1)⁻¹*g.val*H.rowAction (H.refPair hf).1)*(H.rowAction (H.refPair hf).1)⁻¹=g.val group map_mul' g k := by apply Subtype.ext change H.rowAction (H.refPair hf).1*(g.val*k.val)*(H.rowAction (H.refPair hf).1)⁻¹= (H.rowAction (H.refPair hf).1*g.val*(H.rowAction (H.refPair hf).1)⁻¹)* (H.rowAction (H.refPair hf).1*k.val*(H.rowAction (H.refPair hf).1)⁻¹) group lemma sweep_refPair (hf : H.Feasible) : (concat A B).sweep (H.reference hf)=H.columnAction (H.refPair hf).2*H.rowAction (H.refPair hf).1 := by simpa only [refPair,Equiv.symm_apply_apply] using H.split_choice_sweep (H.refPair hf) lemma junction_residual (hf : H.Feasible) (ω : {ω : (concat A B).Choices // H.Compatible ω}) : H.junctionEquiv hf (H.residual hf ω)= H.columnResidual hf (H.splitCompatibleChoices ω).2*H.rowResidual hf (H.splitCompatibleChoices ω).1 := by apply Subtype.ext change H.rowAction (H.refPair hf).1*(((concat A B).sweep (H.reference hf))⁻¹* (concat A B).sweep ω.val)*(H.rowAction (H.refPair hf).1)⁻¹=_ have he : (concat A B).sweep ω.val=H.columnAction (H.splitCompatibleChoices ω).2* H.rowAction (H.splitCompatibleChoices ω).1 := by simpa only [Equiv.symm_apply_apply] using H.split_choice_sweep (H.splitCompatibleChoices ω) rw [H.sweep_refPair hf,he] change _=((H.columnAction (H.refPair hf).2)⁻¹*H.columnAction (H.splitCompatibleChoices ω).2)* (H.rowAction (H.splitCompatibleChoices ω).1*(H.rowAction (H.refPair hf).1)⁻¹) group instance rowChoicesFintype : Fintype H.RowChoices := by letI (y : B.Slot) : Fintype {ω : A.Choices // (H.rowHoles y).Compatible ω} := Subtype.fintype _ unfold RowChoices infer_instance instance columnChoicesFintype : Fintype H.ColumnChoices := by letI (x : A.Slot) : Fintype {ω : B.Choices // (H.columnHoles x).Compatible ω} := Subtype.fintype _ unfold ColumnChoices infer_instance /- Arbitrary matrix representations may be used: the equality is at the law level. -/ def rowAverage {n : Type*} [Fintype n] [DecidableEq n] (hf : H.Feasible) (z : ℝ) (τ : H.JunctionFix →* Matrix n n ℂ) : Matrix n n ℂ := ∑ ω : H.RowChoices, ((∏ y, A.choiceWeight z (ω y).val/(H.rowHoles y).probability z : ℝ) : ℂ) • τ (H.rowResidual hf ω) def columnAverage {n : Type*} [Fintype n] [DecidableEq n] (hf : H.Feasible) (z : ℝ) (τ : H.JunctionFix →* Matrix n n ℂ) : Matrix n n ℂ := ∑ ω : H.ColumnChoices, ((∏ x, B.choiceWeight z (ω x).val/(H.columnHoles x).probability z : ℝ) : ℂ) • τ (H.columnResidual hf ω) /- Exact factorization of the faithful conditional matrix average at the junction. -/ theorem junction_average_split {n : Type*} [Fintype n] [DecidableEq n] (hf : H.Feasible) (z : ℝ) (τ : H.JunctionFix →* Matrix n n ℂ) : (∑ ω : {ω : (concat A B).Choices // H.Compatible ω}, (((concat A B).choiceWeight z ω.val/H.probability z : ℝ) : ℂ) • τ (H.junctionEquiv hf (H.residual hf ω)))= H.columnAverage hf z τ*H.rowAverage hf z τ := by classical let (y : B.Slot) : Fintype {ω : A.Choices // (H.rowHoles y).Compatible ω} := Subtype.fintype _ let (x : A.Slot) : Fintype {ω : B.Choices // (H.columnHoles x).Compatible ω} := Subtype.fintype _ rw [← H.splitCompatibleChoices.symm.sum_comp] simp_rw [H.junction_residual,Equiv.apply_symm_apply,map_mul,H.conditionalWeight_split, Complex.ofReal_mul] unfold columnAverage rowAverage rw [Matrix.sum_mul] simp_rw [Matrix.mul_sum,Matrix.smul_mul,Matrix.mul_smul,smul_smul] rw [Fintype.sum_prod_type,Finset.sum_comm] apply Finset.sum_congr rfl intro c _ apply Finset.sum_congr rfl intro r _ have he := H.splitCompatibleChoices.apply_symm_apply (r,c) have hr : rowChoices A B (H.splitCompatibleChoices.symm (r,c)).val=fun y => (r y).val := by change ((choicesSplit A B) ((choicesSplit A B).symm _)).1=_ rw [Equiv.apply_symm_apply] have hc : columnChoices A B (H.splitCompatibleChoices.symm (r,c)).val=fun x => (c x).val := by change ((choicesSplit A B) ((choicesSplit A B).symm _)).2=_ rw [Equiv.apply_symm_apply] simp only [hr,hc] rw [mul_comm] end CoordinateSweeps.Grid.Holes namespace CoordinateSweeps namespace Grid.Holes variable {G : Grid} {h : ℕ} /- Average of the remaining random bijection, conditioned on the entire paths, not only endpoints. The reference affects only unitary identifications. -/ def conditionalAverage (H : G.Holes h) (hf : H.Feasible) (z : ℝ) (ρ : UnitaryIrrep H.stabilizer) : Matrix (Fin ρ.dimension) (Fin ρ.dimension) ℂ := (H.probability z : ℂ)⁻¹ • ∑ ω : {ω : G.Choices // H.Compatible ω}, (G.choiceWeight z ω.val : ℂ) • ρ.matrix (H.residual hf ω) theorem probability_pos (H : G.Holes h) (hf : H.Feasible) {z : ℝ} (hz : 0 ≤ z) (hz' : z < 1) : 0 < H.probability z := by let : Nonempty {ω : G.Choices // H.Compatible ω} := ⟨⟨H.reference hf, H.reference_compatible hf⟩⟩ apply Finset.sum_pos · intro ω _ exact G.choiceWeight_pos hz hz' ω.val · exact Finset.univ_nonempty theorem conditionalAverage_eq_sum (H : G.Holes h) (hf : H.Feasible) (z : ℝ) (ρ : UnitaryIrrep H.stabilizer) : H.conditionalAverage hf z ρ = ∑ ω : {ω : G.Choices // H.Compatible ω}, ((G.choiceWeight z ω.val / H.probability z : ℝ) : ℂ) • ρ.matrix (H.residual hf ω) := by simp only [conditionalAverage, Finset.smul_sum, smul_smul, div_eq_mul_inv, Complex.ofReal_mul, Complex.ofReal_inv, mul_comm] theorem conditionalAverage_norm_le (H : G.Holes h) (hf : H.Feasible) {z : ℝ} (hz : 0 ≤ z) (hz' : z < 1) (ρ : UnitaryIrrep H.stabilizer) : ‖H.conditionalAverage hf z ρ‖ ≤ 1 := by let : NeZero ρ.dimension := ⟨ρ.positive.ne'⟩ rw [H.conditionalAverage_eq_sum hf z ρ] apply unitary_average_norm_le · intro ω exact div_nonneg (G.choiceWeight_pos hz hz' ω.val).le (H.probability_pos hf hz hz').le · rw [← Finset.sum_div] exact div_self (H.probability_pos hf hz hz').ne' · intro ω exact ρ.unitary (H.residual hf ω) theorem conditionalMoment_nonneg (H : G.Holes h) (hf : H.Feasible) (z : ℝ) (ρ : UnitaryIrrep H.stabilizer) (q : ℕ) : 0 ≤ schattenMoment q (H.conditionalAverage hf z ρ) := trace_moment_nonneg _ _ theorem conditionalMoment_le_dimension (H : G.Holes h) (hf : H.Feasible) {z : ℝ} (hz : 0 ≤ z) (hz' : z < 1) (ρ : UnitaryIrrep H.stabilizer) (q : ℕ) : schattenMoment q (H.conditionalAverage hf z ρ) ≤ ρ.dimension := by let : NeZero ρ.dimension := ⟨ρ.positive.ne'⟩ apply (trace_moment_le _ q).trans have hn := H.conditionalAverage_norm_le hf hz hz' ρ have hp : ‖H.conditionalAverage hf z ρ‖^(2*q) ≤ 1 := pow_le_one₀ (norm_nonneg _) hn exact mul_le_of_le_one_right (Nat.cast_nonneg _) hp end Grid.Holes /- Source constants a=1/100, c0=e0=a/100. -/ def a : ℝ := 1 / 100 def c0 : ℝ := a / 100 def e0 : ℝ := a / 100 def c (s : ℕ) : ℝ := c0 + 1 / Real.sqrt (Real.log s) def e (s : ℕ) : ℝ := e0 - 1 / Real.sqrt (Real.log s) /- Natural logarithm with the manuscript's log zero = minus infinity. -/ def logMoment (t : ℝ) : EReal := if t = 0 then ⊥ else (Real.log t : EReal) /- Faithful conditional main target; R=2^r. The harmless strengthening z_*≤1/2 makes the probability-law range explicit. -/ def ConditionalMain : Prop := ∃ (r q : ℕ) (zStar : ℝ), 1 ≤ r ∧ 1 ≤ q ∧ 0 < zStar ∧ zStar ≤ 1 / ((2 : ℕ) : ℝ) ∧ ∀ (G : Grid), G.Allowed r → ∀ (h : ℕ) (H : G.Holes h) (hf : H.Feasible), ∀ z ∈ Set.Icc 0 zStar, ∀ ρ : UnitaryIrrep H.stabilizer, logMoment (schattenMoment q (H.conditionalAverage hf z ρ)) ≤ ((-c G.size * Real.log ρ.dimension + e G.size * h * Real.log G.size - H.cost : ℝ) : EReal) end CoordinateSweeps end end end end end end end end open scoped Matrix.Norms.L2Operator end OAI
import Mathlib
import OAI.Probability.CoordinateSweeps.Grid
import OAI.RepresentationTheory.Unitary.Basic
import OAI.Analysis.Matrix.TensorMoment
namespace OAI
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ComplexConjugate Matrix.Norms.L2Operator
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ComplexOrder MatrixOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ENNReal
open MeasureTheory
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
noncomputable section
open scoped BigOperators
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable
namespace CoordinateSweeps.Grid
/- Concatenation of the *ordered* coordinate sequences. -/
def concat (A B : Grid) : Grid where
b := A.b+B.b
positive := Nat.add_pos_left A.positive _
bits := Fin.addCases A.bits B.bits
@[simp] lemma concat_bits_left (A B : Grid) (i : Fin A.b) :
(concat A B).bits (Fin.castAdd B.b i)=A.bits i := by simp [concat]
@[simp] lemma concat_bits_right (A B : Grid) (i : Fin B.b) :
(concat A B).bits (Fin.natAdd A.b i)=B.bits i := by simp [concat]
/- Literal Cartesian identification for the split, retaining all bit labels. -/
def splitSlots (A B : Grid) : (concat A B).Slot ≃ A.Slot × B.Slot :=
((Equiv.prodPiEquivSumPi (fun i => Cube (A.bits i)) (fun j => Cube (B.bits j))).trans
(Equiv.piCongr finSumFinEquiv (fun i => by
cases i with
| inl i => exact Equiv.cast (by simp [concat])
| inr j => exact Equiv.cast (by simp [concat])))).symm
@[simp] lemma splitSlots_left (A B : Grid) (x : (concat A B).Slot) (i : Fin A.b) :
(splitSlots A B x).1 i = (Equiv.cast (by simp : Cube ((concat A B).bits (Fin.castAdd B.b i))=Cube (A.bits i)))
(x (Fin.castAdd B.b i)) := by
rfl
@[simp] lemma splitSlots_right (A B : Grid) (x : (concat A B).Slot) (j : Fin B.b) :
(splitSlots A B x).2 j = (Equiv.cast (by simp : Cube ((concat A B).bits (Fin.natAdd A.b j))=Cube (B.bits j)))
(x (Fin.natAdd A.b j)) := by
rfl
lemma concat_size (A B : Grid) : (concat A B).size=A.size*B.size := by
change (∏ j : Fin (A.b+B.b), 2^Fin.addCases A.bits B.bits j)=A.size*B.size
rw [Fin.prod_univ_add]
simp [size]
lemma concat_allowed (A B : Grid) (r : ℕ) :
(concat A B).Allowed r ↔ A.Allowed r ∧ B.Allowed r := by
constructor
· intro h
exact ⟨fun i => by simpa using h (Fin.castAdd B.b i),
fun i => by simpa using h (Fin.natAdd A.b i)⟩
· rintro ⟨hA,hB⟩ i
induction i using Fin.addCases with
| left i => simpa using hA i
| right i => simpa using hB i
end CoordinateSweeps.Grid
noncomputable section
attribute [local instance] Classical.propDecidable
namespace CoordinateSweeps
/- Deleting a head coordinate commutes with the literal Fin concatenation. -/
def finDeleteLeft {m n : ℕ} (i : Fin m) :
({j : Fin m // j ≠ i} ⊕ Fin n) ≃ {j : Fin (m+n) // j ≠ Fin.castAdd n i} where
toFun z := match z with
| Sum.inl j => ⟨Fin.castAdd n j.val,by simpa using j.property⟩
| Sum.inr j => ⟨Fin.natAdd m j,by intro h; have ht := congrArg Fin.val h; simp at ht; omega⟩
invFun z := Fin.addCases (motive := fun j : Fin (m+n) => j ≠ Fin.castAdd n i → ({j : Fin m // j ≠ i} ⊕ Fin n))
(fun j (h : Fin.castAdd n j ≠ Fin.castAdd n i) => Sum.inl ⟨j,by simpa using h⟩)
(fun j (_h : Fin.natAdd m j ≠ Fin.castAdd n i) => Sum.inr j) z.val z.property
left_inv z := by cases z <;> simp
right_inv z := by
rcases z with ⟨j,hj⟩
induction j using Fin.addCases with
| left j => simp
| right j => simp
@[simp] lemma finDeleteLeft_inl {m n : ℕ} (i : Fin m) (j : {j : Fin m // j ≠ i}) :
(finDeleteLeft (n := n) i (Sum.inl j)).val=Fin.castAdd n j.val := rfl
@[simp] lemma finDeleteLeft_inr {m n : ℕ} (i : Fin m) (j : Fin n) :
(finDeleteLeft (n := n) i (Sum.inr j)).val=Fin.natAdd m j := rfl