File size: 4,192 Bytes
5d5048e | 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Storage.StoredEntry
namespace OAI
/-! # Executed overlap tests on bounded index lists -/
namespace LowSpaceSubsetSum.CountedMaskChecks
variable {n : ℕ}
def disjointAcc (A B : IndexedMask n) : List (Fin n) → Bool × ℕ
| [] => (true, 1)
| i :: xs =>
let a := CountedWeights.member i A.indices
let b := CountedWeights.member i B.indices
let rest := disjointAcc A B xs
(!(a.1 && b.1) && rest.1, a.2 + b.2 + rest.2 + 5)
theorem disjointAcc_value (A B : IndexedMask n) (xs : List (Fin n)) :
(disjointAcc A B xs).1 = true ↔
∀ i ∈ xs, ¬(i ∈ A.indices ∧ i ∈ B.indices) := by
induction xs with
| nil => simp [disjointAcc]
| cons i xs ih =>
by_cases ha : i ∈ A.indices <;> by_cases hb : i ∈ B.indices <;>
simp [disjointAcc, CountedWeights.member_value, ha, hb, ih]
theorem disjointAcc_work (A B : IndexedMask n) (xs : List (Fin n)) :
(disjointAcc A B xs).2 ≤ (2 * n + 7) * xs.length + 1 := by
induction xs with
| nil => simp [disjointAcc]
| cons i xs ih =>
have ha := CountedWeights.member_work i A.indices
have hb := CountedWeights.member_work i B.indices
have hA := A.length_le
have hB := B.length_le
simp only [disjointAcc, List.length_cons, Nat.mul_add, Nat.mul_one]
omega
def disjoint (A B : IndexedMask n) : Bool × ℕ := disjointAcc A B (List.finRange n)
theorem disjoint_value (A B : IndexedMask n) :
(disjoint A B).1 = decide (Disjoint A.semantic B.semantic) := by
apply Bool.eq_iff_iff.mpr
simp only [disjoint, disjointAcc_value, decide_eq_true_eq, List.mem_finRange,
forall_true_left, Finset.disjoint_left, IndexedMask.semantic, List.mem_toFinset]
simp only [not_and]
theorem disjoint_work (A B : IndexedMask n) :
(disjoint A B).2 ≤ (2 * n + 7) * n + 1 := by
simpa only [disjoint, List.length_finRange] using disjointAcc_work A B (List.finRange n)
def four (A B C D : IndexedMask n) : Bool × ℕ :=
let ab := disjoint A B
let ac := disjoint A C
let bc := disjoint B C
let ad := disjoint A D
let bd := disjoint B D
let cd := disjoint C D
(ab.1 && ac.1 && bc.1 && ad.1 && bd.1 && cd.1,
ab.2 + ac.2 + bc.2 + ad.2 + bd.2 + cd.2 + 6)
theorem four_value (A B C D : IndexedMask n) :
(four A B C D).1 = true ↔
RepresentationUniverse.DisjointFour A.semantic B.semantic C.semantic D.semantic := by
simp only [four, disjoint_value, Bool.and_eq_true, decide_eq_true_eq,
RepresentationUniverse.DisjointFour, Finset.disjoint_union_left]
tauto
theorem four_work (A B C D : IndexedMask n) :
(four A B C D).2 ≤ 6 * ((2 * n + 7) * n + 1) + 6 := by
have hab := disjoint_work A B
have hac := disjoint_work A C
have hbc := disjoint_work B C
have had := disjoint_work A D
have hbd := disjoint_work B D
have hcd := disjoint_work C D
change _ + _ + _ + _ + _ + _ + 6 ≤ _
omega
def valid (x : (LeafRecord n × LeafRecord n) × (LeafRecord n × LeafRecord n)) : Bool × ℕ :=
let top := four x.1.1.top x.1.2.top x.2.1.top x.2.2.top
let loc := four x.1.1.localMask x.1.2.localMask x.2.1.localMask x.2.2.localMask
let bg := four x.1.1.background x.1.2.background x.2.1.background x.2.2.background
(top.1 && loc.1 && bg.1, top.2 + loc.2 + bg.2 + 3)
theorem valid_value (x : (LeafRecord n × LeafRecord n) × (LeafRecord n × LeafRecord n)) :
(valid x).1 = decide (RepresentationUniverse.Valid
(RepresentationKeys.pairSemantic x.1, RepresentationKeys.pairSemantic x.2)) := by
apply Bool.eq_iff_iff.mpr
rw [decide_eq_true_eq]
simp only [valid, four_value, Bool.and_eq_true,
RepresentationUniverse.Valid, RepresentationKeys.pairSemantic, LeafRecord.semantic]
tauto
theorem valid_work (x : (LeafRecord n × LeafRecord n) × (LeafRecord n × LeafRecord n)) :
(valid x).2 ≤ 18 * ((2 * n + 7) * n + 1) + 21 := by
have ht := four_work x.1.1.top x.1.2.top x.2.1.top x.2.2.top
have hl := four_work x.1.1.localMask x.1.2.localMask x.2.1.localMask x.2.2.localMask
have hb := four_work x.1.1.background x.1.2.background x.2.1.background x.2.2.background
change _ + _ + _ + 3 ≤ _
omega
end LowSpaceSubsetSum.CountedMaskChecks
end OAI
|