| import OAI.Combinatorics.BalancedRyser.Local.GlobalAlignedParentCoordinates |
|
|
| namespace OAI |
|
|
| namespace Balanced.Local.AlignedGlobal |
|
|
| open RootChildPartition AlignedUnused |
|
|
| noncomputable section |
| attribute [local instance] Classical.propDecidable |
|
|
| variable {F : Type*} [Field F] [Fintype F] [DecidableEq F] |
|
|
| theorem PointSystem.generated_points {b κ : ℕ} {P : EqualityPattern b κ} |
| {a : DirectionAssignment F b κ} {bits : Bits b} {p : Point F} |
| {R : Finset (Fin b)} (S : PointSystem P a bits p R) |
| (hκ : κ ≤ 2) (hD : (dependentOccurrences P R).card = 2*κ) (ha : Eligible P a) |
| (z : (FreeIndex P R → F) × UnusedArray P a) (ij : Fin b × Fin 4) : |
| prescribedPoint P a bits ((coordinateEquiv P hκ R hD a ha bits p).symm z).1 ij = |
| S.point ij (z.1 (S.underlying ij)) := by |
| let e := coordinateEquiv P hκ R hD a ha bits p |
| have hcoord := congrFun (congrArg Prod.fst (e.apply_symm_apply z)) (S.underlying ij) |
| exact (S.realizes (e.symm z) ij).trans (congrArg (S.point ij) hcoord) |
|
|
| theorem PointSystem.aligned_pointLaw {b κ : ℕ} {P : EqualityPattern b κ} |
| {a : DirectionAssignment F b κ} {bits : Bits b} {p : Point F} |
| {R : Finset (Fin b)} (S : PointSystem P a bits p R) |
| (hκ : κ ≤ 2) (hD : (dependentOccurrences P R).card = 2*κ) (ha : Eligible P a) : |
| (alignedLaw P hκ a ha bits p).map |
| (fun M => (prescribedPoint P a bits M, (fun d => M d.1 : UnusedArray P a))) = |
| (PMF.uniformOfFintype ((FreeIndex P R → F) × UnusedArray P a)).map |
| (fun z => ((fun ij => S.point ij (z.1 (S.underlying ij))), z.2)) := by |
| rw [alignedLaw_eq_uniform_coordinates P hκ R hD a ha bits p, PMF.map_comp] |
| congr 1 |
| funext z |
| apply Prod.ext |
| · funext ij |
| exact S.generated_points hκ hD ha z ij |
| · funext d |
| exact generated_unused P hκ R hD a ha bits p z d |
|
|
| theorem PointSystem.conditioned_probability {b κ : ℕ} {P : EqualityPattern b κ} |
| {a : DirectionAssignment F b κ} {bits : Bits b} {p : Point F} |
| {R : Finset (Fin b)} (S : PointSystem P a bits p R) |
| (hκ : κ ≤ 2) (hD : (dependentOccurrences P R).card = 2*κ) (ha : Eligible P a) |
| (E : ((Fin b × Fin 4) → Point F) → UnusedArray P a → Prop) : |
| conditionedOffsetProbability (Aligned P a bits p) |
| (fun M => E (prescribedPoint P a bits M) (fun d => M d.1)) = |
| ((PMF.uniformOfFintype ((FreeIndex P R → F) × UnusedArray P a)).toOuterMeasure |
| {z | E (fun ij => S.point ij (z.1 (S.underlying ij))) z.2}).toReal := by |
| rw [conditionedOffsetProbability_eq_alignedLaw P hκ a ha bits p] |
| have h := congrArg (fun law => (law.toOuterMeasure {z | E z.1 z.2}).toReal) |
| (S.aligned_pointLaw hκ hD ha) |
| simpa only [PMF.toOuterMeasure_map_apply, Set.preimage_ofPred_eq] using h |
|
|
| theorem exists_smallReuse_pointLaw {b κ : ℕ} (P : EqualityPattern b κ) |
| (hb : 3 ≤ b) (hκ : κ ≤ 1) (a : DirectionAssignment F b κ) (ha : Eligible P a) |
| (bits : Bits b) (p : Point F) : |
| ∃ R : Finset (Fin b), ∃ _ : (dependentOccurrences P R).card = 2*κ, |
| ∃ S : PointSystem P a bits p R, |
| ∀ E : ((Fin b × Fin 4) → Point F) → UnusedArray P a → Prop, |
| conditionedOffsetProbability (Aligned P a bits p) |
| (fun M => E (prescribedPoint P a bits M) (fun d => M d.1)) = |
| ((PMF.uniformOfFintype ((FreeIndex P R → F) × UnusedArray P a)).toOuterMeasure |
| {z | E (fun ij => S.point ij (z.1 (S.underlying ij))) z.2}).toReal := by |
| obtain ⟨R, hD, ⟨S⟩⟩ := exists_smallReuse_pointSystem P hb hκ a ha bits p |
| exact ⟨R, hD, S, S.conditioned_probability (by omega) hD ha⟩ |
|
|
| end |
| end Balanced.Local.AlignedGlobal |
|
|
| end OAI |
|
|
