| import Mathlib |
| import OAI.Probability.Contingency.ConcreteKernel |
|
|
| namespace OAI |
|
|
| /-! Concrete Contexts. -/ |
|
|
| noncomputable section |
|
|
| open scoped BigOperators |
| open scoped BigOperators |
| namespace Contingency.PaddedGraph |
| variable {m n : ℕ} |
|
|
| def smallRank (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (s : SmallSlot U r c) : Fin (m*n) := |
| finProdFinEquiv s.val |
|
|
| theorem smallRank_injective (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) : |
| Function.Injective (smallRank U r c) := by |
| intro s t h |
| exact Subtype.ext (finProdFinEquiv.injective h) |
|
|
| |
|
|
| noncomputable def smallIndex (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) : |
| Fin (Fintype.card (SmallSlot U r c)) ≃ SmallSlot U r c := by |
| letI := LinearOrder.lift' (smallRank U r c) (smallRank_injective U r c) |
| exact (monoEquivOfFin (SmallSlot U r c) rfl).toEquiv |
|
|
| theorem smallRank_lt_iff (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (s t : SmallSlot U r c) : smallRank U r c s < smallRank U r c t ↔ Before s.val t.val := by |
| change s.val.2.val+n*s.val.1.val < t.val.2.val+n*t.val.1.val ↔ _ |
| have hs := s.val.2.isLt |
| have ht := t.val.2.isLt |
| unfold Before |
| constructor |
| · intro hh |
| by_cases hi : s.val.1 < t.val.1 |
| · exact Or.inl hi |
| · have hti : t.val.1 ≤ s.val.1 := le_of_not_gt hi |
| have he : s.val.1=t.val.1 := by |
| apply Fin.ext |
| by_contra hn |
| have hlt : t.val.1.val+1 ≤ s.val.1.val := by omega |
| have hm := Nat.mul_le_mul_left n hlt |
| simp only [Nat.mul_add,Nat.mul_one] at hm |
| omega |
| exact Or.inr ⟨he,by rw [he] at hh; omega⟩ |
| · rintro (hi | ⟨hi,hj⟩) |
| · have hm := Nat.mul_le_mul_left n (show s.val.1.val+1 ≤ t.val.1.val by omega) |
| simp only [Nat.mul_add,Nat.mul_one] at hm |
| omega |
| · rw [hi]; omega |
| |
| theorem smallIndex_lt (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (s t : Fin (Fintype.card (SmallSlot U r c))) : |
| Before (smallIndex U r c s).val (smallIndex U r c t).val ↔ s < t := by |
| let := LinearOrder.lift' (smallRank U r c) (smallRank_injective U r c) |
| rw [← smallRank_lt_iff] |
| exact @OrderIso.lt_iff_lt _ _ _ |
| (LinearOrder.lift' (smallRank U r c) (smallRank_injective U r c)).toPreorder |
| (monoEquivOfFin (SmallSlot U r c) rfl) s t |
|
|
| |
|
|
| noncomputable def contextCoordinates (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) : |
| SmallCoord U r c ≃ ((Fin k × Bool) ⊕ PairCoords Bool a) := |
| (((smallIndex U r c).symm.trans (finCongr h)).trans finSumFinEquiv.symm |>.prodCongr (Equiv.refl Bool)).trans |
| ((Equiv.sumProdDistrib (Fin k) (Fin (a+1)) Bool).trans |
| (Equiv.sumCongr (Equiv.refl _) (smallCoords a).symm)) |
|
|
| noncomputable def contextKernel (η : ℝ) (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) |
| (σ : Fin k → Fin (U+1)) (p : PairCoords Bool a → ℤ) : ℝ := |
| smallKernel η U L C r c ((Sum.elim (balanceProfile (fun _ => U) σ) p) ∘ |
| contextCoordinates U r c k a h) |
|
|
| theorem balanceProfile_box (U k : ℕ) (σ : Fin k → Fin (U+1)) : |
| InBox (fun _ => (U:ℤ)) (balanceProfile (fun _ => U) σ) := by |
| intro ⟨s,b⟩ |
| have hs := (σ s).isLt |
| cases b <;> dsimp [balanceProfile] <;> omega |
| |
| theorem balanceProfile_total (U k : ℕ) (σ : Fin k → Fin (U+1)) : |
| (∑ w, balanceProfile (fun _ => U) σ w) = (k:ℤ)*U := by |
| rw [Fintype.sum_prod_type] |
| simp [balanceProfile] |
|
|
| |
|
|
| theorem contextKernel_signature (η : ℝ) (hη : 0 < η) (hη1 : η < 1) |
| (U L C : ℕ) (hC : 2 ≤ C) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (σ : Fin k → Fin (U+1)) : |
| PositiveSlice (contextKernel η U L C r c k a h σ) (fun _ => (U:ℤ)) (((a+1:ℕ):ℤ)*U) ∧ |
| HasSignature (contextKernel η U L C r c k a h σ) (fun _ => (U:ℤ)) (((a+1:ℕ):ℤ)*U) := by |
| obtain ⟨hp,hs⟩ := smallKernel_signature η hη hη1 U L C hC r c |
| have hp' := hp.reindex (contextCoordinates U r c k a h) |
| have hs' := hs.reindex (contextCoordinates U r c k a h) |
| have hbox : (fun _ : SmallCoord U r c => (U:ℤ)) ∘ (contextCoordinates U r c k a h).symm = |
| Sum.elim (fun _ : Fin k × Bool => (U:ℤ)) (fun _ : PairCoords Bool a => (U:ℤ)) := by |
| funext w; cases w <;> rfl |
| rw [hbox] at hp' hs' |
| have hp'' := hp'.fixedContext _ (balanceProfile_box U k σ) |
| have hs'' := hs'.fixedContext _ (balanceProfile_box U k σ) |
| rw [balanceProfile_total,h] at hp'' hs'' |
| have he : ((k+(a+1):ℕ):ℤ)*U-(k:ℤ)*U = ((a+1:ℕ):ℤ)*U := by push_cast; ring |
| rw [he] at hp'' hs'' |
| exact ⟨hp'',hs''⟩ |
| |
| theorem contextKernel_continuous (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) |
| (σ : Fin k → Fin (U+1)) (p : PairCoords Bool a → ℤ) : |
| Continuous (fun η => contextKernel η U L C r c k a h σ p) := |
| smallKernel_continuous U L C r c _ |
|
|
| theorem contextKernel_nonneg (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) |
| (σ : Fin k → Fin (U+1)) (p : PairCoords Bool a → ℤ) : |
| 0 ≤ contextKernel 0 U L C r c k a h σ p := |
| smallKernel_nonneg 0 (by norm_num) U L C r c _ |
|
|
| theorem context_child_no_holes (U L C : ℕ) (hU : 2 ≤ U) (hC : 2 ≤ C) |
| (r : Fin m → ℕ) (c : Fin n → ℕ) (k a : ℕ) |
| (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (σ : Fin k → Fin (U+1)) |
| (u v j : ℕ) (huj : u ≤ j) (hjv : j ≤ v) (hv : v ≤ U) : |
| min (nodeMass U a (contextKernel 0 U L C r c k a h σ) u) |
| (nodeMass U a (contextKernel 0 U L C r c k a h σ) v) ≤ |
| nodeMass U a (contextKernel 0 U L C r c k a h σ) j := |
| nodeMass_min U hU a _ (contextKernel_continuous U L C r c k a h σ) |
| (fun η hη hη' => (contextKernel_signature η hη hη' U L C hC r c k a h σ).1) |
| (fun η hη hη' => (contextKernel_signature η hη hη' U L C hC r c k a h σ).2) |
| u v j huj hjv hv |
|
|
| end Contingency.PaddedGraph |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency |
| universe u |
|
|
| noncomputable def branchEquiv (C : ℕ) : (n : ℕ) → Branches C n ≃ (Fin n → Fin (C+1)) |
| | 0 => { toFun := fun _ i => Fin.elim0 i |
| invFun := fun _ => PUnit.unit |
| left_inv := fun x => by cases x; rfl |
| right_inv := fun x => by funext i; exact Fin.elim0 i } |
| | n+1 => ((Equiv.refl (Fin (C+1))).prodCongr (branchEquiv C n)).trans |
| (piHeadEquiv (fun _ : Fin (n+1) => Fin (C+1))).symm |
|
|
| theorem branchEquiv_value (C n : ℕ) (a : Branches C n) (s : Fin n) : |
| branchEquiv C n a s = branchValue C n a s := by |
| induction n with |
| | zero => exact Fin.elim0 s |
| | succ n ih => |
| refine Fin.cases ?_ (fun t => ?_) s |
| · rfl |
| · exact ih a.2 t |
|
|
| theorem allBalance_sum_leaf {ι : Type u} (C n : ℕ) |
| (f : (PairCoords ι n → ℤ) → ℝ) (p : ι → ℤ) : |
| allBalance C n f p = ∑ a : Branches C n, f (leafDisplay C n p a) := by |
| induction n generalizing ι with |
| | zero => simp [allBalance,leafDisplay] |
| | succ n ih => |
| change (∑ j ∈ Finset.range (C+1), allBalance C n f (pairAssembly p (j:ℤ) ((C:ℤ)-j))) = _ |
| rw [← Fin.sum_univ_eq_sum_range] |
| simp_rw [ih] |
| change _ = ∑ a : Fin (C+1) × Branches C n, f (leafDisplay C (n+1) p a) |
| rw [Fintype.sum_prod_type] |
| rfl |
|
|
| noncomputable def mixedDisplay {ι : Type u} (n : ℕ) (D : Fin n → ℕ) |
| (p : ι → ℤ) (a : ∀ s, Fin (D s+1)) : PairCoords ι n → ℤ := |
| Sum.elim p (balanceProfile D a) ∘ pairCoordsEquiv ι n |
|
|
| @[simp] theorem mixedDisplay_base {ι : Type u} (n : ℕ) (D : Fin n → ℕ) |
| (p : ι → ℤ) (a : ∀ s, Fin (D s+1)) (i : ι) : |
| mixedDisplay n D p a ((pairCoordsEquiv ι n).symm (.inl i)) = p i := by |
| simp [mixedDisplay] |
|
|
| @[simp] theorem mixedDisplay_slot {ι : Type u} (n : ℕ) (D : Fin n → ℕ) |
| (p : ι → ℤ) (a : ∀ s, Fin (D s+1)) (s : Fin n) (b : Bool) : |
| mixedDisplay n D p a ((pairCoordsEquiv ι n).symm (.inr (s,b))) = |
| if b then ((a s:ℕ):ℤ) else (D s:ℤ)-(a s:ℕ) := by |
| simp [mixedDisplay,balanceProfile] |
|
|
| theorem leafDisplay_mixed {ι : Type u} (C n : ℕ) (p : ι → ℤ) (a : Branches C n) : |
| leafDisplay C n p a = mixedDisplay n (fun _ => C) p (branchEquiv C n a) := by |
| funext i |
| obtain ⟨q,rfl⟩ := (pairCoordsEquiv ι n).symm.surjective i |
| rcases q with i | ⟨s,b⟩ |
| · rw [leafDisplay_base,mixedDisplay_base] |
| · rw [leafDisplay_slot,mixedDisplay_slot,branchEquiv_value] |
|
|
| theorem mixedDisplay_injective {ι : Type u} (n : ℕ) (D : Fin n → ℕ) (p : ι → ℤ) : |
| Function.Injective (mixedDisplay n D p) := by |
| intro a b hab |
| funext s |
| have hh := congrFun hab ((pairCoordsEquiv ι n).symm (.inr (s,true))) |
| simp only [mixedDisplay_slot,ite_true] at hh |
| apply Fin.ext |
| exact_mod_cast hh |
|
|
| theorem leafDisplay_injective {ι : Type u} (C n : ℕ) (p : ι → ℤ) : |
| Function.Injective (leafDisplay C n p) := by |
| intro a b hab |
| simp only [leafDisplay_mixed] at hab |
| exact (branchEquiv C n).injective (mixedDisplay_injective n _ p hab) |
|
|
| noncomputable def mixedBalance {ι : Type u} (n : ℕ) (D : Fin n → ℕ) |
| (f : (PairCoords ι n → ℤ) → ℝ) (p : ι → ℤ) : ℝ := |
| ∑ a : ∀ s, Fin (D s+1), f (mixedDisplay n D p a) |
|
|
| theorem allBalance_mixed {ι : Type u} (C n : ℕ) |
| (f : (PairCoords ι n → ℤ) → ℝ) (p : ι → ℤ) : |
| allBalance C n f p = mixedBalance n (fun _ => C) f p := by |
| rw [allBalance_sum_leaf] |
| simp only [leafDisplay_mixed,mixedBalance] |
| exact Equiv.sum_comp (branchEquiv C n) (fun a => f (mixedDisplay n (fun _ => C) p a)) |
|
|
| |
|
|
| theorem mixedDisplay_succ {ι : Type u} (n : ℕ) (D : Fin (n+1) → ℕ) |
| (p : ι → ℤ) (a : ∀ s, Fin (D s+1)) : |
| mixedDisplay (n+1) D p a = mixedDisplay n (fun s => D s.succ) |
| (pairAssembly p (a 0:ℕ) ((D 0:ℤ)-(a 0:ℕ))) (fun s => a s.succ) := by |
| funext i |
| obtain ⟨q,rfl⟩ := (pairCoordsEquiv (ι ⊕ Bool) n).symm.surjective i |
| rcases q with (i | b) | ⟨s,b⟩ <;> |
| simp only [mixedDisplay, Function.comp_apply, pairCoordsEquiv, Equiv.trans_apply, |
| Equiv.apply_symm_apply, joinPairHead, Equiv.coe_fn_mk, balanceProfile, pairAssembly, |
| Sum.elim_inl, Sum.elim_inr] |
| |
| theorem mixedBalance_succ {ι : Type u} (n : ℕ) (D : Fin (n+1) → ℕ) |
| (f : (PairCoords ι (n+1) → ℤ) → ℝ) (p : ι → ℤ) : |
| mixedBalance (n+1) D f p = ∑ j : Fin (D 0+1), |
| mixedBalance n (fun s => D s.succ) f (pairAssembly p (j:ℕ) ((D 0:ℤ)-(j:ℕ))) := by |
| unfold mixedBalance |
| rw [← Equiv.sum_comp (piHeadEquiv (fun s => Fin (D s+1))).symm] |
| rw [Fintype.sum_prod_type] |
| apply Finset.sum_congr rfl; intro j hj |
| apply Finset.sum_congr rfl; intro a ha |
| congr 1 |
| rw [mixedDisplay_succ] |
| rfl |
| |
| noncomputable def surplusCaps (C n : ℕ) (t : Fin n) (s : Fin n) : ℕ := |
| if s=t then C+1 else C |
|
|
| |
|
|
| theorem allSurplus_sum_types {ι : Type u} (C n : ℕ) |
| (f : (PairCoords ι n → ℤ) → ℝ) (p : ι → ℤ) : |
| allSurplus C n f p = ∑ t : Fin n, mixedBalance n (surplusCaps C n t) f p := by |
| induction n generalizing ι with |
| | zero => simp [allSurplus] |
| | succ n ih => |
| rw [Fin.sum_univ_succ] |
| change balancedMarginal (allBalance C n f) (C+1) p + |
| balancedMarginal (allSurplus C n f) C p = _ |
| congr 1 |
| · rw [mixedBalance_succ] |
| simp only [surplusCaps,ite_eq_left,Fin.succ_ne_zero,ite_false] |
| unfold balancedMarginal |
| rw [← Fin.sum_univ_eq_sum_range] |
| apply Finset.sum_congr rfl; intro j hj |
| exact allBalance_mixed C n f _ |
| · have hs (t : Fin n) : mixedBalance (n+1) (surplusCaps C (n+1) t.succ) f p = |
| ∑ j : Fin (C+1), mixedBalance n (surplusCaps C n t) f |
| (pairAssembly p (j:ℕ) ((C:ℤ)-(j:ℕ))) := by |
| have he : surplusCaps C (n+1) t.succ = Fin.cases C (surplusCaps C n t) := by |
| funext s |
| refine Fin.cases ?_ (fun v => ?_) s |
| · simp [surplusCaps,Ne.symm (Fin.succ_ne_zero t)] |
| · simp [surplusCaps] |
| rw [he,mixedBalance_succ] |
| rfl |
| simp_rw [hs] |
| rw [Finset.sum_comm] |
| unfold balancedMarginal |
| rw [← Fin.sum_univ_eq_sum_range] |
| apply Finset.sum_congr rfl; intro j hj |
| exact ih f _ |
| |
| end Contingency |
| |
| |
| |
| |
| |
| open scoped BigOperators |
| namespace Contingency.PaddedGraph |
| variable {m n : ℕ} |
|
|
| noncomputable def splitSlots (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) : |
| SmallSlot U r c ≃ (Fin k ⊕ Fin (a+1)) := |
| ((smallIndex U r c).symm.trans (finCongr h)).trans finSumFinEquiv.symm |
|
|
| noncomputable def prefixSlot (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (s : Fin k) := |
| (splitSlots U r c k a h).symm (.inl s) |
|
|
| noncomputable def suffixSlot (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (s : Fin (a+1)) := |
| (splitSlots U r c k a h).symm (.inr s) |
|
|
| @[simp] theorem contextCoordinates_prefix (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (s : Fin k) (b : Bool) : |
| contextCoordinates U r c k a h (prefixSlot U r c k a h s,b) = .inl (s,b) := by |
| change ((Equiv.sumCongr (Equiv.refl _) (smallCoords a).symm) |
| ((Equiv.sumProdDistrib (Fin k) (Fin (a+1)) Bool) |
| (splitSlots U r c k a h ((splitSlots U r c k a h).symm (.inl s)),b))) = _ |
| rw [Equiv.apply_symm_apply]; rfl |
| |
| @[simp] theorem contextCoordinates_suffix (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (s : Fin (a+1)) (b : Bool) : |
| contextCoordinates U r c k a h (suffixSlot U r c k a h s,b) = |
| .inr ((smallCoords a).symm (s,b)) := by |
| change ((Equiv.sumCongr (Equiv.refl _) (smallCoords a).symm) |
| ((Equiv.sumProdDistrib (Fin k) (Fin (a+1)) Bool) |
| (splitSlots U r c k a h ((splitSlots U r c k a h).symm (.inr s)),b))) = _ |
| rw [Equiv.apply_symm_apply]; rfl |
| |
| theorem prefix_before_suffix (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (s : Fin k) (t : Fin (a+1)) : |
| Before (prefixSlot U r c k a h s).val (suffixSlot U r c k a h t).val := by |
| apply (smallIndex_lt U r c _ _).2 |
| change ((finCongr h).symm (finSumFinEquiv (.inl s))) < |
| ((finCongr h).symm (finSumFinEquiv (.inr t))) |
| change s.val < k+t.val |
| omega |
|
|
| theorem suffix_before (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (s t : Fin (a+1)) (hst : s<t) : |
| Before (suffixSlot U r c k a h s).val (suffixSlot U r c k a h t).val := by |
| apply (smallIndex_lt U r c _ _).2 |
| change k+s.val < k+t.val |
| exact Nat.add_lt_add_left hst k |
|
|
| theorem slot_cases (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (w : SmallSlot U r c) : |
| (∃ s, w=prefixSlot U r c k a h s) ∨ (∃ s, w=suffixSlot U r c k a h s) := by |
| obtain ⟨v,rfl⟩ := (splitSlots U r c k a h).symm.surjective w |
| cases v with |
| | inl s => exact Or.inl ⟨s,rfl⟩ |
| | inr s => exact Or.inr ⟨s,rfl⟩ |
|
|
| noncomputable def contextState (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (σ : Fin k → Fin (U+1)) |
| (p : PairCoords Bool a → ℤ) : State m n := |
| coordinatesState U r c (Sum.elim (balanceProfile (fun _ => U) σ) p ∘ contextCoordinates U r c k a h) |
|
|
| @[simp] theorem contextState_prefix (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (σ : Fin k → Fin (U+1)) |
| (p : PairCoords Bool a → ℤ) (s : Fin k) : |
| (contextState U r c k a h σ p).x (prefixSlot U r c k a h s).val = (σ s:ℕ) ∧ |
| (contextState U r c k a h σ p).q (prefixSlot U r c k a h s).val = (σ s:ℕ) := by |
| simp [contextState,balanceProfile] |
|
|
| @[simp] theorem contextState_suffix (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (σ : Fin k → Fin (U+1)) |
| (p : PairCoords Bool a → ℤ) (s : Fin (a+1)) : |
| (contextState U r c k a h σ p).x (suffixSlot U r c k a h s).val = p ((smallCoords a).symm (s,true)) ∧ |
| (contextState U r c k a h σ p).q (suffixSlot U r c k a h s).val = U-p ((smallCoords a).symm (s,false)) := by |
| simp [contextState] |
|
|
| theorem contextState_supported (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (σ : Fin k → Fin (U+1)) |
| (p : PairCoords Bool a → ℤ) (w : Cell m n) (hw : IsLarge U r c w) : |
| (contextState U r c k a h σ p).x w=0 ∧ (contextState U r c k a h σ p).q w=0 := |
| coordinatesState_supported U r c _ w hw |
|
|
| theorem contextState_injective (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (σ : Fin k → Fin (U+1)) : |
| Function.Injective (contextState U r c k a h σ) := by |
| intro p q hpq |
| have he := congrArg (stateCoordinates U r c) hpq |
| dsimp [contextState] at he |
| simp only [stateCoordinates_coordinatesState] at he |
| funext i |
| have hh := congrFun he ((contextCoordinates U r c k a h).symm (.inr i)) |
| simpa using hh |
|
|
| theorem contextKernel_weight (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (hrc : (∑ i, r i)=∑ j, c j) (hC : ∀ i, paddedRow U L r c i ≤ C) |
| (k a : ℕ) (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (σ : Fin k → Fin (U+1)) |
| (p : PairCoords Bool a → ℤ) : |
| contextKernel 0 U L C r c k a h σ p = (weight U L r c (contextState U r c k a h σ p):ℝ) := by |
| classical |
| let X := contextState U r c k a h σ p |
| by_cases hx : Feasible U r c X |
| · rw [weight,ite_eq_left hx] |
| have he := smallKernel_zero_count U L C r c hrc X hx hC |
| simpa only [X,contextState,stateCoordinates_coordinatesState,contextKernel] using he |
| · rw [weight,ite_eq_right hx,Nat.cast_zero] |
| exact smallKernel_zero_infeasible U L C r c _ hx |
|
|
| end Contingency.PaddedGraph |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency.PaddedGraph |
| variable {m n : ℕ} |
|
|
| @[ext] theorem State.ext {X Y : State m n} (hx : X.x=Y.x) (hq : X.q=Y.q) : X=Y := by |
| cases X; cases Y; simp_all |
| |
| variable (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (k a : ℕ) |
| (h : Fintype.card (SmallSlot U r c)=k+(a+1)) (σ : Fin k → Fin (U+1)) |
|
|
| @[simp] theorem suffixSlot_val_inj (s t : Fin (a+1)) : |
| (suffixSlot U r c k a h s).val=(suffixSlot U r c k a h t).val ↔ s=t := by |
| constructor |
| · intro he |
| have he' := Subtype.ext he |
| exact Sum.inr.inj ((splitSlots U r c k a h).symm.injective he') |
| · rintro rfl; rfl |
| |
| @[simp] theorem prefix_suffix_ne (s : Fin k) (t : Fin (a+1)) : |
| (prefixSlot U r c k a h s).val ≠ (suffixSlot U r c k a h t).val := by |
| intro he |
| have he' := Subtype.ext he |
| have hh := (splitSlots U r c k a h).symm.injective he' |
| cases hh |
|
|
| @[simp] theorem mixedDisplay_current (D : Fin a → ℕ) (p : Bool → ℤ) |
| (α : ∀ s, Fin (D s+1)) (b : Bool) : |
| mixedDisplay a D p α ((smallCoords a).symm (0,b)) = p b := by |
| exact mixedDisplay_base a D p α b |
|
|
| @[simp] theorem mixedDisplay_ordinary (D : Fin a → ℕ) (p : Bool → ℤ) |
| (α : ∀ s, Fin (D s+1)) (s : Fin a) (b : Bool) : |
| mixedDisplay a D p α ((smallCoords a).symm (s.succ,b)) = |
| if b then ((α s:ℕ):ℤ) else (D s:ℤ)-(α s:ℕ) := by |
| exact mixedDisplay_slot a D p α s b |
|
|
| |
|
|
| def defectProfile (j : ℕ) : Bool → ℤ := fun b => if b then (j:ℤ) else (U:ℤ)-j-1 |
|
|
| @[simp] theorem adjacent_removePair (j : ℕ) : |
| removePair (adjacentDisplay U j) true false = defectProfile U j := by |
| funext b; cases b <;> simp [removePair,adjacentDisplay,defectProfile] |
| |
| noncomputable def defectState (j : ℕ) (t : Fin a) (α : ∀ v, Fin (surplusCaps U a t v+1)) : State m n := |
| contextState U r c k a h σ (mixedDisplay a (surplusCaps U a t) (defectProfile U j) α) |
|
|
| @[simp] theorem defectState_current (j : ℕ) (t : Fin a) (α : ∀ v, Fin (surplusCaps U a t v+1)) : |
| (defectState U r c k a h σ j t α).x (suffixSlot U r c k a h 0).val = j ∧ |
| (defectState U r c k a h σ j t α).q (suffixSlot U r c k a h 0).val = (j:ℤ)+1 := by |
| have hh := contextState_suffix U r c k a h σ (mixedDisplay a (surplusCaps U a t) (defectProfile U j) α) 0 |
| refine ⟨hh.1.trans ?_,hh.2.trans ?_⟩ |
| · simp only [mixedDisplay_current,defectProfile,ite_true] |
| · simp only [mixedDisplay_current,defectProfile,Bool.false_eq_true,ite_false] |
| ring |
|
|
| @[simp] theorem defectState_ordinary (j : ℕ) (t v : Fin a) (α : ∀ v, Fin (surplusCaps U a t v+1)) : |
| (defectState U r c k a h σ j t α).x (suffixSlot U r c k a h v.succ).val = (α v:ℕ) ∧ |
| (defectState U r c k a h σ j t α).q (suffixSlot U r c k a h v.succ).val = |
| (α v:ℕ)-(if v=t then (1:ℤ) else 0) := by |
| have hh := contextState_suffix U r c k a h σ (mixedDisplay a (surplusCaps U a t) (defectProfile U j) α) v.succ |
| simp only [mixedDisplay_ordinary,Bool.false_eq_true,ite_true,ite_false] at hh |
| refine ⟨hh.1,hh.2.trans ?_⟩ |
| unfold surplusCaps |
| split_ifs <;> push_cast <;> ring |
| |
| theorem defectState_defect (j : ℕ) (t : Fin a) (α : ∀ v, Fin (surplusCaps U a t v+1)) : |
| DefectAt U r c (suffixSlot U r c k a h 0).val (suffixSlot U r c k a h t.succ).val |
| (defectState U r c k a h σ j t α) := by |
| refine ⟨(suffixSlot U r c k a h 0).property,(suffixSlot U r c k a h t.succ).property,?_,?_⟩ |
| · rw [ne_eq,suffixSlot_val_inj] |
| exact Ne.symm (Fin.succ_ne_zero t) |
| · funext w |
| by_cases hw : IsSmall U r c w |
| · rcases slot_cases U r c k a h ⟨w,hw⟩ with ⟨v,hv⟩ | ⟨v,hv⟩ |
| · have he : w=(prefixSlot U r c k a h v).val := congrArg Subtype.val hv |
| subst w |
| have hp := contextState_prefix U r c k a h σ |
| (mixedDisplay a (surplusCaps U a t) (defectProfile U j) α) v |
| dsimp [defectState] at * |
| rw [hp.1,hp.2] |
| simp [unit] |
| · have he : w=(suffixSlot U r c k a h v).val := congrArg Subtype.val hv |
| subst w |
| refine Fin.cases ?_ (fun v => ?_) v |
| · rw [(defectState_current U r c k a h σ j t α).1, |
| (defectState_current U r c k a h σ j t α).2] |
| simp [unit,Ne.symm (Fin.succ_ne_zero t)] |
| · rw [(defectState_ordinary U r c k a h σ j t v α).1, |
| (defectState_ordinary U r c k a h σ j t v α).2] |
| simp [unit] |
| · have hl : IsLarge U r c w := Classical.not_not.mp hw |
| have hh := contextState_supported U r c k a h σ |
| (mixedDisplay a (surplusCaps U a t) (defectProfile U j) α) w hl |
| have hs : w ≠ (suffixSlot U r c k a h 0).val := by |
| rintro rfl; exact (suffixSlot U r c k a h 0).property hl |
| have ht : w ≠ (suffixSlot U r c k a h t.succ).val := by |
| rintro rfl; exact (suffixSlot U r c k a h t.succ).property hl |
| change _ = _-unit _ _+unit _ _ |
| simp only [defectState] at * |
| rw [hh.1,hh.2]; simp [unit,hs,ht] |
| |
| noncomputable def stateSuffix (X : State m n) (hf : Feasible U r c X) : Fin a → Fin (U+1) := |
| fun v => ⟨(X.x (suffixSlot U r c k a h v.succ).val).toNat,by |
| have hh := hf.1 (suffixSlot U r c k a h v.succ).val; omega⟩ |
| |
| |
| |
| theorem contextState_reconstruct (X : State m n) (hf : Feasible U r c X) |
| (htr : Transversal X) (hp : ∀ v, X.x (prefixSlot U r c k a h v).val=(σ v:ℕ)) |
| (j : ℕ) (hj : X.x (suffixSlot U r c k a h 0).val=(j:ℤ)) : |
| contextState U r c k a h σ (mixedDisplay a (fun _ => U) (childProfile U j) |
| (stateSuffix U r c k a h X hf)) = X := by |
| apply State.ext |
| · funext w |
| by_cases hw : IsSmall U r c w |
| · rcases slot_cases U r c k a h ⟨w,hw⟩ with ⟨v,hv⟩ | ⟨v,hv⟩ |
| · have he : w=(prefixSlot U r c k a h v).val := congrArg Subtype.val hv |
| subst w |
| rw [(contextState_prefix U r c k a h σ _ v).1,hp] |
| · have he : w=(suffixSlot U r c k a h v).val := congrArg Subtype.val hv |
| subst w |
| rw [(contextState_suffix U r c k a h σ _ v).1] |
| refine Fin.cases ?_ (fun t => ?_) v |
| · simpa [childProfile] using hj.symm |
| · simp only [mixedDisplay_ordinary,ite_true,stateSuffix] |
| exact Int.toNat_of_nonneg (hf.1 _).1 |
| · exact (contextState_supported U r c k a h σ _ w (Classical.not_not.mp hw)).1.trans |
| ((hf.2.1 w (Classical.not_not.mp hw)).1.symm) |
| · funext w |
| by_cases hw : IsSmall U r c w |
| · rcases slot_cases U r c k a h ⟨w,hw⟩ with ⟨v,hv⟩ | ⟨v,hv⟩ |
| · have he : w=(prefixSlot U r c k a h v).val := congrArg Subtype.val hv |
| subst w |
| rw [(contextState_prefix U r c k a h σ _ v).2,htr,hp] |
| · have he : w=(suffixSlot U r c k a h v).val := congrArg Subtype.val hv |
| subst w |
| rw [(contextState_suffix U r c k a h σ _ v).2,htr] |
| refine Fin.cases ?_ (fun t => ?_) v |
| · simp [childProfile,hj] |
| · simp only [mixedDisplay_ordinary,Bool.false_eq_true,ite_false,stateSuffix] |
| rw [Int.toNat_of_nonneg (hf.1 _).1]; ring |
| · exact (contextState_supported U r c k a h σ _ w (Classical.not_not.mp hw)).2.trans |
| ((hf.2.1 w (Classical.not_not.mp hw)).2.symm) |
| |
| end Contingency.PaddedGraph |
| |
| end |
| |
| end OAI |
| |
