openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /JointExtraction /MaskedAssignment.lean
| import OAI.LinearAlgebra.MatrixMultiplication.JointExtraction.MaskedSelection | |
| namespace OAI | |
| /-! Joint tensor extraction, compatibility and entropy estimates. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.JointMaskedSelection.OrbitData | |
| open JointCoarseHashing | |
| attribute [local instance] Classical.propDecidable | |
| variable {P E O V : Type*} [Fintype P] [Fintype E] | |
| def actualTargets (d : OrbitData P E O V) : Finset (Triple P) := | |
| Finset.univ.image d.coarse | |
| theorem coarse_mem_actualTargets (d : OrbitData P E O V) (e : E) : | |
| d.coarse e ∈ d.actualTargets := | |
| Finset.mem_image.mpr ⟨e, Finset.mem_univ e, rfl⟩ | |
| def xFlag (k : ℕ) (U : Finset (ZMod (37 ^ k))) (s : Sample P k) (I : Word P) : Prop := | |
| JointHashing.xHash s (castWord k I) ∈ U | |
| def yFlag (k : ℕ) (U : Finset (ZMod (37 ^ k))) (s : Sample P k) (J : Word P) : Prop := | |
| JointHashing.yHash s (castWord k J) ∈ U | |
| def zFlag (d : OrbitData P E O V) (k : ℕ) (U : Finset (ZMod (37 ^ k))) | |
| (s : Sample P k) (K : Word P) : Prop := | |
| JointHashing.zHash (twoUnit k) s (fun p => (d.support p : ZMod (37 ^ k))) (castWord k K) ∈ U | |
| omit [Fintype E] in | |
| theorem actual_survival_iff (d : OrbitData P E O V) (k : ℕ) | |
| (U : Finset (ZMod (37 ^ k))) | |
| (hAP : ∀ x ∈ U, ∀ y ∈ U, ∀ z ∈ U, x + y = 2 * z → x = z ∧ y = z) | |
| (s : Sample P k) (f : Triple P) (hf : f ∈ d.ambient) : | |
| JointCoarseAssignment.survives (xFlag k U s) (yFlag k U s) (d.zFlag k U s) f ↔ | |
| Survives k U f s := | |
| full_survival_iff k U hAP d.support f (d.support_ambient f hf) s | |
| def actualEligible (d : OrbitData P E O V) (k : ℕ) (U : Finset (ZMod (37 ^ k))) | |
| (s : Sample P k) : Finset (Triple P) := | |
| JointCoarseAssignment.eligible d.ambient d.actualTargets | |
| (xFlag k U s) (yFlag k U s) (d.zFlag k U s) | |
| theorem good_mem_actualEligible (d : OrbitData P E O V) (k : ℕ) | |
| (U : Finset (ZMod (37 ^ k))) | |
| (hAP : ∀ x ∈ U, ∀ y ∈ U, ∀ z ∈ U, x + y = 2 * z → x = z ∧ y = z) | |
| (N : ℝ) (e : E) (s : Sample P k) (hg : d.Good k U N e s) : | |
| d.coarse e ∈ d.actualEligible k U s := by | |
| apply JointAssignmentLoss.eligible_of_no_ambientXCollision d.ambient d.actualTargets | |
| (xFlag k U s) (yFlag k U s) (d.zFlag k U s) (d.coarse e) | |
| (d.target_mem e) (d.coarse_mem_actualTargets e) | |
| ((d.actual_survival_iff k U hAP s _ (d.target_mem e)).2 hg.1) | |
| rintro ⟨f, hf, hne, hs, hx⟩ | |
| exact d.good_eligibility k U N e s hg | |
| ⟨f, (d.mem_eligibilityCompetitors e f).2 ⟨hf, hne, hx⟩, | |
| (d.actual_survival_iff k U hAP s f hf).1 hs⟩ | |
| def actualAssignment (d : OrbitData P E O V) (k : ℕ) (U : Finset (ZMod (37 ^ k))) | |
| (compatible useful : Triple P → V → Prop) (keep : V → Prop) | |
| (s : Sample P k) (v : V) : Option (Triple P) := | |
| JointExtraction.retainAssignment | |
| (JointCoarseAssignment.assignUseful (d.actualEligible k U s) compatible useful) keep v | |
| theorem model_retained_assigned (d : OrbitData P E O V) (k : ℕ) | |
| (U : Finset (ZMod (37 ^ k))) | |
| (hAP : ∀ x ∈ U, ∀ y ∈ U, ∀ z ∈ U, x + y = 2 * z → x = z ∧ y = z) | |
| (N : ℝ) (e : E) (o : O) (ho : o ∈ d.orbits e) (s : Sample P k) | |
| (hg : d.Good k U N e s) | |
| (compatible useful : Triple P → V → Prop) (keep : V → Prop) | |
| (v : V) (hv : v ∈ JointLossCounts.retained (d.passing e o) (d.variableBad k U e o) s) | |
| (hc : compatible (d.coarse e) v) (hu : useful (d.coarse e) v) (hk : keep v) | |
| (hcover : ∀ f ∈ d.actualTargets, f ≠ d.coarse e → compatible f v → | |
| f ∈ d.competitors e o v) : | |
| d.actualAssignment k U compatible useful keep s v = some (d.coarse e) := by | |
| obtain ⟨hpass, hnotbad⟩ := Finset.mem_filter.1 hv | |
| have hassign := JointAssignmentLoss.assignUseful_of_no_targetCollision | |
| d.ambient d.actualTargets (xFlag k U s) (yFlag k U s) (d.zFlag k U s) | |
| compatible useful (d.coarse e) v (d.good_mem_actualEligible k U hAP N e s hg) hc hu | |
| (by | |
| rintro ⟨f, hf, hne, hsurv, hcomp⟩ | |
| have hfc := hcover f hf hne hcomp | |
| have hfa := d.competitor_mem e o ho v hpass f hfc | |
| exact hnotbad ⟨f, hfc, (d.actual_survival_iff k U hAP s f hfa).1 hsurv⟩) | |
| simpa only [actualAssignment, actualEligible, JointExtraction.retainAssignment, ite_eq_left hk] using hassign | |
| theorem actual_failure_subset_model_missing (d : OrbitData P E O V) (k : ℕ) | |
| (U : Finset (ZMod (37 ^ k))) | |
| (hAP : ∀ x ∈ U, ∀ y ∈ U, ∀ z ∈ U, x + y = 2 * z → x = z ∧ y = z) | |
| (N : ℝ) (e : E) (o : O) (ho : o ∈ d.orbits e) (s : Sample P k) | |
| (hg : d.Good k U N e s) | |
| (compatible useful : Triple P → V → Prop) (keep : V → Prop) | |
| (hc : ∀ v ∈ d.passing e o, compatible (d.coarse e) v) | |
| (hu : ∀ v ∈ d.passing e o, useful (d.coarse e) v) | |
| (hk : ∀ v ∈ d.passing e o, keep v) | |
| (hcover : ∀ v ∈ d.passing e o, ∀ f ∈ d.actualTargets, | |
| f ≠ d.coarse e → compatible f v → f ∈ d.competitors e o v) : | |
| (d.full e o).filter (fun v => d.actualAssignment k U compatible useful keep s v ≠ | |
| some (d.coarse e)) ⊆ | |
| d.full e o \ JointLossCounts.retained (d.passing e o) (d.variableBad k U e o) s := by | |
| intro v hv | |
| obtain ⟨hvfull, hvfail⟩ := Finset.mem_filter.1 hv | |
| apply Finset.mem_sdiff.2 | |
| refine ⟨hvfull, ?_⟩ | |
| intro hvmodel | |
| have hpass := (Finset.mem_filter.1 hvmodel).1 | |
| exact hvfail (d.model_retained_assigned k U hAP N e o ho s hg compatible useful keep v | |
| hvmodel (hc v hpass) (hu v hpass) (hk v hpass) (hcover v hpass)) | |
| theorem good_actual_missingFraction_le (d : OrbitData P E O V) (k : ℕ) | |
| (U : Finset (ZMod (37 ^ k))) | |
| (hAP : ∀ x ∈ U, ∀ y ∈ U, ∀ z ∈ U, x + y = 2 * z → x = z ∧ y = z) | |
| (C₀ N : ℝ) (e : E) (o : O) (ho : o ∈ d.orbits e) (s : Sample P k) | |
| (hg : d.Good k U N e s) | |
| (compatible useful : Triple P → V → Prop) (keep : V → Prop) | |
| (hc : ∀ v ∈ d.passing e o, compatible (d.coarse e) v) | |
| (hu : ∀ v ∈ d.passing e o, useful (d.coarse e) v) | |
| (hk : ∀ v ∈ d.passing e o, keep v) | |
| (hcover : ∀ v ∈ d.passing e o, ∀ f ∈ d.actualTargets, | |
| f ≠ d.coarse e → compatible f v → f ∈ d.competitors e o v) | |
| (hdet : ∀ o ∈ d.orbits e, | |
| JointLossCounts.deterministicLossFraction (d.full e o) (d.passing e o) ≤ C₀ / N) : | |
| (((d.full e o).filter (fun v => d.actualAssignment k U compatible useful keep s v ≠ | |
| some (d.coarse e))).card : ℝ) / ((d.full e o).card : ℝ) ≤ (C₀ + 1) / N := by | |
| have hcard := Finset.card_le_card | |
| (d.actual_failure_subset_model_missing k U hAP N e o ho s hg compatible useful keep hc hu hk hcover) | |
| have hR : (((d.full e o).filter (fun v => d.actualAssignment k U compatible useful keep s v ≠ | |
| some (d.coarse e))).card : ℝ) ≤ | |
| ((d.full e o \ JointLossCounts.retained (d.passing e o) (d.variableBad k U e o) s).card : ℝ) := by | |
| exact_mod_cast hcard | |
| exact (div_le_div_of_nonneg_right hR (Nat.cast_nonneg _)).trans | |
| (d.good_missingFraction_le k U C₀ N e s hg hdet o ho) | |
| end MatrixMultiplication.JointMaskedSelection.OrbitData | |
| end | |
| end OAI | |