| import Mathlib | |
| import OAI.Computability.DirectedFeedback.Games.RowErasureSliceUniform | |
| namespace OAI | |
| noncomputable section | |
| namespace DFVSGames.Decoder.SelectedPolicies | |
| open DFVSGames.Integration.BinaryLinear DFVSGames.Reduction | |
| open DFVSGames.Inverse | |
| open ActualSource VisiblePolicies MatrixCoordinates | |
| open scoped BigOperators Classical | |
| attribute [local instance] Classical.propDecidable | |
| variable {k s d r : ℕ} | |
| def matrixTable (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (occ : ActualGame.Question S k) | |
| (T : ActualHomogeneous.E k →ₗ[F2] Vector d) | |
| (M : Shortcode.Mat s (1 + 2 * k)) : Alphabet s := | |
| TableKeysGame.unfolded S k s d labeling | |
| (occ, ((mapEquiv k s).symm M).prod T) | |
| def fullTable (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (q : LeftInput S k s d (Vector r)) : Shortcode.Mat s (1 + 2 * k) → Alphabet s := | |
| matrixTable S labeling q.occurrences q.complement | |
| theorem matrixTable_fold (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (occ : ActualGame.Question S k) | |
| (T : ActualHomogeneous.E k →ₗ[F2] Vector d) | |
| (h : Alphabet s) (M : Shortcode.Mat s (1 + 2 * k)) : | |
| matrixTable S labeling occ T | |
| (M + Shortcode.rankOne h (Shortcode.functionalRow (coordinateTau k))) = | |
| matrixTable S labeling occ T M + h := by | |
| unfold matrixTable | |
| rw [mapEquiv_symm_firstBit_shift] | |
| have hprod : (((mapEquiv k s).symm M + ActualHomogeneous.tau.smulRight h).prod T) = | |
| ((mapEquiv k s).symm M).prod T + | |
| ActualHomogeneous.tau.smulRight (h, (0 : Vector d)) := by | |
| apply LinearMap.ext | |
| intro x | |
| apply Prod.ext | |
| · rfl | |
| · simp | |
| rw [hprod] | |
| exact TableKeysGame.unfolded_equivariant S k s d labeling | |
| (occ, ((mapEquiv k s).symm M).prod T) h | |
| def GoodAdvice (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (q : LeftInput S k s d (Vector r)) : Prop := | |
| (RowErasureMatrix.family s (1 + 2 * k) r).GoodAdvice (fullTable S labeling q) α | |
| (LinearMap.toMatrix' q.rowMap) (mapEquiv k r q.rows) | |
| def normalizedDescription (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) : | |
| RowErasureDescriptions.Description s (1 + 2 * k) r := | |
| RowErasureMatrix.normalizedChosenDescription (fullTable S labeling q) α | |
| (LinearMap.toMatrix' q.rowMap) (mapEquiv k r q.rows) hgood (coordinateTau k) | |
| (matrixTable_fold S labeling q.occurrences q.complement) hα hsmall | |
| theorem normalizedDescription_spec (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) : | |
| let F := RowErasureMatrix.family s (1 + 2 * k) r | |
| let D := normalizedDescription S labeling α hα hsmall q hgood | |
| let D₀ := F.chosenDescription (fullTable S labeling q) α | |
| (LinearMap.toMatrix' q.rowMap) (mapEquiv k r q.rows) hgood | |
| F.rowMap D = LinearMap.toMatrix' q.rowMap ∧ | |
| F.rowValue D = mapEquiv k r q.rows ∧ | |
| (F.points D).Nonempty ∧ | |
| α / 2 ≤ F.agreement (fullTable S labeling q) D ∧ | |
| coordinateTau k D.coefficient = 1 ∧ | |
| D.toSlice = D₀.toSlice ∧ | |
| F.agreement (fullTable S labeling q) D = F.agreement (fullTable S labeling q) D₀ ∧ | |
| ∀ M, M ∈ F.points D₀ → F.target D M = F.target D₀ M := | |
| RowErasureMatrix.normalizedChosenDescription_spec (fullTable S labeling q) α | |
| (LinearMap.toMatrix' q.rowMap) (mapEquiv k r q.rows) hgood (coordinateTau k) | |
| (matrixTable_fold S labeling q.occurrences q.complement) hα hsmall | |
| def normalizedResponse (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) : | |
| ResponseWitness k where | |
| columns := (normalizedDescription S labeling α hα hsmall q hgood).toSlice.columnSpan.map | |
| (domainCoordinates k).symm.toLinearMap | |
| coefficient := (domainCoordinates k).symm | |
| (normalizedDescription S labeling α hα hsmall q hgood).coefficient | |
| firstBit := (normalizedDescription_spec S labeling α hα hsmall q hgood).2.2.2.2.1 | |
| theorem normalizedResponse_dimension (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) : | |
| Module.finrank F2 (normalizedResponse S labeling α hα hsmall q hgood).columns ≤ r := by | |
| exact (Submodule.finrank_map_le (domainCoordinates k).symm.toLinearMap | |
| (normalizedDescription S labeling α hα hsmall q hgood).toSlice.columnSpan).trans | |
| (normalizedDescription S labeling α hα hsmall q hgood).toSlice.columnSpan_finrank_le | |
| def goodPredicate (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (w : ResponseWitness k) : Prop := | |
| ∃ hgood : GoodAdvice S labeling α q, | |
| w = normalizedResponse S labeling α hα hsmall q hgood | |
| theorem chosenWitness_eq_normalizedResponse (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) : | |
| chosenWitness (goodPredicate S labeling α hα hsmall) q = | |
| normalizedResponse S labeling α hα hsmall q hgood := by | |
| obtain ⟨hgood', hw⟩ := chosenWitness_spec (goodPredicate S labeling α hα hsmall) q | |
| ⟨normalizedResponse S labeling α hα hsmall q hgood, hgood, rfl⟩ | |
| exact hw | |
| theorem leftPolicy_eq_candidateLaw (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) : | |
| leftPolicy (goodPredicate S labeling α hα hsmall) q = | |
| let w := normalizedResponse S labeling α hα hsmall q hgood | |
| PrivateStrategy.candidateLaw w.columns w.coefficient ActualHomogeneous.tau w.firstBit := by | |
| unfold leftPolicy | |
| rw [chosenWitness_eq_normalizedResponse S labeling α hα hsmall q hgood] | |
| theorem normalized_point_row (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) | |
| (M : Shortcode.Mat s (1 + 2 * k)) | |
| (hM : M ∈ (RowErasureMatrix.family s (1 + 2 * k) r).points | |
| (normalizedDescription S labeling α hα hsmall q hgood)) : | |
| q.rowMap.comp ((mapEquiv k s).symm M) = q.rows := by | |
| have hs := normalizedDescription_spec S labeling α hα hsmall q hgood | |
| have hm := (RowErasureMatrix.family s (1 + 2 * k) r).points_row | |
| (normalizedDescription S labeling α hα hsmall q hgood) M hM | |
| rw [hs.1, hs.2.1] at hm | |
| apply (mapEquiv k r).injective | |
| rw [mapEquiv_rowAdvice, LinearEquiv.apply_symm_apply] | |
| exact hm | |
| theorem normalized_target (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) | |
| (M : Shortcode.Mat s (1 + 2 * k)) : | |
| (RowErasureMatrix.family s (1 + 2 * k) r).target | |
| (normalizedDescription S labeling α hα hsmall q hgood) M = | |
| (mapEquiv k s).symm M (normalizedResponse S labeling α hα hsmall q hgood).coefficient + | |
| (normalizedDescription S labeling α hα hsmall q hgood).intercept := | |
| affine_evaluation k s M _ _ | |
| end DFVSGames.Decoder.SelectedPolicies | |
| end | |
| namespace DFVSGames.Decoder.ActualSeedEvents | |
| open Integration.BinaryLinear Reduction ActualSource Foundations.Games | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| attribute [local instance] Fintype.ofFinite | |
| local instance homFintype {D F : Type*} | |
| [AddCommGroup D] [Module F2 D] [AddCommGroup F] [Module F2 F] | |
| [Fintype D] [Fintype F] : Fintype (D →ₗ[F2] F) := | |
| Fintype.ofInjective (fun M : D →ₗ[F2] F => (M : D → F)) DFunLike.coe_injective | |
| abbrev Seed (S : Source) (k s d r : ℕ) := | |
| AdviceLaw.FullSeed k (Fin S.occurrences) (Alphabet s) (Vector d) (Vector r) | |
| abbrev Datum (S : Source) (k s d r : ℕ) := | |
| AdviceLaw.CompleteData k (Fin S.occurrences) (Alphabet s) (Vector d) (Vector r) | |
| def law (S : Source) (k s d r : ℕ) (β : ℝ) (hβ : 0 ≤ β) (hβ' : β ≤ 1) : | |
| FiniteDistribution (Seed S k s d r) := | |
| AdviceLaw.fullSeedLaw (V := Ambient s d) | |
| (FiniteDistribution.uniform (ActualGame.Question S k)) | |
| (FiniteDistribution.uniform (Alphabet s →ₗ[F2] Vector r)) β hβ hβ' | |
| def draw {S : Source} {k s d r : ℕ} (x : Seed S k s d r) := | |
| AdviceLaw.seedToActualDraw x.1.1 x.1.2 x.2 | |
| def pad (S : Source) (k s d r : ℕ) (x : Seed S k s d r) : ActualEvents.Sample S k s d r := | |
| ActualEvents.fullTableEquiv S k s d r | |
| (AdviceLaw.fullSeedPad (fun i => toBit (ActualGame.rhs S i)) x) | |
| def slice (S : Source) (k s d r : ℕ) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) (α : ℝ) : | |
| Seed S k s d r → Bool := | |
| fun x => ActualEvents.sliceEvent S k s d r labeling α (pad S k s d r x) | |
| def targetHit (S : Source) (k s d r : ℕ) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) (α : ℝ) : | |
| Seed S k s d r → Bool := | |
| fun x => ActualEvents.targetHit S k s d r labeling α (pad S k s d r x) | |
| theorem pad_eq (S : Source) (k s d r : ℕ) (x : Seed S k s d r) : | |
| pad S k s d r x = | |
| (((draw x).occurrences, AdviceExperiment.paddedComplement (ActualGame.rhs S) (draw x)), | |
| (LinearMap.toMatrix' (draw x).rowMap, | |
| MatrixCoordinates.mapEquiv k s (AdviceExperiment.paddedMatrix (ActualGame.rhs S) (draw x)))) := | |
| rfl | |
| theorem slice_eq_selectedEvent (S : Source) (k s d r : ℕ) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) (α : ℝ) | |
| (x : Seed S k s d r) : | |
| slice S k s d r labeling α x = decide | |
| ((Inverse.RowErasureMatrix.family s (1 + 2 * k) r).selectedEvent | |
| (SelectedPolicies.fullTable S labeling | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) (draw x))) α | |
| (LinearMap.toMatrix' (draw x).rowMap) | |
| (MatrixCoordinates.mapEquiv k s (AdviceExperiment.paddedMatrix (ActualGame.rhs S) (draw x)))) := | |
| rfl | |
| theorem targetHit_eq_selectedMatch (S : Source) (k s d r : ℕ) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) (α : ℝ) | |
| (x : Seed S k s d r) : | |
| targetHit S k s d r labeling α x = decide | |
| ((Inverse.RowErasureMatrix.family s (1 + 2 * k) r).selectedMatch | |
| (SelectedPolicies.fullTable S labeling | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) (draw x))) α | |
| (LinearMap.toMatrix' (draw x).rowMap) | |
| (MatrixCoordinates.mapEquiv k s (AdviceExperiment.paddedMatrix (ActualGame.rhs S) (draw x)))) := | |
| rfl | |
| theorem slice_good (S : Source) (k s d r : ℕ) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) (α : ℝ) | |
| (x : Seed S k s d r) (hx : slice S k s d r labeling α x = true) : | |
| SelectedPolicies.GoodAdvice S labeling α | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) (draw x)) := by | |
| rw [slice_eq_selectedEvent] at hx | |
| have h := (Inverse.RowErasureMatrix.family s (1 + 2 * k) r).selectedEvent_good | |
| (SelectedPolicies.fullTable S labeling | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) (draw x))) α | |
| (LinearMap.toMatrix' (draw x).rowMap) | |
| (MatrixCoordinates.mapEquiv k s (AdviceExperiment.paddedMatrix (ActualGame.rhs S) (draw x))) | |
| (of_decide_eq_true hx) | |
| change (Inverse.RowErasureMatrix.family s (1 + 2 * k) r).GoodAdvice | |
| (SelectedPolicies.fullTable S labeling | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) (draw x))) α | |
| (LinearMap.toMatrix' (draw x).rowMap) | |
| (MatrixCoordinates.mapEquiv k r | |
| ((draw x).rowMap.comp (AdviceExperiment.paddedMatrix (ActualGame.rhs S) (draw x)))) | |
| rw [MatrixCoordinates.mapEquiv_rowAdvice] | |
| exact h | |
| end | |
| end DFVSGames.Decoder.ActualSeedEvents | |
| namespace DFVSGames.Decoder.ActualSeedVariation | |
| open Integration.BinaryLinear Reduction ActualSource Foundations.Games | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| attribute [local instance] Fintype.ofFinite | |
| local instance homFintype {D F : Type*} | |
| [AddCommGroup D] [Module F2 D] [AddCommGroup F] [Module F2 F] | |
| [Fintype D] [Fintype F] : Fintype (D →ₗ[F2] F) := | |
| Fintype.ofInjective (fun M : D →ₗ[F2] F => (M : D → F)) DFunLike.coe_injective | |
| theorem uniform_pushforward_equiv {X Y : Type*} [Fintype X] [Fintype Y] | |
| [Nonempty X] [Nonempty Y] (e : X ≃ Y) : | |
| (FiniteDistribution.uniform X).pushforward e = FiniteDistribution.uniform Y := by | |
| rw [FiniteDistribution.pushforward_equiv] | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro y | |
| simp only [FiniteDistribution.transport, FiniteDistribution.uniform, | |
| Fintype.card_congr e] | |
| theorem totalVariation_pushforward_equiv {X Y : Type*} [Fintype X] [Fintype Y] | |
| (μ ν : FiniteDistribution X) (e : X ≃ Y) : | |
| (μ.pushforward e).totalVariation (ν.pushforward e) = μ.totalVariation ν := by | |
| rw [FiniteDistribution.pushforward_equiv, FiniteDistribution.pushforward_equiv] | |
| unfold FiniteDistribution.totalVariation FiniteDistribution.transport | |
| congr 1 | |
| exact e.symm.sum_comp (fun x => |μ.weight x - ν.weight x|) | |
| theorem ideal_full_uniform (S : Source) (k s d r : ℕ) : | |
| AdviceLaw.withKernel | |
| ((FiniteDistribution.uniform (ActualGame.Question S k)).product | |
| (FiniteDistribution.uniform (Alphabet s →ₗ[F2] Vector r))) | |
| (fun _ => FiniteDistribution.uniform (ActualGame.Map k s d)) = | |
| FiniteDistribution.uniform (ActualEvents.FullTableSample S k s d r) := by | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro p | |
| simp only [AdviceLaw.withKernel, FiniteDistribution.product, FiniteDistribution.uniform, | |
| Fintype.card_prod, Nat.cast_mul] | |
| ring | |
| theorem ideal_pad_coordinates (S : Source) (k s d r : ℕ) : | |
| (AdviceLaw.withKernel | |
| ((FiniteDistribution.uniform (ActualGame.Question S k)).product | |
| (FiniteDistribution.uniform (Alphabet s →ₗ[F2] Vector r))) | |
| (fun _ => FiniteDistribution.uniform (ActualGame.Map k s d))).pushforward | |
| (ActualEvents.fullTableEquiv S k s d r) = ActualEvents.unrestricted S k s d r := by | |
| rw [ideal_full_uniform] | |
| exact uniform_pushforward_equiv _ | |
| theorem actual_totalVariation_le_slope (S : Source) (k s d r : ℕ) | |
| (β : ℝ) (hβ : 0 ≤ β) (hβ' : β ≤ 1) : | |
| (ActualEvents.unrestricted S k s d r).totalVariation | |
| ((ActualSeedEvents.law S k s d r β hβ hβ').pushforward (ActualSeedEvents.pad S k s d r)) ≤ | |
| Foundations.Information.totalVariation | |
| (SparseLaw.independentWeights | |
| (SparseLaw.mixture β (SparseLaw.singletonPairWeights (Ambient s d))) k) | |
| (SparseLaw.uniformWeights (Fin k → Ambient s d × Ambient s d)) := by | |
| rw [FiniteDistribution.totalVariation_comm] | |
| have h := AdviceLaw.fullSeed_totalVariation_le_slope (V := Ambient s d) | |
| (FiniteDistribution.uniform (ActualGame.Question S k)) | |
| (FiniteDistribution.uniform (Alphabet s →ₗ[F2] Vector r)) | |
| (fun i => toBit (ActualGame.rhs S i)) β hβ hβ' | |
| rw [← ideal_pad_coordinates S k s d r] | |
| change ((ActualSeedEvents.law S k s d r β hβ hβ').pushforward | |
| (fun x => ActualEvents.fullTableEquiv S k s d r | |
| (AdviceLaw.fullSeedPad (fun i => toBit (ActualGame.rhs S i)) x))).totalVariation _ ≤ _ | |
| rw [← FiniteDistribution.pushforward_comp, totalVariation_pushforward_equiv] | |
| convert h using 1 <;> congr 4 ; exact Subsingleton.elim _ _ | |
| end | |
| end DFVSGames.Decoder.ActualSeedVariation | |
| noncomputable section | |
| namespace DFVSGames.Decoder.SelectedDecoding | |
| open DFVSGames.Integration.BinaryLinear DFVSGames.Reduction DFVSGames.Soundness | |
| open DFVSGames.Inverse | |
| open ActualSource VisiblePolicies SelectedPolicies MatrixCoordinates | |
| open scoped BigOperators Classical | |
| attribute [local instance] Classical.propDecidable | |
| attribute [local instance] Fintype.ofFinite | |
| local instance homFintype {D F : Type*} | |
| [AddCommGroup D] [Module F2 D] [AddCommGroup F] [Module F2 F] | |
| [Fintype D] [Fintype F] : Fintype (D →ₗ[F2] F) := | |
| Fintype.ofInjective (fun M : D →ₗ[F2] F => (M : D → F)) DFunLike.coe_injective | |
| instance affineSliceFintype {E K L : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup K] [Module F2 K] | |
| [AddCommGroup L] [Module F2 L] [Fintype (E →ₗ[F2] K)] | |
| (A : K →ₗ[F2] L) (Q : Submodule F2 E) (Mstar : E →ₗ[F2] K) : | |
| Fintype (RowErasureSliceQuotient.AffineSlice A Q Mstar) := by | |
| unfold RowErasureSliceQuotient.AffineSlice | |
| infer_instance | |
| variable {k s d r : ℕ} | |
| theorem selectedEvent_iff_normalized (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) | |
| (M : Shortcode.Mat s (1 + 2 * k)) | |
| (hrow : RowErasureMatrix.rowAdvice (LinearMap.toMatrix' q.rowMap) M = | |
| mapEquiv k r q.rows) : | |
| (RowErasureMatrix.family s (1 + 2 * k) r).selectedEvent | |
| (fullTable S labeling q) α (LinearMap.toMatrix' q.rowMap) M ↔ | |
| M ∈ (RowErasureMatrix.family s (1 + 2 * k) r).points | |
| (normalizedDescription S labeling α hα hsmall q hgood) := by | |
| have he := (RowErasureMatrix.family s (1 + 2 * k) r).selectedEvent_iff_of_advice | |
| (fullTable S labeling q) α (LinearMap.toMatrix' q.rowMap) | |
| (mapEquiv k r q.rows) hgood M hrow | |
| obtain ⟨_, _, _, _, _, hslice, _, _⟩ := | |
| normalizedDescription_spec S labeling α hα hsmall q hgood | |
| rw [show (RowErasureMatrix.family s (1 + 2 * k) r).points | |
| (normalizedDescription S labeling α hα hsmall q hgood) = | |
| (RowErasureMatrix.family s (1 + 2 * k) r).points | |
| ((RowErasureMatrix.family s (1 + 2 * k) r).chosenDescription | |
| (fullTable S labeling q) α (LinearMap.toMatrix' q.rowMap) | |
| (mapEquiv k r q.rows) hgood) from congrArg Shortcode.Slice.points hslice] | |
| exact he | |
| theorem selectedMatch_iff_normalized (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (q : LeftInput S k s d (Vector r)) (hgood : GoodAdvice S labeling α q) | |
| (M : Shortcode.Mat s (1 + 2 * k)) | |
| (hrow : RowErasureMatrix.rowAdvice (LinearMap.toMatrix' q.rowMap) M = | |
| mapEquiv k r q.rows) : | |
| (RowErasureMatrix.family s (1 + 2 * k) r).selectedMatch | |
| (fullTable S labeling q) α (LinearMap.toMatrix' q.rowMap) M ↔ | |
| M ∈ (RowErasureMatrix.family s (1 + 2 * k) r).points | |
| (normalizedDescription S labeling α hα hsmall q hgood) ∧ | |
| fullTable S labeling q M = | |
| (mapEquiv k s).symm M | |
| (normalizedResponse S labeling α hα hsmall q hgood).coefficient + | |
| (normalizedDescription S labeling α hα hsmall q hgood).intercept := by | |
| let F := RowErasureMatrix.family s (1 + 2 * k) r | |
| let D := normalizedDescription S labeling α hα hsmall q hgood | |
| let D₀ := F.chosenDescription (fullTable S labeling q) α | |
| (LinearMap.toMatrix' q.rowMap) (mapEquiv k r q.rows) hgood | |
| have he := F.selectedMatch_iff_of_advice (fullTable S labeling q) α | |
| (LinearMap.toMatrix' q.rowMap) (mapEquiv k r q.rows) hgood M hrow | |
| obtain ⟨_, _, _, _, _, hslice, _, htarget⟩ := | |
| normalizedDescription_spec S labeling α hα hsmall q hgood | |
| have hp : F.points D = F.points D₀ := congrArg Shortcode.Slice.points hslice | |
| rw [← normalized_target S labeling α hα hsmall q hgood M] | |
| constructor | |
| · intro h | |
| obtain ⟨hm, hf⟩ := he.mp h | |
| refine ⟨hp.symm ▸ hm, ?_⟩ | |
| rw [htarget M hm] | |
| exact hf | |
| · rintro ⟨hm, hf⟩ | |
| have hm₀ : M ∈ F.points D₀ := hp ▸ hm | |
| apply he.mpr | |
| refine ⟨hm₀, ?_⟩ | |
| rw [← htarget M hm₀] | |
| exact hf | |
| theorem rowKernel_reciprocal_le (A : Alphabet s →ₗ[F2] Vector r) : | |
| 1 / (Fintype.card A.ker : ℝ) ≤ 1 / (2 : ℝ) ^ (s - r) := by | |
| have hk : 2 ^ (s - r) ≤ Fintype.card A.ker := by | |
| simpa only [Nat.card_eq_fintype_card] using binary_kernel_card_lower A | |
| have hk' : (2 : ℝ) ^ (s - r) ≤ (Fintype.card A.ker : ℝ) := by | |
| exact_mod_cast hk | |
| exact one_div_le_one_div_of_le (by positivity) hk' | |
| def transferredAgreement (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (draw : AdviceExperiment.Draw k (Fin S.occurrences) (Alphabet s) (Vector d) (Vector r)) | |
| (w : ResponseWitness k) (u : Alphabet s) | |
| (Mstar : RawPartnerTarget.RawPoint draw.singletons →ₗ[F2] Alphabet s) : ℝ := | |
| 𝔼 M : RowErasureSliceQuotient.AffineSlice draw.rowMap | |
| (w.columns.map (AdviceExperiment.projection (ActualGame.rhs S) draw)) Mstar, | |
| if TableKeysRestoration.projectedAnswer S k s d labeling draw.singletons | |
| (RawPrivateTable.supported draw.singletons (ActualGame.names S) | |
| draw.occurrences draw.positions) (M.val.prod draw.complement) = | |
| M.val (AdviceExperiment.projection (ActualGame.rhs S) draw w.coefficient) + u | |
| then (1 : ℝ) else 0 | |
| theorem observedAgreement_lower (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (draw : AdviceExperiment.Draw k (Fin S.occurrences) (Alphabet s) (Vector d) (Vector r)) | |
| (hgood : GoodAdvice S labeling α (AdviceExperiment.leftObservation (ActualGame.rhs S) draw)) | |
| (Mstar : RawPartnerTarget.RawPoint draw.singletons →ₗ[F2] Alphabet s) | |
| (hstar : draw.rowMap.comp Mstar = draw.rowMap.comp draw.hiddenMatrix) | |
| (hagreement : α / 4 ≤ transferredAgreement S labeling draw | |
| (normalizedResponse S labeling α hα hsmall | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) draw) hgood) | |
| (normalizedDescription S labeling α hα hsmall | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) draw) hgood).intercept Mstar) : | |
| (α / 8) ^ 2 / (2 : ℝ) ^ (s * r) / (2 : ℝ) ^ r ≤ | |
| observedAgreement S labeling (goodPredicate S labeling α hα hsmall) draw := by | |
| let q := AdviceExperiment.leftObservation (ActualGame.rhs S) draw | |
| let w := normalizedResponse S labeling α hα hsmall q hgood | |
| let u := (normalizedDescription S labeling α hα hsmall q hgood).intercept | |
| have hH : Module.finrank F2 draw.rowMap.ker ≤ s := by | |
| simpa only [Module.finrank_fin_fun] using draw.rowMap.ker.finrank_le | |
| have hs : 1 / (Fintype.card draw.rowMap.ker : ℝ) ≤ α / 8 := | |
| (rowKernel_reciprocal_le draw.rowMap).trans hsmall.le | |
| have h := TransferredDecoding.actual_transferred_decoding S labeling draw.singletons | |
| draw.occurrences draw.positions draw.rowMap | |
| (AdviceFibers.observe draw.rowMap draw.hiddenMatrix) draw.complement Mstar hstar | |
| w.columns w.coefficient w.firstBit u α hα.le s r hH | |
| (normalizedResponse_dimension S labeling α hα hsmall q hgood) hs hagreement | |
| rw [observedAgreement_eq_private, | |
| chosenWitness_eq_normalizedResponse S labeling α hα hsmall _ hgood] | |
| exact h | |
| end DFVSGames.Decoder.SelectedDecoding | |
| end | |
| noncomputable section | |
| namespace DFVSGames.Decoder.ProjectedColumnSlice | |
| open DFVSGames.Integration.BinaryLinear DFVSGames.Reduction DFVSGames.Soundness | |
| open DFVSGames.Inverse | |
| open ActualSource VisiblePolicies SelectedPolicies MatrixCoordinates | |
| open scoped BigOperators Classical | |
| attribute [local instance] Classical.propDecidable | |
| variable {k s d r : ℕ} | |
| section Algebra | |
| variable {V : Type*} [AddCommGroup V] [Module F2 V] | |
| theorem column_agreement_iff (Q : Submodule F2 (Vector (1 + 2 * k))) | |
| (π : ActualHomogeneous.E k →ₗ[F2] V) (M Mstar : V →ₗ[F2] Alphabet s) : | |
| (∀ x ∈ Q, M (π ((domainCoordinates k).symm x)) = | |
| Mstar (π ((domainCoordinates k).symm x))) ↔ | |
| ∀ v ∈ (Q.map (domainCoordinates k).symm.toLinearMap).map π, M v = Mstar v := by | |
| constructor | |
| · intro h v hv | |
| obtain ⟨z, hz, rfl⟩ := Submodule.mem_map.mp hv | |
| obtain ⟨x, hx, rfl⟩ := Submodule.mem_map.mp hz | |
| exact h x hx | |
| · intro h x hx | |
| apply h | |
| exact Submodule.mem_map.mpr ⟨(domainCoordinates k).symm x, | |
| Submodule.mem_map.mpr ⟨x, hx, rfl⟩, rfl⟩ | |
| theorem contains_padded_iff | |
| (D : RowErasureDescriptions.Description s (1 + 2 * k) r) | |
| (A : Alphabet s →ₗ[F2] Vector r) | |
| (hDrow : (RowErasureMatrix.family s (1 + 2 * k) r).rowMap D = LinearMap.toMatrix' A) | |
| (π : ActualHomogeneous.E k →ₗ[F2] V) (Mstar : V →ₗ[F2] Alphabet s) | |
| (hstar : mapEquiv k s (Mstar.comp π) ∈ D.toSlice.points) | |
| (M : V →ₗ[F2] Alphabet s) (hrow : A.comp M = A.comp Mstar) : | |
| mapEquiv k s (M.comp π) ∈ D.toSlice.points ↔ | |
| ∀ v ∈ (D.toSlice.columnSpan.map (domainCoordinates k).symm.toLinearMap).map π, | |
| M v = Mstar v := by | |
| have hr : D.toSlice.rowMap = A := by | |
| change Matrix.toLin' D.1 = A | |
| change D.1 = LinearMap.toMatrix' A at hDrow | |
| rw [hDrow, Matrix.toLin'_toMatrix'] | |
| have hc (N : V →ₗ[F2] Alphabet s) : | |
| Matrix.toLin' (mapEquiv k s (N.comp π)) = | |
| (N.comp π).comp (domainCoordinates k).symm.toLinearMap := by | |
| rw [mapEquiv_apply, Matrix.toLin'_toMatrix'] | |
| have hs : D.toSlice.Contains (mapEquiv k s (Mstar.comp π)) := | |
| (Finset.mem_filter.mp hstar).2 | |
| have he := D.toSlice.contains_iff_inSlice (mapEquiv k s (Mstar.comp π)) hs | |
| (mapEquiv k s (M.comp π)) | |
| rw [AffineWitness.InSlice, hr, hc, hc] at he | |
| have hrows : A.comp ((M.comp π).comp (domainCoordinates k).symm.toLinearMap) = | |
| A.comp ((Mstar.comp π).comp (domainCoordinates k).symm.toLinearMap) := by | |
| apply LinearMap.ext | |
| intro x | |
| exact LinearMap.congr_fun hrow (π ((domainCoordinates k).symm x)) | |
| constructor | |
| · intro h | |
| have hh := he.mp (Finset.mem_filter.mp h).2 | |
| exact (column_agreement_iff D.toSlice.columnSpan π M Mstar).mp hh.2 | |
| · intro h | |
| apply Finset.mem_filter.mpr | |
| exact ⟨Finset.mem_univ _, he.mpr ⟨hrows, | |
| (column_agreement_iff D.toSlice.columnSpan π M Mstar).mpr h⟩⟩ | |
| def paddedSliceEquiv | |
| (D : RowErasureDescriptions.Description s (1 + 2 * k) r) | |
| (A : Alphabet s →ₗ[F2] Vector r) | |
| (hDrow : (RowErasureMatrix.family s (1 + 2 * k) r).rowMap D = LinearMap.toMatrix' A) | |
| (π : ActualHomogeneous.E k →ₗ[F2] V) (Mstar : V →ₗ[F2] Alphabet s) | |
| (hstar : mapEquiv k s (Mstar.comp π) ∈ D.toSlice.points) : | |
| {M : V →ₗ[F2] Alphabet s // A.comp M = A.comp Mstar ∧ | |
| mapEquiv k s (M.comp π) ∈ D.toSlice.points} ≃ | |
| RowErasureSliceQuotient.AffineSlice A | |
| ((D.toSlice.columnSpan.map (domainCoordinates k).symm.toLinearMap).map π) Mstar where | |
| toFun M := ⟨M.val, M.property.1, | |
| (contains_padded_iff D A hDrow π Mstar hstar M.val M.property.1).mp M.property.2⟩ | |
| invFun M := ⟨M.val, M.property.1, | |
| (contains_padded_iff D A hDrow π Mstar hstar M.val M.property.1).mpr M.property.2⟩ | |
| left_inv _ := rfl | |
| right_inv _ := rfl | |
| theorem paddedSlice_expect | |
| (D : RowErasureDescriptions.Description s (1 + 2 * k) r) | |
| (A : Alphabet s →ₗ[F2] Vector r) | |
| (hDrow : (RowErasureMatrix.family s (1 + 2 * k) r).rowMap D = LinearMap.toMatrix' A) | |
| (π : ActualHomogeneous.E k →ₗ[F2] V) (Mstar : V →ₗ[F2] Alphabet s) | |
| (hstar : mapEquiv k s (Mstar.comp π) ∈ D.toSlice.points) | |
| [Fintype {M : V →ₗ[F2] Alphabet s // A.comp M = A.comp Mstar ∧ | |
| mapEquiv k s (M.comp π) ∈ D.toSlice.points}] | |
| [Fintype (RowErasureSliceQuotient.AffineSlice A | |
| ((D.toSlice.columnSpan.map (domainCoordinates k).symm.toLinearMap).map π) Mstar)] | |
| (f : (V →ₗ[F2] Alphabet s) → ℝ) : | |
| (𝔼 M : {M : V →ₗ[F2] Alphabet s // A.comp M = A.comp Mstar ∧ | |
| mapEquiv k s (M.comp π) ∈ D.toSlice.points}, f M.val) = | |
| 𝔼 M : RowErasureSliceQuotient.AffineSlice A | |
| ((D.toSlice.columnSpan.map (domainCoordinates k).symm.toLinearMap).map π) Mstar, | |
| f M.val := by | |
| exact Fintype.expect_equiv (paddedSliceEquiv D A hDrow π Mstar hstar) _ _ (fun _ => rfl) | |
| end Algebra | |
| theorem fullTable_padded (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (draw : AdviceExperiment.Draw k (Fin S.occurrences) (Alphabet s) (Vector d) (Vector r)) | |
| (M : RawPartnerTarget.RawPoint draw.singletons →ₗ[F2] Alphabet s) : | |
| fullTable S labeling (AdviceExperiment.leftObservation (ActualGame.rhs S) draw) | |
| (mapEquiv k s (M.comp (AdviceExperiment.projection (ActualGame.rhs S) draw))) = | |
| TableKeysRestoration.projectedAnswer S k s d labeling draw.singletons | |
| (RawPrivateTable.supported draw.singletons (ActualGame.names S) | |
| draw.occurrences draw.positions) (M.prod draw.complement) := by | |
| unfold fullTable matrixTable | |
| rw [LinearEquiv.symm_apply_apply, TableKeysRestoration.projectedAnswer_pullback] ; rfl | |
| theorem normalized_contains_iff (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (draw : AdviceExperiment.Draw k (Fin S.occurrences) (Alphabet s) (Vector d) (Vector r)) | |
| (hgood : GoodAdvice S labeling α (AdviceExperiment.leftObservation (ActualGame.rhs S) draw)) | |
| (Mstar : RawPartnerTarget.RawPoint draw.singletons →ₗ[F2] Alphabet s) | |
| (hstar : mapEquiv k s (Mstar.comp (AdviceExperiment.projection (ActualGame.rhs S) draw)) ∈ | |
| (normalizedDescription S labeling α hα hsmall | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) draw) hgood).toSlice.points) | |
| (M : RawPartnerTarget.RawPoint draw.singletons →ₗ[F2] Alphabet s) | |
| (hrow : draw.rowMap.comp M = draw.rowMap.comp Mstar) : | |
| mapEquiv k s (M.comp (AdviceExperiment.projection (ActualGame.rhs S) draw)) ∈ | |
| (normalizedDescription S labeling α hα hsmall | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) draw) hgood).toSlice.points ↔ | |
| ∀ v ∈ (normalizedResponse S labeling α hα hsmall | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) draw) hgood).columns.map | |
| (AdviceExperiment.projection (ActualGame.rhs S) draw), M v = Mstar v := by | |
| exact contains_padded_iff _ draw.rowMap | |
| (normalizedDescription_spec S labeling α hα hsmall _ hgood).1 | |
| (AdviceExperiment.projection (ActualGame.rhs S) draw) Mstar hstar M hrow | |
| theorem normalized_target_padded (S : Source) | |
| (labeling : Fin (TableKeysGame.vertexCount S k s d) → Fin (2 ^ s)) | |
| (α : ℝ) (hα : 0 < α) (hsmall : 1 / (2 : ℝ) ^ (s - r) < α / 8) | |
| (draw : AdviceExperiment.Draw k (Fin S.occurrences) (Alphabet s) (Vector d) (Vector r)) | |
| (hgood : GoodAdvice S labeling α (AdviceExperiment.leftObservation (ActualGame.rhs S) draw)) | |
| (M : RawPartnerTarget.RawPoint draw.singletons →ₗ[F2] Alphabet s) : | |
| (RowErasureMatrix.family s (1 + 2 * k) r).target | |
| (normalizedDescription S labeling α hα hsmall | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) draw) hgood) | |
| (mapEquiv k s (M.comp (AdviceExperiment.projection (ActualGame.rhs S) draw))) = | |
| M (AdviceExperiment.projection (ActualGame.rhs S) draw | |
| (normalizedResponse S labeling α hα hsmall | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) draw) hgood).coefficient) + | |
| (normalizedDescription S labeling α hα hsmall | |
| (AdviceExperiment.leftObservation (ActualGame.rhs S) draw) hgood).intercept := by | |
| rw [normalized_target, LinearEquiv.symm_apply_apply] ; rfl | |
| end DFVSGames.Decoder.ProjectedColumnSlice | |
| end | |
| namespace DFVSGames.Decoder.UniformConditioning | |
| open Foundations.Games | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| variable {Ω : Type*} [Fintype Ω] | |
| theorem sum_over_event (given : Ω → Bool) (f : Ω → ℝ) : | |
| (∑ x, if given x then f x else 0) = ∑ x : {x : Ω // given x = true}, f x.val := by | |
| rw [← Finset.sum_filter] | |
| exact Finset.sum_subtype _ (fun x => by simp) f | |
| theorem probability_as_subtype_sum (μ : FiniteDistribution Ω) (given : Ω → Bool) : | |
| μ.probability given = ∑ x : {x : Ω // given x = true}, μ.weight x.val := | |
| sum_over_event given μ.weight | |
| theorem probability_and_as_subtype_sum (μ : FiniteDistribution Ω) | |
| (given event : Ω → Bool) : | |
| μ.probability (fun x => given x && event x) = | |
| ∑ x : {x : Ω // given x = true}, if event x.val then μ.weight x.val else 0 := by | |
| calc | |
| _ = ∑ x, if given x then (if event x then μ.weight x else 0) else 0 := by | |
| apply Finset.sum_congr rfl | |
| intro x _ | |
| change (if given x && event x then μ.weight x else 0) = _ | |
| cases given x <;> cases event x <;> rfl | |
| _ = _ := sum_over_event given _ | |
| theorem probability_of_constant_weight (μ : FiniteDistribution Ω) | |
| (given : Ω → Bool) (c : ℝ) (hconstant : ∀ x, given x = true → μ.weight x = c) : | |
| μ.probability given = (Fintype.card {x : Ω // given x = true} : ℝ) * c := by | |
| rw [probability_as_subtype_sum] | |
| calc | |
| _ = ∑ _x : {x : Ω // given x = true}, c := by | |
| apply Finset.sum_congr rfl | |
| intro x _ | |
| exact hconstant x.val x.property | |
| _ = _ := by simp [nsmul_eq_mul] | |
| theorem condition_probability_uniform (μ : FiniteDistribution Ω) | |
| (given event : Ω → Bool) (positive : 0 < μ.probability given) | |
| (c : ℝ) (hconstant : ∀ x, given x = true → μ.weight x = c) : | |
| (μ.condition given positive).probability event = | |
| 𝔼 x : {x : Ω // given x = true}, if event x.val then (1 : ℝ) else 0 := by | |
| have hp := probability_of_constant_weight μ given c hconstant | |
| have hc : c ≠ 0 := by | |
| intro hz | |
| rw [hp, hz, mul_zero] at positive | |
| exact (lt_irrefl 0) positive | |
| have hn : (Fintype.card {x : Ω // given x = true} : ℝ) ≠ 0 := by | |
| intro hz | |
| rw [hp, hz, zero_mul] at positive | |
| exact (lt_irrefl 0) positive | |
| rw [FiniteDistribution.probability_condition, probability_and_as_subtype_sum, hp, | |
| Fintype.expect_eq_sum_div_card] | |
| have hnum : (∑ x : {x : Ω // given x = true}, if event x.val then μ.weight x.val else 0) = | |
| c * ∑ x : {x : Ω // given x = true}, if event x.val then (1 : ℝ) else 0 := by | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro x _ | |
| rw [hconstant x.val x.property] | |
| cases event x.val <;> simp | |
| rw [hnum] | |
| field_simp [hc, hn] | |
| theorem condition_probability_equiv {Y : Type*} [Fintype Y] | |
| (μ : FiniteDistribution Ω) (given event : Ω → Bool) | |
| (positive : 0 < μ.probability given) (c : ℝ) | |
| (hconstant : ∀ x, given x = true → μ.weight x = c) | |
| (e : {x : Ω // given x = true} ≃ Y) (target : Y → Bool) | |
| (hevent : ∀ x, event x.val = target (e x)) : | |
| (μ.condition given positive).probability event = | |
| 𝔼 y : Y, if target y then (1 : ℝ) else 0 := by | |
| rw [condition_probability_uniform μ given event positive c hconstant] | |
| apply Fintype.expect_equiv e | |
| intro x | |
| rw [hevent x] | |
| end | |
| end DFVSGames.Decoder.UniformConditioning | |
| end OAI | |