openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Representation /RepresentationJoinLedger.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationQueryBound | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionTrialLedger | |
| namespace OAI | |
| /-! # Actual parent-join counters through the full prefix tree | |
| The full tree is only an accounting view. The executable search is depth | |
| first and may return YES earlier. Invalid matching tuples remain charged. | |
| -/ | |
| noncomputable section | |
| namespace LowSpaceSubsetSum | |
| namespace CompressionLedger | |
| def add (a b : CompressionLedger) : CompressionLedger := | |
| ⟨a.queries + b.queries, a.reports + b.reports, | |
| a.copies + b.copies, a.controls + b.controls⟩ | |
| end CompressionLedger | |
| namespace RepresentationParentData | |
| variable {n : ℕ} (D : RepresentationParentData n) | |
| def localLedger (B : ℕ) : CompressionLedger := | |
| ⟨(D.collect B).state.queries, (D.collect B).state.reports, | |
| (D.collect B).state.copies, (D.collect B).steps⟩ | |
| def prefixLedger (B : ℕ) : List (Fin n) → MaskRestriction n → CompressionLedger | |
| | [], P => ({ D with maskRestriction := P }).localLedger B | |
| | i :: order, P => | |
| let task := ({ D with maskRestriction := P }).localLedger B | |
| if ({ D with maskRestriction := P }.collect B).state.user.keys.overflow then | |
| task.add ((prefixLedger B order (P.force i false)).add | |
| (prefixLedger B order (P.force i true))) | |
| else task | |
| theorem prefixLedger_queries (B : ℕ) (order : List (Fin n)) (P : MaskRestriction n) : | |
| (D.prefixLedger B order P).queries = D.queryVisits B order P := by | |
| induction order generalizing P with | |
| | nil => rfl | |
| | cons i order ih => | |
| simp only [prefixLedger, queryVisits] | |
| split <;> simp only [CompressionLedger.add, localLedger, ih, Nat.add_zero] | |
| theorem prefixLedger_bounds (B : ℕ) (order : List (Fin n)) (P : MaskRestriction n) : | |
| (D.prefixLedger B order P).reports ≤ D.matchingVisits B order P ∧ | |
| B * (D.prefixLedger B order P).copies ≤ 2 * D.matchingVisits B order P ∧ | |
| (D.prefixLedger B order P).controls ≤ (D.prefixLedger B order P).queries := by | |
| induction order generalizing P with | |
| | nil => | |
| have h := ({ D with maskRestriction := P }).collect_query_bounds B | |
| have hstep : ({ D with maskRestriction := P }.collect B).steps ≤ | |
| ({ D with maskRestriction := P }.collect B).state.queries := by | |
| simpa only [RepresentationParentData.collect, StreamJoin.stopped_eq] using | |
| StreamJoin.stopped_steps_le_queries _ _ _ _ _ _ _ _ _ _ _ _ | |
| exact ⟨h.2.1, h.2.2.1, hstep⟩ | |
| | cons i order ih => | |
| have h := ({ D with maskRestriction := P }).collect_query_bounds B | |
| have hstep : ({ D with maskRestriction := P }.collect B).steps ≤ | |
| ({ D with maskRestriction := P }.collect B).state.queries := by | |
| simpa only [RepresentationParentData.collect, StreamJoin.stopped_eq] using | |
| StreamJoin.stopped_steps_le_queries _ _ _ _ _ _ _ _ _ _ _ _ | |
| have h0 := ih (P.force i false) | |
| have h1 := ih (P.force i true) | |
| simp only [prefixLedger, matchingVisits] | |
| split <;> simp only [CompressionLedger.add, localLedger, Nat.mul_add] | |
| · exact ⟨Nat.add_le_add h.2.1 (Nat.add_le_add h0.1 h1.1), | |
| Nat.add_le_add h.2.2.1 (Nat.add_le_add h0.2.1 h1.2.1), | |
| Nat.add_le_add hstep (Nat.add_le_add h0.2.2 h1.2.2)⟩ | |
| · simpa only [Nat.add_zero] using ⟨h.2.1, h.2.2.1, hstep⟩ | |
| end RepresentationParentData | |
| end LowSpaceSubsetSum | |
| end | |
| end OAI | |