Files
conflict-range/FormalConflictRange/ComputableAlgorithm.lean
T

71 lines
3.0 KiB
Lean4

/-
Released under Apache 2.0 license as described in the file LICENSE.
-/
import FormalConflictRange.ComputableHull
import FormalConflictRange.ComputableSearch
/-!
# A simple computable conflict-range algorithm
This file assembles the computable pieces into one algorithm:
* `activeComputableFast` decides cell activity by finite count feasibility, using
the lazy hitting-set search of `ComputableSearch.lean`;
* `cellRepsC`/`activeRepsOfC` enumerate the endpoint cells with executable
`Finset` operations;
* `hullOfActiveRepsC` extracts the least active key and greatest active upper
boundary with `Finset.min`/`Finset.max`.
The result, `simpleConflictRange`, is a total `ConflictRange`-valued `def` (not
a classical existence statement) and is proved minimal on every readable pair.
Both activity and hull extraction are executable; the eager `choices` oracle is
kept only as a proof-facing reference.
-/
namespace FormalConflictRange
/-- The simple computable conflict-range algorithm: enumerate the endpoint
cells, decide activity with the lazy oracle `activeComputableFast`, and take the
hull. -/
def simpleConflictRange (r : RangeRead) (res : Result) : ConflictRange :=
computableCellwise r res (activeComputableFast r res)
/-- The simple algorithm agrees with the cellwise oracle algorithm. -/
theorem simpleConflictRange_eq_cellwise (r : RangeRead) (res : Result) :
simpleConflictRange r res = conflictRangeCellwise r res (activeComputableFast r res) :=
computableCellwise_eq_cellwise r res (activeComputableFast r res)
/-- On a readable pair, the simple algorithm agrees with the cellwise algorithm
driven by the eager `choices` oracle. -/
theorem simpleConflictRange_eq_eager_cellwise {r : RangeRead} {res : Result}
(hread : Readable r res) :
simpleConflictRange r res =
conflictRangeCellwise r res (activeComputable r res) := by
rw [simpleConflictRange_eq_cellwise]
have hfun : activeComputableFast r res = activeComputable r res :=
funext (activeComputableFast_eq hread)
rw [hfun]
/-- The simple algorithm computes the general hull on every readable pair. -/
theorem simpleConflictRange_eq_general {r : RangeRead} {res : Result}
(hread : Readable r res) :
simpleConflictRange r res = conflictRangeGeneral r res := by
rw [simpleConflictRange_eq_cellwise]
exact conflictRangeCellwise_eq_general (activeComputableFast_spec hread)
/-- The simple algorithm is minimal on every readable pair. -/
theorem simpleConflictRange_minimal {r : RangeRead} {res : Result}
(hread : Readable r res) :
Minimal r res (simpleConflictRange r res) := by
rw [simpleConflictRange_eq_general hread]
exact conflictRangeGeneral_minimal hread
/-- The simple algorithm computes exactly the necessary-key set. -/
theorem simpleConflictRange_toSet_eq_necessarySet {r : RangeRead} {res : Result}
(hread : Readable r res) :
(simpleConflictRange r res).toSet = necessarySet r res := by
rw [simpleConflictRange_eq_general hread]
exact necessarySet_eq_flipHull (characterizesDNF_characterizingDNF hread)
end FormalConflictRange