| import OAI.Combinatorics.BalancedRyser.Profiles.LocalMarkedAnchors |
|
|
| namespace OAI |
|
|
| namespace Balanced.Local.ConditionSpec |
|
|
| noncomputable section |
| open scoped Classical |
| open Surplus MarkedAnchors |
|
|
| abbrev Position (b : ℕ) := Fin b × Fin 4 |
|
|
| abbrev Code (b κ : ℕ) := Unit ⊕ |
| ((Position b × Position b) ⊕ (Position b ⊕ (Fin (4 * b - κ) × Position b))) |
|
|
| def anchors {b κ : ℕ} : Code b κ → Finset (Position b) |
| | Sum.inl _ => ∅ |
| | Sum.inr (Sum.inl xy) => {xy.1, xy.2} |
| | Sum.inr (Sum.inr (Sum.inl x)) => {x} |
| | Sum.inr (Sum.inr (Sum.inr cx)) => {cx.2} |
|
|
| def underlyingAnchors {b κ : ℕ} (u : Position b → Position b) |
| (z : Code b κ) : Finset (Position b) := (anchors z).image u |
|
|
| theorem anchors_card_le_two {b κ : ℕ} (z : Code b κ) : (anchors z).card ≤ 2 := by |
| rcases z with _ | xy | x | cx |
| · simp [anchors] |
| · exact Finset.card_le_two |
| · simp [anchors] |
| · simp [anchors] |
|
|
| theorem underlyingAnchors_card_le_two {b κ : ℕ} (u : Position b → Position b) |
| (z : Code b κ) : (underlyingAnchors u z).card ≤ 2 := |
| Finset.card_image_le.trans (anchors_card_le_two z) |
|
|
| theorem card_code (b κ : ℕ) : |
| Fintype.card (Code b κ) = 1 + (4 * b) ^ 2 + 4 * b + (4 * b - κ) * (4 * b) := by |
| simp only [Code, Position, Fintype.card_sum, Fintype.card_prod, |
| Fintype.card_unit, Fintype.card_fin] |
| ring |
|
|
| theorem card_code_le (b κ : ℕ) (hb : 1 ≤ b) : |
| Fintype.card (Code b κ) ≤ 37 * b ^ 2 := by |
| rw [card_code] |
| have hκ : 4 * b - κ ≤ 4 * b := Nat.sub_le _ _ |
| have hmul := Nat.mul_le_mul_right (4 * b) hκ |
| nlinarith [Nat.mul_self_le_mul_self hb] |
|
|
| theorem card_test_code_le (b κ : ℕ) (hb : 1 ≤ b) : |
| Fintype.card (Position b × Code b κ) ≤ 148 * b ^ 3 := by |
| rw [Fintype.card_prod] |
| have h := Nat.mul_le_mul_left (4 * b) (card_code_le b κ hb) |
| simpa [Position, Nat.mul_comm, Nat.mul_left_comm, pow_succ, Nat.mul_assoc] using h |
|
|
| theorem card_specifications_le (b κ : ℕ) (hb : 1 ≤ b) : |
| Fintype.card (Fin (3 - κ) → Position b × Code b κ) ≤ (148 * b ^ 3) ^ 3 := by |
| rw [Fintype.card_fun, Fintype.card_fin] |
| apply (Nat.pow_le_pow_left (card_test_code_le b κ hb) (3 - κ)).trans |
| exact Nat.pow_le_pow_right (by positivity) (Nat.sub_le _ _) |
|
|
| 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) |
|
|
| def Holds (v : Position b) : Code b κ → Prop |
| | Sum.inl _ => ∃ d : Direction F, d ∉ FourEvents.usedDirections a ∧ |
| ∃ t : Bool, OnLine p (constituent M d t) ∧ |
| OnLine (prescribedPoint P a bits M v) (constituent M d (!t)) ∧ |
| constituent M d (!t) ≠ lineThrough (a.1 v.1) p |
| | Sum.inr (Sum.inl xy) => |
| prescribedPoint P a bits M xy.1 ≠ prescribedPoint P a bits M xy.2 ∧ |
| OnLine (prescribedPoint P a bits M v) |
| (joiningLine (prescribedPoint P a bits M xy.1) (prescribedPoint P a bits M xy.2)) ∧ |
| joiningLine (prescribedPoint P a bits M xy.1) (prescribedPoint P a bits M xy.2) ≠ |
| lineThrough (a.1 v.1) p |
| | Sum.inr (Sum.inr (Sum.inl x)) => |
| ∃ d : Direction F, d ∉ FourEvents.usedDirections a ∧ |
| prescribedPoint P a bits M x ∈ mergedPoints M d ∧ |
| ∃ t : Bool, OnLine (prescribedPoint P a bits M v) (constituent M d t) ∧ |
| constituent M d t ≠ lineThrough (a.1 v.1) p |
| | Sum.inr (Sum.inr (Sum.inr cx)) => |
| OnLine (prescribedPoint P a bits M v) |
| (lineThrough (a.2 cx.1) (prescribedPoint P a bits M cx.2)) ∧ |
| lineThrough (a.2 cx.1) (prescribedPoint P a bits M cx.2) ≠ |
| lineThrough (a.1 v.1) p |
|
|
| theorem marked_exists_spec {A : Finset (LocalPiece F)} |
| (f : CoverAssignment P a bits p M A) |
| (R : LocalPiece F → Finset (Position b)) |
| (hallowed : ∀ L ∈ A, AllowedPiece a p M L) |
| (hR : ∀ L ∈ A, protectedFibre P a bits p M f L ⊆ R L ∧ |
| R L ⊆ assignmentFibre P a bits p M f L ∧ |
| (R L).card = min |
| (pieceCapacity (fun d => (FourEvents.usingTuples P a d).card) L) |
| (assignmentFibre P a bits p M f L).card) |
| (ha : Eligible P a) (hadm : Admissible P a bits p M) |
| (root child : Fin b) (r s : Fin 4) |
| (hshared : P.classOf root r = P.classOf child s) |
| (v : Position b) (hv : v ∈ Finset.univ \ A.biUnion R) |
| (hvd : v ∉ ParentMap.dependent child s) : |
| ∃ z : Code b κ, Holds P a bits p M v z ∧ |
| v ∉ underlyingAnchors |
| (ParentMap.underlying root child r s (bits root r) (bits child s)) z := by |
| cases hfv : f.piece v with |
| | none => |
| have hp := (f.precovered v).mp hfv |
| obtain ⟨_, ⟨d, t⟩, hd, hpt, hvt⟩ := |
| (PrescribedGeometry.mem_prescribedPartners_iff_unused ha hadm _).mp hp |
| refine ⟨Sum.inl (), ?_, by simp [underlyingAnchors, anchors]⟩ |
| exact ⟨d, hd, t, hpt, hvt, constituent_ne_target P a bits p M hadm d (!t) v⟩ |
| | some L => |
| have hLA := (f.covered v L hfv).1 |
| have hret := hR L hLA |
| rcases L with U | l | d |
| · exact False.elim (small_piece_not_surplus P a bits p M f hadm R U |
| (hallowed _ hLA) hret.2.1 hret.2.2 v hfv hv) |
| · obtain ⟨x, hx, y, hy, hxy, hpoints, hxl, hyl, hnx, hny⟩ := |
| ordinary_marked_anchors P a bits p M f R ha hadm root child r s hshared |
| l (hallowed _ hLA) hret.2.1 hret.2.2 v hfv hv hvd |
| have hvl : OnLine (prescribedPoint P a bits M v) l := |
| (Finset.mem_filter.mp (f.covered v _ hfv).2).2 |
| have heq : joiningLine (prescribedPoint P a bits M x) |
| (prescribedPoint P a bits M y) = l := |
| (eq_of_two_common_points _ _ hpoints l _ hxl hyl |
| (onLine_joiningLine_left _ _) (onLine_joiningLine_right _ _)).symm |
| refine ⟨Sum.inr (Sum.inl (x, y)), ?_, ?_⟩ |
| · change _ ∧ _ ∧ _ |
| rw [heq] |
| exact ⟨hpoints, hvl, ordinary_ne_target a p M l (hallowed _ hLA) v⟩ |
| · simpa [underlyingAnchors, anchors, eq_comm] using And.intro hnx hny |
| · by_cases hd : d ∈ FourEvents.usedDirections a |
| · obtain ⟨c, _, rfl⟩ := Finset.mem_image.mp hd |
| obtain ⟨t, x, hxp, hxv, hvt, hxt, hnx⟩ := |
| used_marked_anchor P a bits p M f R (fun L hL => (hR L hL).1) |
| ha hadm root child r s hshared c v hfv hv hvd |
| have heq : lineThrough (a.2 c) (prescribedPoint P a bits M x) = |
| constituent M (a.2 c) t := (line_eq_lineThrough _ _ hxt).symm |
| refine ⟨Sum.inr (Sum.inr (Sum.inr (c, x))), ?_, ?_⟩ |
| · change _ ∧ _ |
| rw [heq] |
| exact ⟨hvt, constituent_ne_target P a bits p M hadm (a.2 c) t v⟩ |
| · simpa [underlyingAnchors, anchors, eq_comm] using hnx |
| · obtain ⟨x, hx, hxv, hxm, hnx⟩ := |
| unused_marked_anchor P a bits p M f R root child r s d hd |
| hret.2.1 hret.2.2 v hfv hv |
| have hvm : prescribedPoint P a bits M v ∈ mergedPoints M d := |
| (f.covered v _ hfv).2 |
| have ht : ∃ t : Bool, |
| OnLine (prescribedPoint P a bits M v) (constituent M d t) := by |
| simpa only [mergedPoints, linePoints, Finset.mem_union, Finset.mem_filter, |
| Finset.mem_univ, true_and, Bool.exists_bool] using hvm |
| obtain ⟨t, hvt⟩ := ht |
| refine ⟨Sum.inr (Sum.inr (Sum.inl x)), ?_, ?_⟩ |
| · exact ⟨d, hd, hxm, t, hvt, constituent_ne_target P a bits p M hadm d t v⟩ |
| · simpa [underlyingAnchors, anchors, eq_comm] using hnx |
|
|
| theorem underlying_diagonal (i : Fin b) (s : Fin 4) (t : Bool) (x : Position b) : |
| ParentMap.underlying i i s s t t x = x := by |
| cases t <;> simp only [ParentMap.underlying, ParentMap.endpointIndex, |
| Bool.not_false, Bool.not_true, ite_true, Bool.false_eq_true, Bool.true_eq_false, ite_false] |
| all_goals split_ifs <;> simp_all |
| |
| theorem marked_exists_identity_spec {A : Finset (LocalPiece F)} |
| (f : CoverAssignment P a bits p M A) |
| (R : LocalPiece F → Finset (Position b)) |
| (hallowed : ∀ L ∈ A, AllowedPiece a p M L) |
| (hR : ∀ L ∈ A, protectedFibre P a bits p M f L ⊆ R L ∧ |
| R L ⊆ assignmentFibre P a bits p M f L ∧ |
| (R L).card = min |
| (pieceCapacity (fun d => (FourEvents.usingTuples P a d).card) L) |
| (assignmentFibre P a bits p M f L).card) |
| (hb : 3 ≤ b) (ha : Eligible P a) (hadm : Admissible P a bits p M) |
| (v : Position b) (hv : v ∈ Finset.univ \ A.biUnion R) : |
| ∃ z : Code b κ, Holds P a bits p M v z ∧ v ∉ anchors z := by |
| obtain ⟨i, hi, _⟩ := Fin.exists_ne_and_ne_of_two_lt v.1 v.1 (by omega) |
| have hvd : v ∉ ParentMap.dependent i 0 := by |
| simp [ParentMap.dependent, Prod.ext_iff, hi.symm] |
| obtain ⟨z, hz, hn⟩ := marked_exists_spec P a bits p M f R hallowed hR ha hadm |
| i i 0 0 rfl v hv hvd |
| refine ⟨z, hz, ?_⟩ |
| simpa [underlyingAnchors, underlying_diagonal] using hn |
|
|
| end |
| end Balanced.Local.ConditionSpec |
|
|
| end OAI |
|
|
