openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Repetition /CleanCountingLemmas.lean
| import OAI.Computability.PerfectCompleteness.Construction.FactoredFunctionsLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.CanonicalKeys | |
| import OAI.Computability.PerfectCompleteness.Foundations.ClauseSupportLemmas | |
| import OAI.Computability.PerfectCompleteness.Foundations.QuotientTableAgreementLemmas | |
| import OAI.Computability.PerfectCompleteness.Repetition.CleanConditioning | |
| namespace OAI | |
| namespace PerfectCompleteness.CleanCounting | |
| open scoped BigOperators | |
| open UniqueGamesTheorem.Foundations.Games | |
| open FiniteProduct CleanConditioning | |
| noncomputable section | |
| theorem expectation_event_factor {A : Type*} [Fintype A] | |
| (μ : FiniteDistribution A) (event : A → Bool) (a : ℝ) : | |
| μ.expectation (fun x => if event x then a else 1) = | |
| 1 - (1 - a) * μ.probability event := by | |
| have hpoint (x : A) : μ.weight x * (if event x then a else 1) = | |
| μ.weight x - (1 - a) * (if event x then μ.weight x else 0) := by | |
| cases event x <;> simp | |
| ring | |
| change (∑ x, μ.weight x * (if event x then a else 1)) = _ | |
| simp_rw [hpoint] | |
| rw [Finset.sum_sub_distrib, ← Finset.mul_sum, μ.normalized] | |
| rfl | |
| variable {I : Type*} [Fintype I] [DecidableEq I] | |
| {Ω : I → Type*} [∀ i, Fintype (Ω i)] | |
| def cleanCount (clean : (i : I) → Ω i → Bool) (x : (i : I) → Ω i) : Nat := | |
| (Finset.univ.filter fun i => clean i (x i) = true).card | |
| omit [DecidableEq I] [∀ i, Fintype (Ω i)] in | |
| theorem power_cleanCount (clean : (i : I) → Ω i → Bool) | |
| (x : (i : I) → Ω i) (a : ℝ) : | |
| a ^ cleanCount clean x = ∏ i, if clean i (x i) = true then a else 1 := by | |
| rw [← Finset.prod_filter] | |
| simp [cleanCount] | |
| theorem cleanCount_moment (P : (i : I) → FiniteDistribution (Ω i)) | |
| (clean : (i : I) → Ω i → Bool) (a : ℝ) : | |
| (law P).expectation (fun x => a ^ cleanCount clean x) = | |
| ∏ i : I, (1 - (1 - a) * (P i).probability (clean i)) := by | |
| calc | |
| _ = (law P).expectation (fun x => ∏ i : I, if clean i (x i) then a else 1) := | |
| FiniteDistribution.expectation_congr _ | |
| (fun x => power_cleanCount (I := I) (Ω := Ω) clean x a) | |
| _ = ∏ i : I, (P i).expectation (fun x => if clean i x then a else 1) := | |
| expectation_product (I := I) (Ω := Ω) P | |
| (fun (i : I) (x : Ω i) => if clean i x then a else 1) | |
| _ = _ := by | |
| apply Finset.prod_congr rfl | |
| intro i _ | |
| exact expectation_event_factor (P i) (clean i) a | |
| theorem cleanCount_moment_le (P : (i : I) → FiniteDistribution (Ω i)) | |
| (clean : (i : I) → Ω i → Bool) (a p₀ : ℝ) | |
| (ha : 0 ≤ a) (ha' : a ≤ 1) | |
| (lower : ∀ i, p₀ ≤ (P i).probability (clean i)) : | |
| (law P).expectation (fun x => a ^ cleanCount clean x) ≤ | |
| (1 - (1 - a) * p₀) ^ Fintype.card I := by | |
| rw [cleanCount_moment] | |
| calc | |
| _ ≤ ∏ _i : I, (1 - (1 - a) * p₀) := by | |
| apply Finset.prod_le_prod₀ | |
| · intro i _ | |
| have h := mul_le_mul_of_nonneg_left ((P i).probability_le_one (clean i)) | |
| (sub_nonneg.mpr ha') | |
| nlinarith | |
| · intro i _ | |
| have h := mul_le_mul_of_nonneg_left (lower i) (sub_nonneg.mpr ha') | |
| linarith | |
| _ = _ := by simp | |
| variable {E R T : I → Type*} | |
| [∀ i, Fintype (E i)] [∀ i, Fintype (R i)] [∀ i, Fintype (T i)] | |
| omit [Fintype I] [DecidableEq I] in | |
| theorem kernel_clean_probability | |
| (μ : (i : I) → FiniteDistribution (E i)) | |
| (ν : (i : I) → FiniteDistribution (R i)) | |
| (kernel : (i : I) → E i → R i → FiniteDistribution (T i)) | |
| (clean : (i : I) → E i → R i → T i → Bool) (p : I → ℝ) | |
| (constant : ∀ i e r, (kernel i e r).probability (clean i e r) = p i) (i : I) : | |
| (kernelJoint (μ i) (fun e => kernelJoint (ν i) (kernel i e))).probability | |
| (fun x => clean i x.1 x.2.1 x.2.2) = p i := by | |
| apply probability_kernelJoint_constant (μ i) _ _ (p i) | |
| intro e | |
| apply probability_kernelJoint_constant (ν i) _ _ (p i) | |
| intro r | |
| exact constant i e r | |
| theorem kernel_cleanCount_moment | |
| (μ : (i : I) → FiniteDistribution (E i)) | |
| (ν : (i : I) → FiniteDistribution (R i)) | |
| (kernel : (i : I) → E i → R i → FiniteDistribution (T i)) | |
| (clean : (i : I) → E i → R i → T i → Bool) (p : I → ℝ) | |
| (constant : ∀ i e r, (kernel i e r).probability (clean i e r) = p i) (a : ℝ) : | |
| (law (fun i => kernelJoint (μ i) (fun e => kernelJoint (ν i) (kernel i e)))).expectation | |
| (fun x => a ^ cleanCount (I := I) (Ω := fun i => E i × (R i × T i)) | |
| (fun i y => clean i y.1 y.2.1 y.2.2) x) = | |
| ∏ i : I, (1 - (1 - a) * p i) := by | |
| rw [cleanCount_moment] | |
| simp only [kernel_clean_probability μ ν kernel clean p constant] | |
| end | |
| end PerfectCompleteness.CleanCounting | |
| section | |
| namespace PerfectCompleteness.MixedSupport | |
| open ClauseSupport | |
| variable {C Y : Type*} | |
| theorem localKey_unused (s : Slot) (f : C → s.Domain → Y) (unused : Unused f) : | |
| localKey s f = .dropped := by | |
| classical | |
| cases s with | |
| | clause occurrence variableIDs signs => | |
| change clauseKey occurrence variableIDs f = .dropped | |
| simp only [clauseKey, clauseMode_unused f unused] | |
| | bit variableID => | |
| change (if Unused f then SlotKey.dropped else SlotKey.bit variableID) = SlotKey.dropped | |
| exact ite_eq_left unused | |
| theorem localReduction_unused (s : Slot) (f : C → s.Domain → Y) | |
| (unused : Unused f) (u : s.Domain) : localReduction s f u = .dropped := by | |
| classical | |
| cases s with | |
| | clause occurrence variableIDs signs => | |
| change clauseReduction f u = .dropped | |
| simp only [clauseReduction, clauseMode_unused f unused, reduceByMode] | |
| | bit variableID => | |
| change (if Unused f then ReducedValue.dropped else ReducedValue.bit u) = ReducedValue.dropped | |
| exact ite_eq_left unused | |
| end PerfectCompleteness.MixedSupport | |
| namespace PerfectCompleteness.CleanKeyErasure | |
| open ClauseSupport MixedSupport FactoredFunctions | |
| variable {I Y : Type*} [DecidableEq I] | |
| abbrev Retained (slots : I → Slot) (keep : I → Prop) := | |
| (i : {i : I // keep i}) → (slots i.val).Domain | |
| def retain (slots : I → Slot) (keep : I → Prop) : | |
| Assignment slots → Retained slots keep := fun x i => x i.val | |
| theorem retain_update_of_not_kept (slots : I → Slot) (keep : I → Prop) | |
| (x : Assignment slots) (i : I) (not_kept : ¬ keep i) (u : (slots i).Domain) : | |
| retain slots keep (Function.update x i u) = retain slots keep x := by | |
| funext j | |
| have hji : j.val ≠ i := by | |
| intro h | |
| exact not_kept (h ▸ j.property) | |
| simp only [retain, Function.update_of_ne hji] | |
| theorem section_unused_of_retained (slots : I → Slot) (keep : I → Prop) | |
| (f : Assignment slots → Y) | |
| (constant : ∀ x y, retain slots keep x = retain slots keep y → f x = f y) | |
| (i : I) (not_kept : ¬ keep i) : Unused (sectionFunction slots f i) := by | |
| intro context u v | |
| apply constant | |
| exact (retain_update_of_not_kept slots keep context i not_kept u).trans | |
| (retain_update_of_not_kept slots keep context i not_kept v).symm | |
| theorem section_unused_of_factor (slots : I → Slot) (keep : I → Prop) | |
| (f : Retained slots keep → Y) (i : I) (not_kept : ¬ keep i) : | |
| Unused (sectionFunction slots (f ∘ retain slots keep) i) := by | |
| apply section_unused_of_retained slots keep (f ∘ retain slots keep) | |
| (fun x y h => congrArg f h) i not_kept | |
| theorem keyFields_dropped_of_retained (slots : I → Slot) (keep : I → Prop) | |
| (f : Assignment slots → Y) | |
| (constant : ∀ x y, retain slots keep x = retain slots keep y → f x = f y) | |
| (i : I) (not_kept : ¬ keep i) : keyFields slots f i = .dropped := | |
| localKey_unused (slots i) (sectionFunction slots f i) | |
| (section_unused_of_retained slots keep f constant i not_kept) | |
| theorem reduction_dropped_of_retained (slots : I → Slot) (keep : I → Prop) | |
| (f : Assignment slots → Y) | |
| (constant : ∀ x y, retain slots keep x = retain slots keep y → f x = f y) | |
| (i : I) (not_kept : ¬ keep i) (x : Assignment slots) : | |
| reduction slots f x i = .dropped := | |
| localReduction_unused (slots i) (sectionFunction slots f i) | |
| (section_unused_of_retained slots keep f constant i not_kept) (x i) | |
| section Scalar | |
| variable {𝕜 : Type*} [Field 𝕜] | |
| theorem section_unused_of_factoring (slots : I → Slot) (keep : I → Prop) | |
| (f : Assignment slots → 𝕜) (factors : f ∈ factoringSpace (retain slots keep)) | |
| (i : I) (not_kept : ¬ keep i) : Unused (sectionFunction slots f i) := | |
| section_unused_of_retained slots keep f factors i not_kept | |
| theorem keyFields_dropped_of_factoring (slots : I → Slot) (keep : I → Prop) | |
| (f : Assignment slots → 𝕜) (factors : f ∈ factoringSpace (retain slots keep)) | |
| (i : I) (not_kept : ¬ keep i) : keyFields slots f i = .dropped := | |
| keyFields_dropped_of_retained slots keep f factors i not_kept | |
| theorem reduction_dropped_of_factoring (slots : I → Slot) (keep : I → Prop) | |
| (f : Assignment slots → 𝕜) (factors : f ∈ factoringSpace (retain slots keep)) | |
| (i : I) (not_kept : ¬ keep i) (x : Assignment slots) : | |
| reduction slots f x i = .dropped := | |
| reduction_dropped_of_retained slots keep f factors i not_kept x | |
| end Scalar | |
| variable {n : Nat} | |
| theorem retainedKeys_only_kept (slots : Fin n → Slot) (keep : Fin n → Prop) | |
| (f : Assignment slots → Y) | |
| (constant : ∀ x y, retain slots keep x = retain slots keep y → f x = f y) | |
| (entry : Fin n × SlotKey) (present : entry ∈ retainedKeys slots f) : keep entry.1 := by | |
| classical | |
| unfold retainedKeys at present | |
| obtain ⟨in_map, not_dropped⟩ := List.mem_filter.mp present | |
| obtain ⟨i, _, rfl⟩ := List.mem_map.mp in_map | |
| by_contra not_kept | |
| exact (of_decide_eq_true not_dropped) | |
| (keyFields_dropped_of_retained slots keep f constant i not_kept) | |
| theorem not_mem_retainedKeys_of_not_kept (slots : Fin n → Slot) (keep : Fin n → Prop) | |
| (f : Assignment slots → Y) | |
| (constant : ∀ x y, retain slots keep x = retain slots keep y → f x = f y) | |
| (i : Fin n) (not_kept : ¬ keep i) (metadata : SlotKey) : | |
| (i, metadata) ∉ retainedKeys slots f := by | |
| intro present | |
| exact not_kept (retainedKeys_only_kept slots keep f constant (i, metadata) present) | |
| theorem keyFields_const (slots : Fin n → Slot) (value : Y) (i : Fin n) : | |
| keyFields slots (fun _ => value) i = .dropped := | |
| localKey_unused (slots i) (sectionFunction slots (fun _ => value) i) | |
| (fun _ _ _ => rfl) | |
| theorem retainedKeys_const (slots : Fin n → Slot) (value : Y) : | |
| retainedKeys slots (fun _ => value) = [] := by | |
| apply List.eq_nil_iff_forall_not_mem.mpr | |
| intro entry present | |
| exact retainedKeys_only_kept slots (fun _ => False) (fun _ => value) | |
| (fun _ _ _ => rfl) entry present | |
| end PerfectCompleteness.CleanKeyErasure | |
| end | |
| namespace PerfectCompleteness.CleanKeyFactorization | |
| open ClauseSupport MixedSupport CanonicalKeys CleanKeyErasure | |
| open scoped Classical | |
| noncomputable section | |
| variable {I Y : Type*} [DecidableEq I] | |
| abbrev retainedSlots (slots : I → Slot) (keep : I → Prop) : {i : I // keep i} → Slot := | |
| fun i => slots i.val | |
| def fill (slots : I → Slot) (keep : I → Prop) | |
| (x : Assignment (retainedSlots slots keep)) : Assignment slots := | |
| fun i => if h : keep i then x ⟨i, h⟩ else Classical.choice (inferInstance : Nonempty (slots i).Domain) | |
| omit [DecidableEq I] in | |
| theorem retain_fill (slots : I → Slot) (keep : I → Prop) | |
| (x : Assignment (retainedSlots slots keep)) : retain slots keep (fill slots keep x) = x := by | |
| funext i | |
| simp only [retain, fill, dite_eq_left i.property] | |
| omit [DecidableEq I] in | |
| theorem retain_surjective (slots : I → Slot) (keep : I → Prop) : | |
| Function.Surjective (retain slots keep) := | |
| fun x => ⟨fill slots keep x, retain_fill slots keep x⟩ | |
| theorem retain_update (slots : I → Slot) (keep : I → Prop) | |
| (x : Assignment slots) (i : {i : I // keep i}) (u : (slots i.val).Domain) : | |
| retain slots keep (Function.update x i.val u) = | |
| Function.update (retain slots keep x) i u := | |
| Function.update_comp_eq_of_injective' x Subtype.val_injective i u | |
| theorem sectionFunction_factor (slots : I → Slot) (keep : I → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) (i : {i : I // keep i}) : | |
| sectionFunction slots (g ∘ retain slots keep) i.val = | |
| pull (sectionFunction (retainedSlots slots keep) g i) (retain slots keep) id := by | |
| funext context u | |
| change g (retain slots keep (Function.update context i.val u)) = | |
| g (Function.update (retain slots keep context) i u) | |
| rw [retain_update] | |
| theorem keyFields_kept (slots : I → Slot) (keep : I → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) (i : {i : I // keep i}) : | |
| keyFields slots (g ∘ retain slots keep) i.val = | |
| keyFields (retainedSlots slots keep) g i := by | |
| change localKey (slots i.val) (sectionFunction slots (g ∘ retain slots keep) i.val) = _ | |
| rw [sectionFunction_factor] | |
| exact localKey_projection (Projection.keep (slots i.val)) | |
| (sectionFunction (retainedSlots slots keep) g i) | |
| (retain slots keep) (retain_surjective slots keep) | |
| theorem reduction_kept (slots : I → Slot) (keep : I → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) (i : {i : I // keep i}) | |
| (x : Assignment slots) : | |
| reduction slots (g ∘ retain slots keep) x i.val = | |
| reduction (retainedSlots slots keep) g (retain slots keep x) i := by | |
| change localReduction (slots i.val) | |
| (sectionFunction slots (g ∘ retain slots keep) i.val) (x i.val) = _ | |
| rw [sectionFunction_factor] | |
| exact localReduction_projection (Projection.keep (slots i.val)) | |
| (sectionFunction (retainedSlots slots keep) g i) | |
| (retain slots keep) (retain_surjective slots keep) (x i.val) | |
| def embeddedFields (keep : I → Prop) (slots : {i : I // keep i} → Slot) | |
| (g : Assignment slots → Y) (i : I) : SlotKey := | |
| if h : keep i then keyFields slots g ⟨i, h⟩ else .dropped | |
| def embeddedReduction (keep : I → Prop) (slots : {i : I // keep i} → Slot) | |
| (g : Assignment slots → Y) (x : Assignment slots) (i : I) : ReducedValue := | |
| if h : keep i then reduction slots g x ⟨i, h⟩ else .dropped | |
| theorem keyFields_factor (slots : I → Slot) (keep : I → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) : | |
| keyFields slots (g ∘ retain slots keep) = embeddedFields keep (retainedSlots slots keep) g := by | |
| funext i | |
| by_cases hi : keep i | |
| · simpa only [embeddedFields, dite_eq_left hi] using keyFields_kept slots keep g ⟨i, hi⟩ | |
| · rw [embeddedFields, dite_eq_right hi] | |
| exact keyFields_dropped_of_retained slots keep (g ∘ retain slots keep) | |
| (fun x y h => congrArg g h) i hi | |
| theorem reduction_factor (slots : I → Slot) (keep : I → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) (x : Assignment slots) : | |
| reduction slots (g ∘ retain slots keep) x = | |
| embeddedReduction keep (retainedSlots slots keep) g (retain slots keep x) := by | |
| funext i | |
| by_cases hi : keep i | |
| · simpa only [embeddedReduction, dite_eq_left hi] using reduction_kept slots keep g ⟨i, hi⟩ x | |
| · rw [embeddedReduction, dite_eq_right hi] | |
| exact reduction_dropped_of_retained slots keep (g ∘ retain slots keep) | |
| (fun x y h => congrArg g h) i hi x | |
| theorem embeddedReduction_constant [Finite I] | |
| (keep : I → Prop) (slots : {i : I // keep i} → Slot) (g : Assignment slots → Y) : | |
| ReducedPartition.ConstantOnFibers (embeddedReduction keep slots g) g := by | |
| intro x y h | |
| apply constant_on_reduction_fibers slots g | |
| funext i | |
| have hi := congrFun h i.val | |
| simpa only [embeddedReduction, dite_eq_left i.property] using hi | |
| variable {n : Nat} | |
| def retainedMetadata (keep : Fin n → Prop) (slots : {i : Fin n // keep i} → Slot) | |
| (g : Assignment slots → Y) : List (Fin n × SlotKey) := | |
| ((List.finRange n).map (fun i => (i, embeddedFields keep slots g i))).filter | |
| (fun entry => decide (entry.2 ≠ .dropped)) | |
| def retainedKey (side : Side) (keep : Fin n → Prop) | |
| (slots : {i : Fin n // keep i} → Slot) (g : Assignment slots → Y) : Key n where | |
| side := side | |
| retained := retainedMetadata keep slots g | |
| partition := ReducedPartition.parts (embeddedReduction keep slots g) g | |
| theorem retainedKeys_factor (slots : Fin n → Slot) (keep : Fin n → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) : | |
| retainedKeys slots (g ∘ retain slots keep) = | |
| retainedMetadata keep (retainedSlots slots keep) g := by | |
| simp only [retainedKeys, retainedMetadata, keyFields_factor] | |
| theorem partition_factor (slots : Fin n → Slot) (keep : Fin n → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) : | |
| CanonicalKeys.partition slots (g ∘ retain slots keep) = | |
| ReducedPartition.parts (embeddedReduction keep (retainedSlots slots keep) g) g := | |
| ReducedPartition.parts_eq_of_pullback (retain slots keep) (retain_surjective slots keep) | |
| (reduction slots (g ∘ retain slots keep)) | |
| (embeddedReduction keep (retainedSlots slots keep) g) | |
| (g ∘ retain slots keep) g (reduction_factor slots keep g) (fun _ => rfl) | |
| theorem key_factor (side : Side) (slots : Fin n → Slot) (keep : Fin n → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) : | |
| key side slots (g ∘ retain slots keep) = | |
| retainedKey side keep (retainedSlots slots keep) g := by | |
| simp only [key, retainedKey, retainedKeys_factor, partition_factor] | |
| theorem retainedKey_nonempty (side : Side) (keep : Fin n → Prop) | |
| (slots : {i : Fin n // keep i} → Slot) (g : Assignment slots → Y) : | |
| (retainedKey side keep slots g).partition.Nonempty := by | |
| obtain ⟨x⟩ := (inferInstance : Nonempty (Assignment slots)) | |
| exact ⟨ReducedPartition.fiber (embeddedReduction keep slots g) g x, ⟨x, rfl⟩⟩ | |
| def retainedQueryKey (side : Side) (keep : Fin n → Prop) | |
| (slots : {i : Fin n // keep i} → Slot) (g : Assignment slots → Y) : | |
| KeyStrategy.NonemptyKey n := | |
| ⟨retainedKey side keep slots g, retainedKey_nonempty side keep slots g⟩ | |
| theorem queryKey_factor (side : Side) (slots : Fin n → Slot) (keep : Fin n → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) : | |
| KeyStrategy.queryKey side slots (g ∘ retain slots keep) = | |
| retainedQueryKey side keep (retainedSlots slots keep) g := by | |
| apply Subtype.ext | |
| exact key_factor side slots keep g | |
| theorem label_factor (labeling : KeyStrategy.Strategy n) (side : Side) | |
| (slots : Fin n → Slot) (keep : Fin n → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) : | |
| (KeyStrategy.label labeling side slots (g ∘ retain slots keep)).val = | |
| (labeling (retainedQueryKey side keep (retainedSlots slots keep) g)).val := | |
| congrArg (fun k : KeyStrategy.NonemptyKey n => (labeling k).val) | |
| (queryKey_factor side slots keep g) | |
| def retainedResponse (labeling : KeyStrategy.Strategy n) (side : Side) | |
| (keep : Fin n → Prop) (slots : {i : Fin n // keep i} → Slot) | |
| (g : Assignment slots → Y) : Y := | |
| ReducedPartition.output (embeddedReduction keep slots g) g | |
| (labeling (retainedQueryKey side keep slots g)) | |
| theorem response_factor (labeling : KeyStrategy.Strategy n) (side : Side) | |
| (slots : Fin n → Slot) (keep : Fin n → Prop) | |
| (g : Assignment (retainedSlots slots keep) → Y) : | |
| KeyStrategy.response labeling side slots (g ∘ retain slots keep) = | |
| retainedResponse labeling side keep (retainedSlots slots keep) g := | |
| ReducedPartition.output_eq_of_shared_part (retain slots keep) | |
| (reduction slots (g ∘ retain slots keep)) | |
| (embeddedReduction keep (retainedSlots slots keep) g) | |
| (g ∘ retain slots keep) g (reduction_factor slots keep g) (fun _ => rfl) | |
| (embeddedReduction_constant keep (retainedSlots slots keep) g) | |
| (KeyStrategy.label labeling side slots (g ∘ retain slots keep)) | |
| (labeling (retainedQueryKey side keep (retainedSlots slots keep) g)) | |
| (label_factor labeling side slots keep g) | |
| end | |
| end PerfectCompleteness.CleanKeyFactorization | |
| end OAI | |