openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Counting /CompanionChainValidator.lean
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionArithmeticProposal | |
| import OAI.Combinatorics.ContingencyTables.Sampling.SmallPatternProgram | |
| namespace OAI | |
| /-! # Polynomial validation of paired binary states | |
| The bounded-profile arithmetic test specializes to width one. | |
| Thus the companion's state filter is a concrete list program on the two | |
| coordinates of every labelled pair. | |
| -/ | |
| namespace ContingencyTables.CompanionChainValidator | |
| open CommonBasesFPRAS TwoLiftStates ProfilePrograms | |
| open MatchingFPRAS.TreeTyped | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| variable {P : Type*} [Fintype P] | |
| omit [Fintype P] in | |
| lemma single_iff_occupancy (S : Set (P×Bool)) (p : P) : | |
| PairSingle (pair p) S ↔ occupancy S p=1 := by | |
| unfold PairSingle TwoLiftStates.pair occupancy | |
| by_cases h0 : (p,false)∈S <;> by_cases h1 : (p,true)∈S <;> simp [h0,h1] | |
| omit [Fintype P] in | |
| lemma empty_iff_occupancy (S : Set (P×Bool)) (p : P) : | |
| PairEmpty (pair p) S ↔ occupancy S p=0 := by | |
| unfold PairEmpty TwoLiftStates.pair occupancy | |
| by_cases h0 : (p,false)∈S <;> by_cases h1 : (p,true)∈S <;> simp [h0,h1] | |
| omit [Fintype P] in | |
| lemma full_iff_occupancy (S : Set (P×Bool)) (p : P) : | |
| PairFull (pair p) S ↔ occupancy S p=2 := by | |
| unfold PairFull TwoLiftStates.pair occupancy | |
| by_cases h0 : (p,false)∈S <;> by_cases h1 : (p,true)∈S <;> simp [h0,h1] | |
| lemma plain_iff_occupancy (S : Set (P×Bool)) : | |
| PlainState pairs S ↔ ∀ p,occupancy S p=1 := by | |
| constructor | |
| · intro h p | |
| exact (single_iff_occupancy S p).mp (h (pair p) (pair_mem p)) | |
| · intro h p hp | |
| obtain ⟨q,_,rfl⟩ := List.mem_map.mp hp | |
| exact (single_iff_occupancy S q).mpr (h q) | |
| lemma defect_iff_occupancy (S : Set (P×Bool)) (p q : P) : | |
| DefectState pairs (pair p) (pair q) S ↔ p≠q ∧ | |
| ∀ i,occupancy S i+(if i=p then 1 else 0)=1+(if i=q then 1 else 0) := by | |
| constructor | |
| · intro h | |
| exact ⟨fun he => h.2.2.1 (congrArg pair he),defect_occupancy S p q h⟩ | |
| · rintro ⟨hpq,h⟩ | |
| refine ⟨pair_mem p,pair_mem q,fun he => hpq (pair_injective he),?_,?_,?_⟩ | |
| · apply (empty_iff_occupancy S p).mpr | |
| have hh := h p | |
| simp only [ite_true,hpq,ite_false] at hh | |
| omega | |
| · apply (full_iff_occupancy S q).mpr | |
| have hh := h q | |
| simp only [ite_true,Ne.symm hpq,ite_false,Nat.add_zero] at hh | |
| omega | |
| · intro t ht htp htq | |
| obtain ⟨i,_,rfl⟩ := List.mem_map.mp ht | |
| apply (single_iff_occupancy S i).mpr | |
| have hip : i≠p := fun he => htp (congrArg pair he) | |
| have hiq : i≠q := fun he => htq (congrArg pair he) | |
| simpa only [hip,hiq,ite_false,Nat.add_zero] using h i | |
| lemma chain_iff_occupancy (S : Set (P×Bool)) : | |
| ChainState pairs S ↔ (∀ i,occupancy S i=1) ∨ | |
| ∃ p q : P,p≠q ∧ ∀ i,occupancy S i+(if i=p then 1 else 0)=1+(if i=q then 1 else 0) := by | |
| constructor | |
| · rintro (h|⟨p,q,h⟩) | |
| · exact Or.inl ((plain_iff_occupancy S).mp h) | |
| · obtain ⟨a,_,rfl⟩ := List.mem_map.mp h.1 | |
| obtain ⟨b,_,rfl⟩ := List.mem_map.mp h.2.1 | |
| exact Or.inr ⟨a,b,(defect_iff_occupancy S a b).mp h⟩ | |
| · rintro (h|⟨p,q,h⟩) | |
| · exact Or.inl ((plain_iff_occupancy S).mpr h) | |
| · exact Or.inr ⟨pair p,pair q,(defect_iff_occupancy S p q).mpr h⟩ | |
| /-- Width one is exactly the companion's labelled paired-state test. -/ | |
| theorem paired_pattern_iff {m : ℕ} (e : Fin m ≃ P) (S : Set (P×Bool)) : | |
| patternTest ((List.ofFn (fun i => if (e i,false)∈S then 1 else 0), | |
| List.ofFn (fun i => if (e i,true)∈S then 1 else 0)),1)=true ↔ ChainState pairs S := by | |
| rw [patternTest_ofFn,chain_iff_occupancy] | |
| change (∀ i,occupancy S (e i)=1) ∨ | |
| (∃ p q : Fin m,p≠q ∧ ∀ i,occupancy S (e i)+(if i=p then 1 else 0)= | |
| 1+(if i=q then 1 else 0)) ↔ _ | |
| constructor | |
| · rintro (h|⟨p,q,hpq,h⟩) | |
| · exact Or.inl (fun i => by simpa using h (e.symm i)) | |
| · refine Or.inr ⟨e p,e q,fun he => hpq (e.injective he),?_⟩ | |
| intro i | |
| simpa only [Equiv.apply_symm_apply,e.symm_apply_eq] using h (e.symm i) | |
| · rintro (h|⟨p,q,hpq,h⟩) | |
| · exact Or.inl (fun i => h (e i)) | |
| · refine Or.inr ⟨e.symm p,e.symm q,fun he => hpq (e.symm.injective he),?_⟩ | |
| intro i | |
| simpa only [←e.eq_symm_apply] using h (e i) | |
| end | |
| abbrev ValidatorInput := List (ℕ×ℕ)×List ℕ | |
| def pairFirstLookup : Realizer (fun z : List ℕ×(ℕ×ℕ) => z.1.getD z.2.1 0) := | |
| composition (pair first (composition second first)) (getDFast 0) | |
| def pairSecondLookup : Realizer (fun z : List ℕ×(ℕ×ℕ) => z.1.getD z.2.2 0) := | |
| composition (pair first (composition second second)) (getDFast 0) | |
| lemma polynomial_pairFirstLookup : PolynomialTime pairFirstLookup := | |
| polynomial_composition (polynomial_pair polynomial_first | |
| (polynomial_composition polynomial_second polynomial_first)) (polynomial_getDFast 0) | |
| lemma polynomial_pairSecondLookup : PolynomialTime pairSecondLookup := | |
| polynomial_composition (polynomial_pair polynomial_first | |
| (polynomial_composition polynomial_second polynomial_second)) (polynomial_getDFast 0) | |
| def pairedStateTest (z : ValidatorInput) : Bool := | |
| patternTest (((z.1.map (fun ij => z.2.getD ij.1 0)), | |
| (z.1.map (fun ij => z.2.getD ij.2 0))),1) | |
| def pairedStateTestRealizer : Realizer pairedStateTest := | |
| composition (pair (pair | |
| (composition (pair second first) (mapWith pairFirstLookup)) | |
| (composition (pair second first) (mapWith pairSecondLookup))) (constant 1)) patternTestRealizer | |
| theorem polynomial_pairedStateTest : PolynomialTime pairedStateTestRealizer := | |
| polynomial_composition (polynomial_pair (polynomial_pair | |
| (polynomial_composition (polynomial_pair polynomial_second polynomial_first) | |
| (polynomial_mapWith polynomial_pairFirstLookup)) | |
| (polynomial_composition (polynomial_pair polynomial_second polynomial_first) | |
| (polynomial_mapWith polynomial_pairSecondLookup))) (polynomial_constant 1)) polynomial_patternTest | |
| noncomputable section | |
| open CompanionFactorialApplication CompanionArithmeticProposal | |
| variable {I J : Type} [Fintype I] [Fintype J] | |
| def labelEquiv (A : Instance I J) : Fin (Fintype.card (Labels A)) ≃ Labels A := | |
| (Fintype.equivFin _).symm | |
| def pairCatalog (A : Instance I J) : List (ℕ×ℕ) := | |
| List.ofFn (fun i => ((coordinateEquiv A (labelEquiv A i,false)).val, | |
| (coordinateEquiv A (labelEquiv A i,true)).val)) | |
| /-- This list program checks the literal companion state, with no | |
| feasibility oracle or whole-state enumeration. -/ | |
| theorem pairedStateTest_encode (A : Instance I J) (S : Set (Labels A×Bool)) : | |
| pairedStateTest (pairCatalog A,encodeSet (coordinateEquiv A) S)=true ↔ ChainState pairs S := by | |
| unfold pairedStateTest pairCatalog | |
| simp only [List.map_ofFn] | |
| change patternTest ((List.ofFn (fun i : Fin (Fintype.card (Labels A)) => | |
| (encodeSet (coordinateEquiv A) S).getD | |
| (coordinateEquiv A (labelEquiv A i,false)).val 0), | |
| List.ofFn (fun i : Fin (Fintype.card (Labels A)) => | |
| (encodeSet (coordinateEquiv A) S).getD | |
| (coordinateEquiv A (labelEquiv A i,true)).val 0)),1)=true ↔ _ | |
| simp only [encodeSet,getD_setProfile,setProfile,coordinateSet,Set.mem_preimage, | |
| Equiv.symm_apply_apply] | |
| exact paired_pattern_iff (labelEquiv A) S | |
| end | |
| end ContingencyTables.CompanionChainValidator | |
| end OAI | |