File size: 6,846 Bytes
d5b7741 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | import OAI.Combinatorics.ContingencyTables.Transport.BalancedEnumeration
import Mathlib.Logic.Equiv.Fin.Basic
namespace OAI
/-!
# Physical indexing of all balanced large-cell pairs
The recursively added pairs are identified with the actual finite cells,
and their assignments with the dependent product of the physical finite
intervals. No extra coordinate or assignment multiplicity is introduced.
-/
namespace ContingencyTables.LargePairEnumeration
open scoped BigOperators Classical
open BalancedFamily BalancedEnumeration IntegerMarginal
universe u
/-- Widths in the explicit order supplied by a finite cell enumeration. -/
def widths : {n : ℕ} → (Fin n → ℕ) → List ℕ
| 0,_ => []
| _+1,M => M 0::widths (fun i => M i.succ)
lemma widths_lower {n : ℕ} (M : Fin n → ℕ) (h : ∀ i, 2≤M i) :
∀ w ∈ widths M, 2≤w := by
induction n with
| zero => intro w hw; exact False.elim (List.not_mem_nil hw)
| succ n ih =>
intro w hw
simp only [widths,List.mem_cons] at hw
rcases hw with rfl|hw
· exact h 0
· exact ih (fun i => M i.succ) (fun i => h i.succ) w hw
private def pairSuccEquiv (n : ℕ) : ((Fin n×Bool)⊕Bool) ≃ Fin (n+1)×Bool where
toFun
| .inl (i,b) => (i.succ,b)
| .inr b => (0,b)
invFun p := Fin.cases (.inr p.2) (fun i => .inl (i,p.2)) p.1
left_inv p := by cases p with
| inl p => rcases p with ⟨i,b⟩; rfl
| inr b => rfl
right_inv p := by
rcases p with ⟨i,b⟩
refine Fin.cases ?_ (fun j => ?_) i <;> rfl
/-- The nested coordinate sums contain exactly the retained coordinates
and one doubled coordinate for each physical large cell. -/
def coordinateEquiv (S : Type u) : {n : ℕ} → (M : Fin n → ℕ) →
Coordinates S (widths M) ≃ S⊕(Fin n×Bool)
| 0,_ => (Equiv.sumEmpty S (Fin 0×Bool)).symm
| n+1,M =>
(Equiv.sumCongr (coordinateEquiv S (fun i => M i.succ)) (Equiv.refl Bool)).trans
((Equiv.sumAssoc S (Fin n×Bool) Bool).trans
(Equiv.sumCongr (Equiv.refl S) (pairSuccEquiv n)))
/-- Balanced choices are the dependent product of the actual intervals. -/
def assignmentEquiv : {n : ℕ} → (M : Fin n → ℕ) →
Assignments (widths M) ≃ ((i : Fin n) → Fin (M i+1))
| 0,_ =>
{ toFun := fun _ i => Fin.elim0 i
invFun := fun _ => PUnit.unit
left_inv := by intro a; cases a; rfl
right_inv := by intro a; funext i; exact Fin.elim0 i }
| n+1,M =>
{ toFun := fun a => Fin.cases a.2 (assignmentEquiv (fun i => M i.succ) a.1)
invFun := fun a => ((assignmentEquiv (fun i => M i.succ)).symm (fun i => a i.succ),a 0)
left_inv := by intro a; simp only [Fin.cases_zero,Fin.cases_succ,Equiv.symm_apply_apply]; exact Prod.eta a
right_inv := by
intro a
funext i
refine Fin.cases ?_ (fun j => ?_) i
· rfl
· exact congrFun ((assignmentEquiv (fun i => M i.succ)).apply_symm_apply
(fun i => a i.succ)) j }
def joinedProfile {S : Type*} {n : ℕ} (M : Fin n → ℕ) (z : S → ℕ)
(a : (i : Fin n) → Fin (M i+1)) : S⊕(Fin n×Bool) → ℕ
| .inl s => z s
| .inr (i,b) => if b then M i-(a i).val else (a i).val
lemma embedding_coordinate {S : Type*} {n : ℕ} (M : Fin n → ℕ) (z : S → ℕ)
(a : (i : Fin n) → Fin (M i+1)) (c : Coordinates S (widths M)) :
embedding (widths M) z ((assignmentEquiv M).symm a) c=
joinedProfile M z a (coordinateEquiv S M c) := by
induction n with
| zero => rfl
| succ n ih =>
cases c with
| inl c =>
change embedding (widths (fun i => M i.succ)) z
((assignmentEquiv (fun i => M i.succ)).symm (fun i => a i.succ)) c=_
rw [ih]
change joinedProfile (fun i => M i.succ) z (fun i => a i.succ)
(coordinateEquiv S (fun i => M i.succ) c)=
joinedProfile M z a (((Equiv.sumAssoc S (Fin n×Bool) Bool).trans
(Equiv.sumCongr (Equiv.refl S) (pairSuccEquiv n)))
(.inl (coordinateEquiv S (fun i => M i.succ) c)))
generalize hc : coordinateEquiv S (fun i => M i.succ) c=q
cases q with
| inl s => rfl
| inr p => rcases p with ⟨i,b⟩; rfl
| inr b => cases b <;> rfl
/-- The recursively proved marginal is the direct finite sum over the
actual physical intervals. -/
theorem eliminate_eq_physical_sum {S : Type*} {n : ℕ} (M : Fin n → ℕ)
(F : (S⊕(Fin n×Bool) → ℕ) → ℝ) (z : S → ℕ) :
eliminate (widths M) (fun q => F (q ∘ (coordinateEquiv S M).symm)) z=
∑ a : ((i : Fin n) → Fin (M i+1)), F (joinedProfile M z a) := by
rw [eliminate_eq_sum]
apply Fintype.sum_equiv (assignmentEquiv M)
intro a
congr 1
funext c
have h := embedding_coordinate M z ((assignmentEquiv M) a) ((coordinateEquiv S M).symm c)
simpa only [Equiv.symm_apply_apply,Equiv.apply_symm_apply,Function.comp_apply] using h
variable {C : Type*}
@[reducible] def SmallView (small : C → Bool) := {c : C // small c=true}×Bool
@[reducible] def LargeCell (small : C → Bool) := {c : C // small c=false}
/-- This is the actual partition of doubled cells into small views and
large pairs. -/
noncomputable def partitionEquiv (small : C → Bool) :
SmallView small⊕(LargeCell small×Bool) ≃ C×Bool where
toFun
| .inl p => (p.1.val,p.2)
| .inr p => (p.1.val,p.2)
invFun p := if h : small p.1=true then .inl (⟨p.1,h⟩,p.2)
else .inr (⟨p.1,Bool.eq_false_iff.mpr h⟩,p.2)
left_inv p := by
cases p with
| inl p => simp only [p.1.property,dite_eq_left]
| inr p => simp only [p.1.property,Bool.false_eq_true,dite_false]
right_inv p := by
dsimp only
split_ifs <;> rfl
noncomputable def physicalJoinEquiv (small : C → Bool) {n : ℕ}
(e : Fin n ≃ LargeCell small) : SmallView small⊕(Fin n×Bool) ≃ C×Bool :=
(Equiv.sumCongr (Equiv.refl _) (Equiv.prodCongr e (Equiv.refl Bool))).trans
(partitionEquiv small)
/-- Every finite enumeration of the large cells gives the same physical
coordinate space, with each original doubled cell appearing once. -/
noncomputable def physicalCoordinateEquiv (small : C → Bool) {n : ℕ}
(e : Fin n ≃ LargeCell small) (M : Fin n → ℕ) :
Coordinates (SmallView small) (widths M) ≃ C×Bool :=
(coordinateEquiv (SmallView small) M).trans (physicalJoinEquiv small e)
theorem eliminate_eq_actual_cells (small : C → Bool) {n : ℕ}
(e : Fin n ≃ LargeCell small) (M : Fin n → ℕ)
(F : (C×Bool → ℕ) → ℝ) (z : SmallView small → ℕ) :
eliminate (widths M) (fun q => F (q ∘ (physicalCoordinateEquiv small e M).symm)) z=
∑ a : ((i : Fin n) → Fin (M i+1)),
F (joinedProfile M z a ∘ (physicalJoinEquiv small e).symm) := by
exact eliminate_eq_physical_sum M (fun q => F (q ∘ (physicalJoinEquiv small e).symm)) z
end ContingencyTables.LargePairEnumeration
end OAI
|