| import OAI.Computability.DepthThree.Model |
|
|
| namespace OAI |
|
|
| universe uDepth1 uDepth2 uDepth3 |
|
|
| namespace DepthThreeLowerBound |
|
|
| abbrev Clause (V : Type uDepth1) := Finset (Literal V) |
| abbrev CNF (V : Type uDepth2) := List (Clause V) |
|
|
| variable {V : Type uDepth3} |
|
|
| namespace Literal |
|
|
| def compl (l : Literal V) : Literal V := (l.1, !l.2) |
|
|
| @[simp] theorem eval_eq_true (l : Literal V) (x : Cube V) : |
| l.eval x = true ↔ x l.1 = l.2 := by simp [eval] |
|
|
| @[simp] theorem compl_compl (l : Literal V) : l.compl.compl = l := by |
| cases l with |
| | mk v b => cases b <;> rfl |
|
|
| @[simp] theorem eval_compl (l : Literal V) (x : Cube V) : |
| l.compl.eval x = !(l.eval x) := by |
| rcases l with ⟨v, b⟩ |
| cases b <;> cases h : x v <;> simp [compl, eval, h] |
|
|
| end Literal |
|
|
| namespace Clause |
|
|
| noncomputable def eval (C : Clause V) (x : Cube V) : Bool := by |
| classical |
| exact decide (∃ l ∈ C, l.eval x = true) |
|
|
| noncomputable def scope (C : Clause V) : Finset V := by |
| classical |
| exact C.image Prod.fst |
|
|
| noncomputable def width (C : Clause V) : ℕ := C.scope.card |
|
|
| def Normalized (C : Clause V) : Prop := |
| ∀ v, (v, false) ∈ C → (v, true) ∈ C → False |
|
|
| @[simp] theorem eval_eq_true (C : Clause V) (x : Cube V) : |
| C.eval x = true ↔ ∃ l ∈ C, x l.1 = l.2 := by |
| classical |
| simp [eval] |
|
|
| @[simp] theorem eval_empty (x : Cube V) : (∅ : Clause V).eval x = false := by |
| simp [eval] |
|
|
| @[simp] theorem scope_empty : (∅ : Clause V).scope = ∅ := by |
| classical |
| simp [scope] |
|
|
| @[simp] theorem width_empty : (∅ : Clause V).width = 0 := by |
| simp [width] |
|
|
| @[simp] theorem eval_singleton (l : Literal V) (x : Cube V) : |
| ({l} : Clause V).eval x = l.eval x := by |
| classical |
| simp [eval, Literal.eval] |
|
|
| theorem eval_mono {C D : Clause V} (h : C ⊆ D) {x : Cube V} |
| (hx : C.eval x = true) : D.eval x = true := by |
| rw [eval_eq_true] at hx ⊢ |
| obtain ⟨l, hl, hx⟩ := hx |
| exact ⟨l, h hl, hx⟩ |
|
|
| theorem Normalized.subset {C D : Clause V} (hD : D.Normalized) (h : C ⊆ D) : |
| C.Normalized := by |
| intro v hf ht |
| exact hD v (h hf) (h ht) |
|
|
| theorem Normalized.fst_injOn {C : Clause V} (h : C.Normalized) : |
| Set.InjOn Prod.fst (↑C : Set (Literal V)) := by |
| rintro ⟨v, b⟩ hb ⟨w, c⟩ hc hv |
| change v = w at hv |
| subst w |
| cases b <;> cases c |
| · rfl |
| · exact (h v hb hc).elim |
| · exact (h v hc hb).elim |
| · rfl |
|
|
| theorem Normalized.card_eq_width {C : Clause V} (h : C.Normalized) : |
| C.card = C.width := by |
| classical |
| exact (Finset.card_image_of_injOn h.fst_injOn).symm |
|
|
| theorem scope_mono {C D : Clause V} (h : C ⊆ D) : C.scope ⊆ D.scope := by |
| classical |
| exact Finset.image_subset_image h |
|
|
| theorem width_mono {C D : Clause V} (h : C ⊆ D) : C.width ≤ D.width := |
| Finset.card_le_card (scope_mono h) |
|
|
| end Clause |
|
|
| namespace CNF |
|
|
| noncomputable def eval (H : CNF V) (x : Cube V) : Bool := by |
| classical |
| exact decide (∀ C ∈ H, C.eval x = true) |
|
|
| def WidthAtMost (H : CNF V) (b : ℕ) : Prop := ∀ C ∈ H, C.width ≤ b |
|
|
| def Normalized (H : CNF V) : Prop := ∀ C ∈ H, C.Normalized |
|
|
| @[simp] theorem eval_eq_true (H : CNF V) (x : Cube V) : |
| H.eval x = true ↔ ∀ C ∈ H, C.eval x = true := by |
| classical |
| simp [eval] |
|
|
| @[simp] theorem eval_nil (x : Cube V) : CNF.eval ([] : CNF V) x = true := by |
| simp [eval] |
|
|
| @[simp] theorem eval_cons (C : Clause V) (H : CNF V) (x : Cube V) : |
| CNF.eval (C :: H) x = (C.eval x && H.eval x) := by |
| classical |
| apply Bool.eq_iff_iff.mpr |
| rw [eval_eq_true, Bool.and_eq_true, eval_eq_true] |
| constructor |
| · intro h |
| exact ⟨h C (by simp), fun D hD => h D (by simp [hD])⟩ |
| · rintro ⟨hc, hH⟩ D hD |
| rcases List.mem_cons.mp hD with hD | hD |
| · simpa only [hD] using hc |
| · exact hH D hD |
|
|
| @[simp] theorem eval_append (H J : CNF V) (x : Cube V) : |
| (H ++ J).eval x = (H.eval x && J.eval x) := by |
| induction H with |
| | nil => simp |
| | cons C H ih => simp [ih, Bool.and_assoc] |
|
|
| theorem eval_antitone {H J : CNF V} (h : H ⊆ J) {x : Cube V} |
| (hx : J.eval x = true) : H.eval x = true := by |
| rw [eval_eq_true] at hx ⊢ |
| exact fun C hC => hx C (h hC) |
|
|
| theorem WidthAtMost.mono {H : CNF V} {b c : ℕ} (h : H.WidthAtMost b) |
| (hbc : b ≤ c) : H.WidthAtMost c := fun C hC => (h C hC).trans hbc |
|
|
| end CNF |
|
|
| def indicator (b : Bool) : ℝ := if b then 1 else 0 |
| def sign (b : Bool) : ℝ := if b then 1 else -1 |
|
|
| @[simp] theorem indicator_false : indicator false = 0 := rfl |
| @[simp] theorem indicator_true : indicator true = 1 := rfl |
| @[simp] theorem sign_false : sign false = -1 := rfl |
| @[simp] theorem sign_true : sign true = 1 := rfl |
|
|
| @[simp] theorem indicator_and (b c : Bool) : |
| indicator (b && c) = indicator b * indicator c := by |
| cases b <;> cases c <;> simp [indicator] |
|
|
| theorem indicator_nonneg (b : Bool) : 0 ≤ indicator b := by |
| cases b <;> simp [indicator] |
|
|
| theorem indicator_le_one (b : Bool) : indicator b ≤ 1 := by |
| cases b <;> simp [indicator] |
|
|
| end DepthThreeLowerBound |
|
|
| end OAI |
|
|
