openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Counting /CompanionCanonicalHistory.lean
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionPhaseFinishSemantics | |
| import OAI.Combinatorics.ContingencyTables.Rooted.RootedRestartAgreement | |
| import OAI.Combinatorics.ContingencyTables.Rooted.RootedPhaseHistory | |
| namespace OAI | |
| /-! # Canonical multiplier entries determine the projected phase history | |
| The extension uses only the first label of a raw coordinate pair. Its values | |
| away from canonical pairs need not match the original multiplier. | |
| -/ | |
| namespace ContingencyTables.CompanionCanonicalHistory | |
| open CompanionFactorialApplication CompanionRationalUpdates CompanionMultiplierAgreement | |
| open CommonBasesFPRAS TwoLiftStates GridBoundary | |
| open CompanionPhaseWords (Stored phaseBits) | |
| open scoped Classical | |
| noncomputable section | |
| variable {I J : Type} [Fintype I] [Fintype J] | |
| variable (A : Instance I J) {p : ℕ} (g : Fin p ≃ Labels A) | |
| abbrev Canonical := (Fin p→Fin p→ℚ)×ℚ | |
| def project (s : Stored A) : Canonical (p := p) := | |
| CompanionPhaseFinishProgram.storedView A g s | |
| def extend (s : Canonical (p := p)) : Stored A := | |
| ⟨(fun a b => s.1 (g.symm a.1.1) (g.symm b.1.1)),s.2⟩ | |
| @[simp] theorem project_extend (s : Canonical (p := p)) : | |
| project A g (extend A g s)=s := by | |
| apply Prod.ext | |
| · funext i j | |
| simp only [project,extend,CompanionPhaseFinishProgram.storedView,pair,Equiv.symm_apply_apply] | |
| · rfl | |
| theorem project_eq_iff (s t : Stored A) : | |
| project A g s=project A g t ↔ Agree A s.multiplier t.multiplier ∧ s.estimate=t.estimate := by | |
| constructor | |
| · intro h | |
| constructor | |
| · intro a b | |
| have he := congrFun (congrFun (congrArg Prod.fst h) (g.symm a)) (g.symm b) | |
| simpa only [project,CompanionPhaseFinishProgram.storedView,Equiv.apply_symm_apply] using he | |
| · exact congrArg Prod.snd h | |
| · rintro ⟨hw,he⟩ | |
| apply Prod.ext | |
| · funext i j | |
| exact hw (g i) (g j) | |
| · exact he | |
| theorem extend_project_agree (s : Stored A) : | |
| Agree A (extend A g (project A g s)).multiplier s.multiplier := by | |
| intro a b | |
| simp only [extend,project,CompanionPhaseFinishProgram.storedView,pair,Equiv.apply_symm_apply] | |
| theorem learn_agree (w w' : Pair A→Pair A→ℚ) (hw : Agree A w w') | |
| (states : List (Set (Labels A×Bool))) : | |
| Agree A (rationalLearn pairs w states) (rationalLearn pairs w' states) := by | |
| intro a b | |
| by_cases h : pair a∈(pairs : List (Pair A)) ∧ pair b∈(pairs : List (Pair A)) ∧ pair a≠pair b | |
| · simp only [rationalLearn,h,hw a b] | |
| · simp only [rationalLearn,h,ite_false,hw a b] | |
| theorem update_project_eq (R : RootedCompletion.Selection A.T) (C K j N : ℕ) | |
| (hK : 1 ≤ K) (hW : 100*A.d*K ≤ A.W) (xi : ℚ) | |
| (v : Grid (I := Fin (CompanionOracleDensity.dimension A)) K) | |
| (s t : Stored A) (h : project A g s=project A g t) | |
| (states : Fin N→Set (Labels A×Bool)) (bits : Fin (phaseBits A C K j N xi)→Bool) : | |
| (RootedPhaseWords.update A R C K j N hK hW xi v s states bits).map (project A g)= | |
| (RootedPhaseWords.update A R C K j N hK hW xi v t states bits).map (project A g) := by | |
| obtain ⟨hw,he⟩ := (project_eq_iff A g s t).mp h | |
| unfold RootedPhaseWords.update | |
| split_ifs | |
| · simp only [Option.map_some] | |
| apply congrArg Option.some | |
| apply (project_eq_iff A g _ _).mpr | |
| exact ⟨learn_agree A s.multiplier t.multiplier hw _,congrArg (fun e => e*_) he⟩ | |
| · rfl | |
| theorem trial_project_eq (R : RootedCompletion.Selection A.T) (C K j k N : ℕ) | |
| (hK : 1 ≤ K) (hW : 100*A.d*K ≤ A.W) (xi : ℚ) | |
| (v : Grid (I := Fin (CompanionOracleDensity.dimension A)) K) | |
| (s t : Stored A) (h : project A g s=project A g t) | |
| (S : CompanionBooleanPhase.State A) (bits : RootedPhaseTrial.TrialWords A C K j k N xi) : | |
| (RootedPhaseTrial.trial A R C K j k N hK hW xi v s S bits).map (project A g)= | |
| (RootedPhaseTrial.trial A R C K j k N hK hW xi v t S bits).map (project A g) := by | |
| have hw := ((project_eq_iff A g s t).mp h).1 | |
| unfold RootedPhaseTrial.trial | |
| rw [observedStates_eq A R C K j k N hK hW xi v s.multiplier t.multiplier hw] | |
| exact update_project_eq A g R C K j (N+1) hK hW xi v s t h _ _ | |
| theorem restart_project_eq (R : RootedCompletion.Selection A.T) | |
| (C K H L j k n N h : ℕ) (hK : 1 ≤ K) (hW : 100*A.d*K ≤ A.W) (xi : ℚ) | |
| (v : Grid (I := Fin (CompanionOracleDensity.dimension A)) K) | |
| (w w' : ℕ→Pair A→Pair A→ℚ) (e e' : ℚ) | |
| (hw : ∀ i,i ≤ j → Agree A (w i) (w' i)) (he : e=e') | |
| (bits : RootedRestartTrial.Words A C K H L j k n N h xi) : | |
| (RootedRestartTrial.run A R C K H L j k n N h hK hW xi v w e bits).map (project A g)= | |
| (RootedRestartTrial.run A R C K H L j k n N h hK hW xi v w' e' bits).map (project A g) := by | |
| have hi := RootedRestartWords.initializedStages_agree A R C K H L k n h j hK hW xi v w w' | |
| (fun i hi => hw (i+1) (by omega)) bits.1 | |
| unfold RootedRestartTrial.run | |
| rw [hi] | |
| exact trial_project_eq A g R C K j k N hK hW xi v ⟨w j,e⟩ ⟨w' j,e'⟩ | |
| ((project_eq_iff A g _ _).mpr ⟨hw j le_rfl,he⟩) _ _ | |
| theorem lookup_project_eq (history history' : List (Stored A)) | |
| (h : history.map (project A g)=history'.map (project A g)) (i : ℕ) : | |
| project A g (RootedStoredHistory.lookup A history i)= | |
| project A g (RootedStoredHistory.lookup A history' i) := by | |
| cases i with | |
| | zero => rfl | |
| | succ i => | |
| have he := congrArg (fun xs : List (Canonical (p := p)) => | |
| xs.getD i (project A g (RootedStoredEstimate.initialStored A))) h | |
| simpa only [RootedStoredHistory.lookup,List.getD_map] using he | |
| private theorem project_getD (a b : Option (Stored A)) (s t : Stored A) | |
| (h : a.map (project A g)=b.map (project A g)) (he : project A g s=project A g t) : | |
| project A g (a.getD s)=project A g (b.getD t) := by | |
| cases a <;> cases b <;> simp_all | |
| theorem step_project_eq (R : RootedCompletion.Selection A.T) (s : RootedPhaseHistory.Settings A) | |
| (history history' : List (Stored A)) | |
| (hh : history.map (project A g)=history'.map (project A g)) (bits : RootedPhaseHistory.Word A s) : | |
| project A g (RootedPhaseHistory.step A R s history bits)= | |
| project A g (RootedPhaseHistory.step A R s history' bits) := by | |
| have hlen : history.length=history'.length := by | |
| simpa only [List.length_map] using congrArg List.length hh | |
| have hold := lookup_project_eq A g history history' hh history'.length | |
| dsimp only [RootedPhaseHistory.step] | |
| rw [hlen] | |
| split_ifs with hj | |
| · apply project_getD A g _ _ _ _ _ hold | |
| apply restart_project_eq A g R s.C s.K s.H s.L history'.length s.k s.n s.N s.h | |
| s.hK s.hW s.xi s.v | |
| · intro i _ | |
| exact ((project_eq_iff A g _ _).mp (lookup_project_eq A g history history' hh i)).1 | |
| · exact ((project_eq_iff A g _ _).mp hold).2 | |
| · exact hold | |
| def canonicalStep (R : RootedCompletion.Selection A.T) (s : RootedPhaseHistory.Settings A) | |
| (history : List (Canonical (p := p))) (bits : RootedPhaseHistory.Word A s) : Canonical (p := p) := | |
| project A g (RootedPhaseHistory.step A R s (history.map (extend A g)) bits) | |
| theorem step_project (R : RootedCompletion.Selection A.T) (s : RootedPhaseHistory.Settings A) | |
| (history : List (Stored A)) (bits : RootedPhaseHistory.Word A s) : | |
| project A g (RootedPhaseHistory.step A R s history bits)= | |
| canonicalStep A g R s (history.map (project A g)) bits := by | |
| apply step_project_eq A g R s history ((history.map (project A g)).map (extend A g)) | |
| simp only [List.map_map,Function.comp_def,project_extend] | |
| end | |
| end ContingencyTables.CompanionCanonicalHistory | |
| end OAI | |