| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.StoredEntry |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| 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 |
|
|
