inductive Std.Tactic.BVDecide.LRAT.Internal.ReduceResult (α : Type u) : Type u

An inductive datatype used specifically for the output of the reduce function. The intended meaning of each constructor is explained in the docstring of the reduce function.

• encounteredBoth {α : Type u} : ReduceResult α
• reducedToEmpty {α : Type u} : ReduceResult α
• reducedToUnit {α : Type u} (l : Sat.Literal α) : ReduceResult α
• reducedToNonunit {α : Type u} : ReduceResult α

class Std.Tactic.BVDecide.LRAT.Internal.Clause (α : outParam (Type u)) (β : Type v) : Type (max u v)

Typeclass for clauses. An instance [Clause α β] indicates that β is the type of a clause with variables of type α.

• toList : β → Sat.CNF.Clause α
• not_tautology (c : β) (l : Sat.Literal α) : ¬l ∈ toList c ∨ ¬l.negate ∈ toList c
• ofArray : Array (Sat.Literal α) → Option β

  Returns none if the given array contains complementary literals

• empty : β
• empty_eq : toList empty = []
• unit : Sat.Literal α → β
• unit_eq (l : Sat.Literal α) : toList (unit l) = [l]
• isUnit : β → Option (Sat.Literal α)
• isUnit_iff (c : β) (l : Sat.Literal α) : isUnit c = some l ↔ toList c = [l]
• negate : β → Sat.CNF.Clause α
• negate_eq (c : β) : negate c = List.map Sat.Literal.negate (toList c)
• delete : β → Sat.Literal α → β
• delete_iff (c : β) (l l' : Sat.Literal α) : l' ∈ toList (delete c l) ↔ l' ≠ l ∧ l' ∈ toList c
• contains : β → Sat.Literal α → Bool
• contains_iff (c : β) (l : Sat.Literal α) : contains c l = true ↔ l ∈ toList c
• reduce : β → Array Assignment → ReduceResult α

  Reduces the clause with respect to the given assignment

@[implicit_reducible]

instance Std.Tactic.BVDecide.LRAT.Internal.Clause.instEntailsLiteral {α : Type u_1} : Entails α (Sat.Literal α)

@[implicit_reducible]

instance Std.Tactic.BVDecide.LRAT.Internal.Clause.instDecidableEvalLiteral {α : Type u_1} (p : α → Bool) (l : Sat.Literal α) : Decidable (Entails.eval p l)

def Std.Tactic.BVDecide.LRAT.Internal.Clause.eval {α : Type u_1} {β : Type u_2} [Clause α β] (a : α → Bool) (c : β) : Bool

@[implicit_reducible]

instance Std.Tactic.BVDecide.LRAT.Internal.Clause.instEntails {α : Type u_1} {β : Type u_2} [Clause α β] : Entails α β

@[implicit_reducible]

instance Std.Tactic.BVDecide.LRAT.Internal.Clause.instDecidableEval {α : Type u_1} {β : Type u_2} [Clause α β] (p : α → Bool) (c : β) : Decidable (Entails.eval p c)

structure Std.Tactic.BVDecide.LRAT.Internal.DefaultClause (numVarsSucc : Nat) : Type

The DefaultClause structure is primarily a list of literals. The additional field nodupkey is included to ensure that not_tautology is provable (which is needed to prove sat_of_insertRup and sat_of_insertRat in LRAT.Formula.Internal.RupAddSound and LRAT.Formula.Internal.RatAddSound). The additional field nodup is included to ensure that delete can be implemented by simply calling erase on the clause field. Without nodup, it would be necessary to iterate through the entire clause field and erase all instances of the literal to be deleted, since there would potentially be more than one.

In principle, one could combine nodupkey and nodup to instead have one additional field that stipulates that ∀ l1 : PosFin numVarsSucc, ∀ l2 : PosFin numVarsSucc, l1.1 ≠ l2.1. This would work just as well, and the only reason that DefaultClause is structured in this manner is that the nodup field was only included in a later stage of the verification process when it became clear that it was needed.

• clause : Sat.CNF.Clause (PosFin numVarsSucc)
• nodupkey (l : PosFin numVarsSucc) : ¬(l, true) ∈ self.clause ∨ ¬(l, false) ∈ self.clause
• nodup : List.Nodup self.clause

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ext {numVarsSucc : Nat} {x y : DefaultClause numVarsSucc} (clause : x.clause = y.clause) : x = y

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ext_iff {numVarsSucc : Nat} {x y : DefaultClause numVarsSucc} : x = y ↔ x.clause = y.clause

def Std.Tactic.BVDecide.LRAT.Internal.instBEqDefaultClause.beq {numVarsSucc✝ : Nat} : DefaultClause numVarsSucc✝ → DefaultClause numVarsSucc✝ → Bool

@[implicit_reducible]

instance Std.Tactic.BVDecide.LRAT.Internal.instBEqDefaultClause {numVarsSucc✝ : Nat} : BEq (DefaultClause numVarsSucc✝)

@[implicit_reducible]

instance Std.Tactic.BVDecide.LRAT.Internal.instToStringDefaultClause {n : Nat} : ToString (DefaultClause n)

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.toList {n : Nat} (c : DefaultClause n) : Sat.CNF.Clause (PosFin n)

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.not_tautology {n : Nat} (c : DefaultClause n) (l : Sat.Literal (PosFin n)) : ¬l ∈ c.toList ∨ ¬l.negate ∈ c.toList

@[inline]

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.empty {n : Nat} : DefaultClause n

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.empty_eq {n : Nat} : empty.toList = []

@[inline]

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit {n : Nat} (l : Sat.Literal (PosFin n)) : DefaultClause n

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit_eq {n : Nat} (l : Sat.Literal (PosFin n)) : (unit l).toList = [l]

@[inline]

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.isUnit {n : Nat} (c : DefaultClause n) : Option (Sat.Literal (PosFin n))

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.isUnit_iff {n : Nat} (c : DefaultClause n) (l : Sat.Literal (PosFin n)) : c.isUnit = some l ↔ c.toList = [l]

@[inline]

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.negate {n : Nat} (c : DefaultClause n) : Sat.CNF.Clause (PosFin n)

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.negate_eq {n : Nat} (c : DefaultClause n) : c.negate = List.map Sat.Literal.negate c.toList

@[irreducible]

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray.folder {n : Nat} (acc : Option (HashMap (PosFin n) Bool)) (l : Sat.Literal (PosFin n)) : Option (HashMap (PosFin n) Bool)

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray {n : Nat} (ls : Array (Sat.Literal (PosFin n))) : Option (DefaultClause n)

@[simp]

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray.foldl_folder_none_eq_none {n✝ : Nat} {ls : List (Sat.Literal (PosFin n✝))} : List.foldl folder none ls = none

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray.mem_of_mem_of_foldl_folder_eq_some {n✝ : Nat} {acc : HashMap (PosFin n✝) Bool} {ls : List (Sat.Literal (PosFin n✝))} {acc' : HashMap (PosFin n✝) Bool} (h : List.foldl folder (some acc) ls = some acc') (l : PosFin n✝ × Bool) : l ∈ acc.toList → l ∈ acc'.toList

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray.folder_foldl_mem_of_mem {n✝ : Nat} {acc : Option (HashMap (PosFin n✝) Bool)} {ls : List (Sat.Literal (PosFin n✝))} {map : HashMap (PosFin n✝) Bool} (h : List.foldl folder acc ls = some map) (l : Sat.Literal (PosFin n✝)) : l ∈ ls → l ∈ map.toList

@[inline]

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.delete {n : Nat} (c : DefaultClause n) (l : Sat.Literal (PosFin n)) : DefaultClause n

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.delete_iff {n : Nat} (c : DefaultClause n) (l l' : Sat.Literal (PosFin n)) : l' ∈ (c.delete l).toList ↔ l' ≠ l ∧ l' ∈ c.toList

@[inline]

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.contains {n : Nat} (c : DefaultClause n) (l : Sat.Literal (PosFin n)) : Bool

theorem Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.contains_iff {n : Nat} (c : DefaultClause n) (l : Sat.Literal (PosFin n)) : c.contains l = true ↔ l ∈ c.toList

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.reduce_fold_fn {n : Nat} (assignments : Array Assignment) (acc : ReduceResult (PosFin n)) (l : Sat.Literal (PosFin n)) : ReduceResult (PosFin n)

def Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.reduce {n : Nat} (c : DefaultClause n) (assignments : Array Assignment) : ReduceResult (PosFin n)

The reduce function takes in a clause c and takes in an array of assignments and attempts to eliminate every literal in the clause that is not compatible with the assignments argument.

• If reduce returns encounteredBoth, then this means that the assignments array has a both Assignment and is therefore fundamentally unsatisfiable.
• If reduce returns reducedToEmpty, then this means that every literal in c is incompatible with assignments. In other words, this means that the conjunction of assignments and c is unsatisfiable.
• If reduce returns reducedToUnit l, then this means that every literal in c is incompatible with assignments except for l. In other words, this means that the conjunction of assignments and c entail l.
• If reduce returns reducedToNonunit, then this means that there are multiple literals in c that are compatible with assignments. This is a failure condition for confirmRupHint (in LRAT.Formula.Implementation.lean) which calls reduce.

@[implicit_reducible]

instance Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.instClausePosFin {n : Nat} : Clause (PosFin n) (DefaultClause n)