openAI-math-dataset / lean /OAI /Combinatorics /BalancedRyser /Local /LocalAcyclicSpecifications.lean
| import OAI.Combinatorics.BalancedRyser.Local.LocalConditionSpec | |
| import OAI.Combinatorics.BalancedRyser.Probability.SurplusAcyclic | |
| namespace OAI | |
| namespace Balanced.Local.ConditionSpec | |
| noncomputable section | |
| open scoped Classical | |
| open Surplus | |
| variable {F : Type*} [Field F] [Fintype F] [DecidableEq F] | |
| variable {b κ : ℕ} (P : EqualityPattern b κ) | |
| variable (a : DirectionAssignment F b κ) (bits : Bits b) | |
| variable (p : Point F) (M : MergedPairs F) | |
| theorem exists_acyclic_codes (S : Finset (Position b)) | |
| (u : Position b → Position b) (hb : 3 ≤ b) (hκ : κ ≤ 1) | |
| (hcard : 2 * b + 2 - 4 * κ ≤ S.card) | |
| (hex : ∀ v ∈ S, ∃ z : Code b κ, | |
| Holds P a bits p M v z ∧ v ∉ underlyingAnchors u z) : | |
| ∃ (T : Finset (Position b)) (code : Position b → Code b κ), | |
| T ⊆ S ∧ T.card = 3 - κ ∧ | |
| (∀ v ∈ T, Holds P a bits p M v (code v) ∧ | |
| v ∉ underlyingAnchors u (code v)) ∧ | |
| WellFounded (fun x y : {v // v ∈ T} => | |
| y.val ∈ underlyingAnchors u (code x.val)) := by | |
| have hex' : ∀ v : Position b, ∃ z : Code b κ, | |
| v ∈ S → Holds P a bits p M v z ∧ v ∉ underlyingAnchors u z := by | |
| intro v | |
| by_cases hv : v ∈ S | |
| · obtain ⟨z, hz⟩ := hex v hv | |
| exact ⟨z, fun _ => hz⟩ | |
| · exact ⟨Sum.inl (), fun h => False.elim (hv h)⟩ | |
| choose code hcode using hex' | |
| let R : Position b → Position b → Prop := | |
| fun x y => y ∈ underlyingAnchors u (code x) | |
| have hloop : ∀ x ∈ S, ¬ R x x := fun x hx => (hcode x hx).2 | |
| have hdegree : ∀ x ∈ S, (S.filter (R x)).card ≤ 2 := by | |
| intro x _ | |
| apply (Finset.card_le_card (show S.filter (R x) ⊆ | |
| underlyingAnchors u (code x) from fun y hy => (Finset.mem_filter.mp hy).2)).trans | |
| exact underlyingAnchors_card_le_two u (code x) | |
| obtain ⟨T, hTS, hTcard, hTwf⟩ := | |
| source_surplus_acyclic S R b κ hb hκ hcard hloop (by | |
| intro x hx | |
| convert hdegree x hx using 1 | |
| congr 1 | |
| ext y | |
| simp only [Finset.mem_filter]) | |
| exact ⟨T, code, hTS, hTcard, fun v hv => hcode v (hTS hv), hTwf⟩ | |
| theorem badCover_zero_reuse_exists_acyclic_spec | |
| {b : ℕ} (P : EqualityPattern b 0) | |
| (a : DirectionAssignment F b 0) (bits : Bits b) (p : Point F) | |
| (M : MergedPairs F) (hb : 3 ≤ b) (ha : Eligible P a) | |
| (hadm : Admissible P a bits p M) (hbad : BadCover P a bits p M) : | |
| ∃ (T : Finset (Position b)) (code : Position b → Code b 0), | |
| T.card = 3 ∧ | |
| (∀ v ∈ T, Holds P a bits p M v (code v) ∧ v ∉ anchors (code v)) ∧ | |
| WellFounded (fun x y : {v // v ∈ T} => y.val ∈ anchors (code x.val)) := by | |
| obtain ⟨A, hA, hallowed, f, R, hR, hsurplus, _⟩ := | |
| badCover_exists_marked_surplus P a bits p M (by omega) (by omega) ha hbad | |
| let S : Finset (Position b) := Finset.univ \ A.biUnion R | |
| have hex : ∀ v ∈ S, ∃ z : Code b 0, | |
| Holds P a bits p M v z ∧ v ∉ underlyingAnchors id z := by | |
| intro v hv | |
| obtain ⟨z, hz, hn⟩ := marked_exists_identity_spec P a bits p M f R | |
| hallowed hR hb ha hadm v hv | |
| exact ⟨z, hz, by simpa [underlyingAnchors] using hn⟩ | |
| have hcard : 2 * b + 2 - 4 * 0 ≤ S.card := by | |
| simpa only [Nat.mul_zero] using hsurplus | |
| obtain ⟨T, code, _, hTcard, hT, hwf⟩ := | |
| exists_acyclic_codes P a bits p M S id hb (by omega) hcard hex | |
| refine ⟨T, code, by simpa using hTcard, ?_, ?_⟩ | |
| · simpa only [underlyingAnchors, Finset.image_id] using hT | |
| · simpa only [underlyingAnchors, Finset.image_id] using hwf | |
| theorem badCover_one_reuse_exists_acyclic_spec | |
| {b : ℕ} (P : EqualityPattern b 1) | |
| (a : DirectionAssignment F b 1) (bits : Bits b) (p : Point F) | |
| (M : MergedPairs F) (hb : 3 ≤ b) (ha : Eligible P a) | |
| (hadm : Admissible P a bits p M) (hbad : BadCover P a bits p M) | |
| (root child : Fin b) (r s : Fin 4) | |
| (hshared : P.classOf root r = P.classOf child s) : | |
| let u := ParentMap.underlying root child r s (bits root r) (bits child s) | |
| ∃ (T : Finset (Position b)) (code : Position b → Code b 1), | |
| T.card = 2 ∧ | |
| (∀ v ∈ T, v ∉ ParentMap.dependent child s ∧ | |
| Holds P a bits p M v (code v) ∧ v ∉ underlyingAnchors u (code v)) ∧ | |
| WellFounded (fun x y : {v // v ∈ T} => y.val ∈ underlyingAnchors u (code x.val)) := by | |
| dsimp only | |
| let u := ParentMap.underlying root child r s (bits root r) (bits child s) | |
| obtain ⟨A, hA, hallowed, f, R, hR, _, hdiscard⟩ := | |
| badCover_exists_marked_surplus P a bits p M (by omega) (by omega) ha hbad | |
| let S : Finset (Position b) := | |
| (Finset.univ \ A.biUnion R) \ ParentMap.dependent child s | |
| have hdep : (ParentMap.dependent child s).card ≤ 2 * 1 := by | |
| simpa only [ParentMap.dependent, Nat.mul_one] using | |
| (Finset.card_le_two (a := (child, s)) (b := (child, s - 1))) | |
| have hcard : 2 * b + 2 - 4 * 1 ≤ S.card := hdiscard _ hdep | |
| have hex : ∀ v ∈ S, ∃ z : Code b 1, | |
| Holds P a bits p M v z ∧ v ∉ underlyingAnchors u z := by | |
| intro v hv | |
| obtain ⟨hvs, hvd⟩ := Finset.mem_sdiff.mp hv | |
| exact marked_exists_spec P a bits p M f R hallowed hR ha hadm | |
| root child r s hshared v hvs hvd | |
| obtain ⟨T, code, hTS, hTcard, hT, hwf⟩ := | |
| exists_acyclic_codes P a bits p M S u hb (by omega) hcard hex | |
| refine ⟨T, code, by simpa using hTcard, ?_, hwf⟩ | |
| intro v hv | |
| exact ⟨(Finset.mem_sdiff.mp (hTS hv)).2, hT v hv⟩ | |
| end | |
| end Balanced.Local.ConditionSpec | |
| end OAI | |