File size: 5,050 Bytes
e5a97c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 | import OAI.Combinatorics.MatrixRemoval.Model
namespace OAI
/-!
The anchor/body extension step for arbitrary repairs.
The finite-order gluing lemma is independent of the host construction.
-/
universe uAlpha
noncomputable section
namespace Problem348
/-- Append two values to a function on a finite initial segment. -/
def appendTwo {α : Type uAlpha} {k : ℕ} (f : Fin k → α) (a b : α) :
Fin (k + 2) → α := fun i =>
if hi : i.val < k then f ⟨i.val, hi⟩ else if i.val = k then a else b
@[simp] theorem appendTwo_initial {α : Type uAlpha} {k : ℕ}
(f : Fin k → α) (a b : α) (i : Fin k) :
appendTwo f a b ⟨i.val, by omega⟩ = f i := by
simp [appendTwo, i.isLt]
@[simp] theorem appendTwo_first {α : Type uAlpha} {k : ℕ}
(f : Fin k → α) (a b : α) :
appendTwo f a b ⟨k, by omega⟩ = a := by
simp [appendTwo]
@[simp] theorem appendTwo_second {α : Type uAlpha} {k : ℕ}
(f : Fin k → α) (a b : α) :
appendTwo f a b ⟨k + 1, by omega⟩ = b := by
simp [appendTwo]
theorem strictMono_appendTwo {α : Type uAlpha} [Preorder α] {k : ℕ}
(f : Fin k → α) (a b : α) (hf : StrictMono f)
(ha : ∀ i, f i < a) (hab : a < b) :
StrictMono (appendTwo f a b) := by
intro i j hij
have hij' : i.val < j.val := hij
by_cases hi : i.val < k
· by_cases hj : j.val < k
· simpa [appendTwo, hi, hj] using
hf (show (⟨i.val, hi⟩ : Fin k) < ⟨j.val, hj⟩ from hij')
· by_cases hjk : j.val = k
· simpa [appendTwo, hi, hj, hjk] using ha ⟨i.val, hi⟩
· simpa [appendTwo, hi, hj, hjk] using lt_trans (ha ⟨i.val, hi⟩) hab
· have hik : i.val = k := by omega
have hjk : j.val = k + 1 := by omega
simpa [appendTwo, hik, hjk] using hab
/-- The increasing map obtained by appending two positions after an anchor. -/
def appendTwoIncreasing {k n : ℕ} (r : IncreasingMap k n)
(a b : Fin n) (ha : ∀ i, r.val i < a) (hab : a < b) :
IncreasingMap (k + 2) n :=
⟨appendTwo r.val a b, strictMono_appendTwo r.val a b r.property ha hab⟩
/-- An anchor and the four body entries reproduce every entry of the fixed pattern. -/
theorem appendTwo_matches_fixedH {n : ℕ} (B : BinaryMatrix n)
(r c : IncreasingMap 64 n) (r₀ r₁ c₀ c₁ : Fin n)
(hanchor : ∀ u v, B (r.val u) (c.val v) = anchor64 u v)
(hrow₀ : ∀ v, B r₀ (c.val v) = decide (v.val = 0))
(hrow₁ : ∀ v, B r₁ (c.val v) = decide (v.val = 1))
(hcol₀ : ∀ u, B (r.val u) c₀ = decide (u.val = 0))
(hcol₁ : ∀ u, B (r.val u) c₁ = decide (u.val = 1))
(h₀₀ : B r₀ c₀ = true) (h₀₁ : B r₀ c₁ = false)
(h₁₀ : B r₁ c₀ = true) (h₁₁ : B r₁ c₁ = true) :
∀ i j : Fin 66,
B (appendTwo r.val r₀ r₁ i) (appendTwo c.val c₀ c₁ j) = fixedH i j := by
intro i j
by_cases hi : i.val < 64
· by_cases hj : j.val < 64
· simpa [appendTwo, fixedH, hi, hj] using
hanchor ⟨i.val, hi⟩ ⟨j.val, hj⟩
· have hjcases : j.val = 64 ∨ j.val = 65 := by omega
rcases hjcases with hj₀ | hj₁
· simpa [appendTwo, fixedH, hi, hj, hj₀] using hcol₀ ⟨i.val, hi⟩
· simpa [appendTwo, fixedH, hi, hj, hj₁] using hcol₁ ⟨i.val, hi⟩
· have hicases : i.val = 64 ∨ i.val = 65 := by omega
by_cases hj : j.val < 64
· rcases hicases with hi₀ | hi₁
· simpa [appendTwo, fixedH, hi, hj, hi₀] using hrow₀ ⟨j.val, hj⟩
· simpa [appendTwo, fixedH, hi, hj, hi₁] using hrow₁ ⟨j.val, hj⟩
· have hjcases : j.val = 64 ∨ j.val = 65 := by omega
rcases hicases with hi₀ | hi₁ <;> rcases hjcases with hj₀ | hj₁ <;>
simp [appendTwo, fixedH, *]
/-- The exact anchor-extension bridge needed by arbitrary-repair propagation. -/
theorem not_HFree_of_anchor_body {n : ℕ} (B : BinaryMatrix n)
(r c : IncreasingMap 64 n) (r₀ r₁ c₀ c₁ : Fin n)
(hr : ∀ i, r.val i < r₀) (hr₀₁ : r₀ < r₁)
(hc : ∀ j, c.val j < c₀) (hc₀₁ : c₀ < c₁)
(hanchor : ∀ u v, B (r.val u) (c.val v) = anchor64 u v)
(hrow₀ : ∀ v, B r₀ (c.val v) = decide (v.val = 0))
(hrow₁ : ∀ v, B r₁ (c.val v) = decide (v.val = 1))
(hcol₀ : ∀ u, B (r.val u) c₀ = decide (u.val = 0))
(hcol₁ : ∀ u, B (r.val u) c₁ = decide (u.val = 1))
(h₀₀ : B r₀ c₀ = true) (h₀₁ : B r₀ c₁ = false)
(h₁₀ : B r₁ c₀ = true) (h₁₁ : B r₁ c₁ = true) :
¬ HFree fixedH B := by
classical
let rr := appendTwoIncreasing r r₀ r₁ hr hr₀₁
let cc := appendTwoIncreasing c c₀ c₁ hc hc₀₁
have hmem : (rr, cc) ∈ orderedCopies fixedH B := by
simp only [orderedCopies, Finset.mem_filter, Finset.mem_univ, true_and]
exact appendTwo_matches_fixedH B r c r₀ r₁ c₀ c₁ hanchor hrow₀ hrow₁
hcol₀ hcol₁ h₀₀ h₀₁ h₁₀ h₁₁
have hpos : 0 < copyCount fixedH B :=
Finset.card_pos.mpr ⟨(rr, cc), hmem⟩
exact Nat.ne_of_gt hpos
end Problem348
end
end OAI
|