Proof Assistant Projects
Collection
Digesting proof assistant libraries for AI ingestion. • 84 items • Updated • 3
fact stringlengths 4 7.31k | type stringclasses 10
values | library stringclasses 3
values | imports listlengths 0 35 | filename stringclasses 124
values | symbolic_name stringlengths 1 63 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
runDuperOnTPTP(fileName : String) (formulas : List (Expr × Expr × Array Name × Bool)) (instanceMaxHeartbeats : Nat) : MetaM Unit := do
let generateDatatypeExhaustivenessFacts ← getCollectDataTypesM
let state ←
withNewMCtxDepth do
let formulas ← unfoldDefinitions (formulas.map (fun (e, proof, paramNames, i... | def | root | [
"import Duper",
"import Duper.TPTP",
"import Duper.TPTPParser.PrattParser"
] | Main.lean | runDuperOnTPTP | |
run(path : String) (_github : Bool) : MetaM Unit := do
let prop := mkSort levelZero
let type := mkSort levelOne
let sortu := mkSort (.param `u)
let sortu1 := mkSort (.param `u1)
let sortu2 := mkSort (.param `u2)
addDecl (.axiomDecl {name := `Nat, levelParams := [], type := type, isUnsafe := false})
addDec... | def | root | [
"import Duper",
"import Duper.TPTP",
"import Duper.TPTPParser.PrattParser"
] | Main.lean | run | |
main: List String → IO UInt32 := fun args => do
if args.length == 0 then
println! "Please provide problem file."
return 1
else
let env ← mkEmptyEnvironment
let github := (args.length > 1 && args[1]! == "--github")
let maxHeartbeats := if github then 50 * 1000 * 1000 else 0
let _ ← Meta.MetaM... | def | root | [
"import Duper",
"import Duper.TPTP",
"import Duper.TPTPParser.PrattParser"
] | Main.lean | main | |
backwardSimpRules: ProverM (Array BackwardSimpRule) := do
let subsumptionTrie ← getSubsumptionTrie
return #[
(backwardDemodulation (← getDemodMainPremiseIdx)).toBackwardSimpRule,
(backwardClauseSubsumption subsumptionTrie).toBackwardSimpRule,
(backwardEqualitySubsumption subsumptionTrie).toBackwardSimpR... | def | Duper | [
"import Duper.ProverM",
"import Duper.Simp",
"import Duper.Rules.ClauseSubsumption",
"import Duper.Rules.ContextualLiteralCutting",
"import Duper.Rules.Demodulation",
"import Duper.Rules.EqualitySubsumption",
"import Duper.Rules.SimplifyReflect"
] | Duper/BackwardSimplification.lean | backwardSimpRules | |
backwardSimplify(givenClause : Clause) : ProverM Unit := do
trace[duper.prover.saturate] "backward simplify with {givenClause}"
let backwardSimpRules ← backwardSimpRules
for i in [0 : backwardSimpRules.size] do
let simpRule := backwardSimpRules[i]!
simpRule givenClause | def | Duper | [
"import Duper.ProverM",
"import Duper.Simp",
"import Duper.Rules.ClauseSubsumption",
"import Duper.Rules.ContextualLiteralCutting",
"import Duper.Rules.Demodulation",
"import Duper.Rules.EqualitySubsumption",
"import Duper.Rules.SimplifyReflect"
] | Duper/BackwardSimplification.lean | backwardSimplify | |
Litwhere
sign : Bool
lvl : Level
ty : Expr
lhs : Expr
rhs : Expr
deriving Inhabited, BEq, Hashable | structure | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | Lit | |
LitSide| lhs | rhs
deriving Inhabited, BEq, Hashable | inductive | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | LitSide | |
Lit.toString(l : Lit) :=
ToString.toString l.lhs ++ if l.sign then " = " else " ≠ " ++ ToString.toString l.rhs | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | Lit.toString | |
LitSide.format(ls : LitSide) : MessageData :=
match ls with
| lhs => m!"lhs"
| rhs => m!"rhs" | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | LitSide.format | |
toggleSide(side : LitSide) : LitSide := match side with
| LitSide.lhs => LitSide.rhs
| LitSide.rhs => LitSide.lhs | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | toggleSide | |
LitPoswhere
side : LitSide
pos : ExprPos
deriving Inhabited, BEq, Hashable | structure | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | LitPos | |
toExpr(lit : Lit) : Expr :=
if lit.sign
then mkApp3 (mkConst ``Eq [lit.lvl]) lit.ty lit.lhs lit.rhs
else mkApp3 (mkConst ``Ne [lit.lvl]) lit.ty lit.lhs lit.rhs | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | toExpr | |
fromSingleExpr(e : Expr) (sign := true) : Lit :=
Lit.mk
(sign := true)
(lvl := levelOne)
(ty := mkSort levelZero)
(lhs := Expr.consumeMData e)
(rhs := if sign then mkConst ``True else mkConst ``False) | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | fromSingleExpr | |
fromExpr: Expr → Lit
| .app (.app (.app (.const ``Eq lvl) ty) lhs) rhs =>
⟨true, lvl[0]!, ty, lhs, rhs⟩
| .app (.app (.app (.const ``Ne lvl) ty) lhs) rhs =>
⟨false, lvl[0]!, ty, lhs, rhs⟩
| e@(_) => dbg_trace "Lit.fromExpr :: Unexpected Expression: {e}"; Lit.fromSingleExpr e | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | fromExpr | |
map(f : Expr → Expr) (l : Lit) :=
-- Should we really map into `ty`?
{l with ty := f l.ty, lhs := f l.lhs, rhs := f l.rhs} | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | map | |
instantiateLevelParamsArray(l : Lit) (paramNames : Array Name) (levels : Array Level) :=
{l with lvl := l.lvl.instantiateParams paramNames.toList levels.toList
ty := l.ty.instantiateLevelParamsArray paramNames levels
lhs := l.lhs.instantiateLevelParamsArray paramNames levels
rhs := l.rhs... | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | instantiateLevelParamsArray | |
mapWithPos(f : Expr → Expr × Array ExprPos) (l : Lit) :=
let (l', lposes) := f l.lhs
let (r', rposes) := f l.rhs
-- Does not map into `ty`
let lit' := {l with lhs := l', rhs := r'}
let lp' := lposes.map (fun p => LitPos.mk .lhs p)
let rp' := rposes.map (fun p => LitPos.mk .rhs p)
(lit', lp' ++ rp') | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | mapWithPos | |
mapMWithPos[Monad m] [MonadLiftT MetaM m] (f : Expr → m (Expr × Array ExprPos)) (l : Lit) : m (Lit × Array LitPos) := do
let (l', lposes) ← f l.lhs
let (r', rposes) ← f l.rhs
-- Does not map into `ty`
let lit' := {l with lhs := l', rhs := r'}
let lp' := lposes.map (fun p => LitPos.mk .lhs p)
let rp' := rpos... | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | mapMWithPos | |
mapByPos(f : Expr → Array ExprPos → Expr) (l : Lit) (poses : Array LitPos) := Id.run <| do
let mut lposes := #[]
let mut rposes := #[]
for ⟨side, pos⟩ in poses do
if side == .lhs then
lposes := lposes.push pos
else
rposes := rposes.push pos
-- Does not map into `ty`
let l' := f l.lhs lpose... | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | mapByPos | |
mapMByPos[Monad m] [MonadLiftT MetaM m] (f : Expr → Array ExprPos → m Expr) (l : Lit) (poses : Array LitPos) : m Lit := do
let mut lposes := #[]
let mut rposes := #[]
for ⟨side, pos⟩ in poses do
if side == .lhs then
lposes := lposes.push pos
else
rposes := rposes.push pos
-- Does not map int... | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | mapMByPos | |
mapM{m : Type → Type w} [Monad m] (f : Expr → m Expr) (l : Lit) : m Lit := do
return {l with ty := ← f l.ty, lhs := ← f l.lhs, rhs := ← f l.rhs} | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | mapM | |
fold{α : Type v} (f : α → Expr → α) (init : α) (l : Lit) : α :=
f (f init l.lhs) l.rhs | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | fold | |
foldWithTypeM{β : Type v} {m : Type v → Type w} [Monad m]
(f : β → Expr → m β) (init : β) (l : Lit) : m β := do
f (← f (← f init l.ty) l.lhs) l.rhs | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | foldWithTypeM | |
foldM{β : Type v} {m : Type v → Type w} [Monad m]
(f : β → Expr → LitPos → m β) (init : β) (l : Lit) : m β := do
f (← f init l.lhs ⟨LitSide.lhs, ExprPos.empty⟩) l.rhs ⟨LitSide.rhs, ExprPos.empty⟩ | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | foldM | |
foldGreenM{β : Type} [Monad m] [MonadLiftT MetaM m]
(f : β → Expr → LitPos → m β) (init : β) (l : Lit) : m β := do
let fLhs := fun acc e p => f acc e ⟨LitSide.lhs, p⟩
let fRhs := fun acc e p => f acc e ⟨LitSide.rhs, p⟩
l.rhs.foldGreenM fRhs (← l.lhs.foldGreenM fLhs init) | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | foldGreenM | |
getAtPos! [Monad m] [MonadLiftT MetaM m] (l : Lit) (pos : LitPos) : m Expr :=
match pos.side with
| LitSide.lhs => l.lhs.getAtPos! pos.pos
| LitSide.rhs => l.rhs.getAtPos! pos.pos | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | getAtPos | |
replaceAtPos? [Monad m] [MonadLiftT MetaM m] (l : Lit) (pos : LitPos) (replacement : Expr) : m (Option Lit) := do
match pos.side with
| LitSide.lhs =>
match ← l.lhs.replaceAtPos? pos.pos replacement with
| some newLhs => return some {l with lhs := newLhs}
| none => return none
| LitSide.rhs =>
mat... | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | replaceAtPos | |
replaceAtPosUpdateType? (l : Lit) (pos : LitPos) (replacement : Expr) : MetaM (Option Lit) := do
let repPos ← replaceAtPos! l pos replacement
try
let ty ← Meta.inferType repPos.lhs
let sort ← Meta.inferType ty
let sortReduced ← Meta.reduce sort false false true
if ! sortReduced.isSort then
tra... | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | replaceAtPosUpdateType | |
abstractAtPos! (l : Lit) (pos : LitPos) : MetaM Lit := do
match pos.side with
| LitSide.lhs => return {l with lhs := ← l.lhs.abstractAtPos! pos.pos}
| LitSide.rhs => return {l with rhs := ← l.rhs.abstractAtPos! pos.pos} | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | abstractAtPos | |
symm(l : Lit) : Lit :=
{l with
lhs := l.rhs
rhs := l.lhs} | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | symm | |
makeLhs(lit : Lit) (side : LitSide) := match side with
| LitSide.lhs => lit
| LitSide.rhs => lit.symm | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | makeLhs | |
getSide(lit : Lit) (side : LitSide) := match side with
| LitSide.lhs => lit.lhs
| LitSide.rhs => lit.rhs | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | getSide | |
getOtherSide(lit : Lit) (side : LitSide) := getSide lit (LitSide.toggleSide side) | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | getOtherSide | |
compare(ord : Expr → Expr → Bool → MetaM Comparison) (alreadyReduced : Bool) (l₁ l₂ : Lit) : MetaM Comparison := do
let l₁ ←
if alreadyReduced then pure l₁
else l₁.mapM (fun e => betaEtaReduceInstMVars e)
let l₂ ←
if alreadyReduced then pure l₂
else l₂.mapM (fun e => betaEtaReduceInstMVars e)
let... | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | compare | |
Clausewhere
(paramNames : Array Name)
(bVarTypes : Array Expr)
(lits : Array Lit)
deriving Inhabited, BEq, Hashable | structure | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | Clause | |
ClausePosextends LitPos where
lit : Nat
deriving Inhabited, BEq, Hashable | structure | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | ClausePos | |
ClausePos.format(pos : ClausePos) : MessageData :=
m!"\{lit: {pos.lit}, side: {pos.side}, ExprPos: {pos.pos}}" | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | ClausePos.format | |
empty: Clause := ⟨#[], #[], #[]⟩ | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | empty | |
litsToExpr: List Lit → Expr
| [] => mkConst ``False
| [l] => l.toExpr
| l :: ls => mkApp2 (mkConst ``Or) l.toExpr (litsToExpr ls) | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | litsToExpr | |
mapMUpdateType[instMonad : Monad m] (c : Clause) (f : Expr → m Expr) := do
let bVarTypes ← c.bVarTypes.mapM f
let lits ← c.lits.mapM (Lit.mapM f)
return {c with bVarTypes := bVarTypes, lits := lits} | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | mapMUpdateType | |
toForallExpr(c : Clause) : Expr :=
c.bVarTypes.foldr (fun ty b => mkForall Name.anonymous BinderInfo.default ty b) c.toExpr | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | toForallExpr | |
toLambdaExpr(c : Clause) : Expr :=
c.bVarTypes.foldr (fun ty b => mkLambda Name.anonymous BinderInfo.default ty b) c.toExpr | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | toLambdaExpr | |
fromForallExpr(paramNames : Array Name) (e : Expr) : Clause :=
let (bvarTypes, e) := deForall e
⟨paramNames, bvarTypes.toArray, (litsFromExpr e).toArray⟩
where
deForall : Expr → List Expr × Expr
| .forallE _ ty body _ => let (l, e) := deForall body; (ty::l, e)
| e@(_) => ([], e)
litsFromExpr : Expr → List L... | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | fromForallExpr | |
weight(c : Clause) : Nat :=
c.lits.foldl (fun acc lit => acc + lit.lhs.weight + lit.rhs.weight) 0
/-- Determines the precedence clause `c` should have for clause selection. Lower values indicate higher precedence -/ | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | weight | |
selectionPrecedence(c : Clause) (goalDistance : Nat) : Nat :=
/- TODO: Experiment with different coefficients for c.weight and goalDistance. Zipperposition's goal_oriented
clause selection function has (among other heuristics) c.weight given a coefficient of 4 and goalDistance given
a coefficient of 1 (mean... | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | selectionPrecedence | |
ClauseAndClausePos.format(c : Clause × ClausePos) : MessageData :=
m!"({c.1}, {c.2})" | def | Duper | [
"import Lean",
"import Duper.Util.Misc",
"import Duper.Expr",
"import Duper.Order"
] | Duper/Clause.lean | ClauseAndClausePos.format | |
kFair:= 70 | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | kFair | |
kBest:= 3 | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | kBest | |
kHighest:= 10
register_option forceProbeRetry : Nat := {
defValue := 500
descr := "Iteration limit for forceProbe"
} | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | kHighest | |
getForceProbeRetry(opts : Options) : Nat :=
forceProbeRetry.get opts | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | getForceProbeRetry | |
logForceProbeRetry(max : Nat) : CoreM Unit := do
let msg := s!"forceProbe exceeded iteration limit {max}"
logInfo msg
register_option kStep : Nat := {
defValue := 40
descr := "Maximum steps a unification problem can take before it's postponed"
}
-- Clause Streams
-- The first `Clause` is the (simplified)Give... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | logForceProbeRetry | |
ClauseProof:= Clause × Clause × RuleM.Proof | abbrev | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | ClauseProof | |
ClauseStream.takeAsProverM(cs : ClauseStream)
: ProverM (Option ((Option ClauseProof) × ClauseStream)) := do
-- No more unification problem left
if cs.ug.isEmpty then
return none
let (opu, ug') ← cs.ug.takeWithRetry (kStep.get (← getOptions))
if let some u := opu then
let res ← ProverM.runRuleM <| do
... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | ClauseStream.takeAsProverM | |
penalty(c : Clause) : ProverM Nat := pure 1 | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | penalty | |
updateWeight(α? : Option ClauseProof) (weight : Nat) (nProbed : Nat) : ProverM Nat := do
if let some (clause, _) := α? then
return weight + (← penalty clause) * Nat.max 1 (nProbed - 64)
else
return weight + Nat.max 2 (nProbed - 16)
/-- Following `Making Higher-Order Superposition Work`.
Extract an `Opt... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | updateWeight | |
ClauseStreamHeap.extractClause{σ} [OptionMStream ProverM σ ClauseProof]
(Q : ClauseStreamHeap σ) (nProbed : Nat) (precs : Array Nat) (s : σ) : ProverM (Option ClauseProof × ClauseStreamHeap σ) := do
have : Inhabited σ := ⟨s⟩
let next? ← MStream.next? s
if let some (α?, stream') := next? then
-- If this stre... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | ClauseStreamHeap.extractClause | |
ClauseStreamHeap.heuristicProbe{σ} [OptionMStream ProverM σ ClauseProof]
(Q : ClauseStreamHeap σ) : ProverM (Array ClauseProof × ClauseStreamHeap σ) := do
let mut collectedClauses := #[]
let mut highestStream := #[]
let mut Q := Q
for _ in List.range kHighest do
let res := Q.deleteMinWithNProbed 0
if ... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | ClauseStreamHeap.heuristicProbe | |
ClauseStreamHeap.fairProbe{σ} [OptionMStream ProverM σ ClauseProof]
(nOldest : Nat) (Q : ClauseStreamHeap σ) : ProverM (Array ClauseProof × ClauseStreamHeap σ) := do
let mut collectedClauses := #[]
let mut oldestStream := #[]
let mut Q := Q
for _ in List.range nOldest do
-- Delete min from age heap
le... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | ClauseStreamHeap.fairProbe | |
ProverM.postProcessInferenceResult(cp : ClauseProof) : ProverM Unit := do
let (given, c, proof) := cp
let allClauses ← getAllClauses
let parentClauseInfoOpts ← proof.parents.mapM
(fun p =>
match allClauses.get? p.clause with
| some pi => pure pi
| none => throwError "ProverM.postProcessInfer... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | ProverM.postProcessInferenceResult | |
ProverM.performInferences(rules : List (Clause → MClause → Nat → RuleM (Array ClauseStream))) (given : Clause) : ProverM Unit := do
trace[duper.prover.saturate] "perform inference with given clause {given}"
let mut cs := #[]
let cInfo ← getClauseInfo! given
let cNum := cInfo.number
for rule in rules do
le... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | ProverM.performInferences | |
ProverM.runProbe(probe : ClauseStreamHeap ClauseStream → ProverM (Array ClauseProof × ClauseStreamHeap ClauseStream)) := do
let Q ← getQStreamSet
let (arrcp, Q') ← probe Q
setQStreamSet Q'
let _ ← arrcp.mapM ProverM.postProcessInferenceResult
/-- We have to repeatedly call `runProbe` and test `(← getPassiveSet... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | ProverM.runProbe | |
ProverM.runForceProbe: ProverM Unit := do
let maxIter := getForceProbeRetry (← getOptions)
let mut fpiter := 0
while (← getQStreamSet).size != 0 ∧ (← getPassiveSet).isEmpty do
runProbe (ClauseStreamHeap.fairProbe (← getQStreamSet).size)
fpiter := fpiter + 1
if fpiter >= maxIter then
... | def | Duper | [
"import Batteries.Data.BinomialHeap",
"import Duper.Util.IdStrategyHeap",
"import Duper.Clause",
"import Duper.DUnif.UnifRules",
"import Duper.ProverM",
"import Lean"
] | Duper/ClauseStreamHeap.lean | ProverM.runForceProbe | |
Keywhere
| const : Name → Nat → Key
| fvar : FVarId → Nat → Key
| lit : Literal → Key
| star : Key
| other : Key
| arrow : Key
| proj : Name → Nat → Key
deriving Inhabited, BEq, Repr | inductive | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | Key | |
Key.hash: Key → UInt64
| Key.const n a => mixHash 5237 $ mixHash (hash n) (hash a)
| Key.fvar n a => mixHash 3541 (hash a) --$ mixHash (hash n) (hash a)
| Key.lit v => mixHash 1879 $ hash v
| Key.star => 7883
| Key.other => 2411
| Key.arrow => 17
| Key.proj s i => mixHash 11 $ mixHash (... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | Key.hash | |
Trie(α : Type) where
| node (vs : Array α) (children : Array (Key × Trie α)) : Trie α
/- The filterSet argument is a temporary hack to simulate deletions from the discrimination tree. If that turns
out to be too slow though, I'll have to remove it and rewrite delete to actually remove elements from the tree -/ | inductive | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | Trie | |
DiscrTree(α : Type) where
root : PersistentHashMap Key (Trie α) := {}
filterSet : HashSet Clause := {} -- Keeps track of the set of clauses that should be filtered out (i.e. "removed" clauses) | structure | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | DiscrTree | |
Key.ctorIdx: Key → Nat
| Key.star => 0
| Key.other => 1
| Key.lit .. => 2
| Key.fvar .. => 3
| Key.const .. => 4
| Key.arrow => 5
| Key.proj .. => 6 | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | Key.ctorIdx | |
Key.lt: Key → Key → Bool
| Key.lit v₁, Key.lit v₂ => v₁ < v₂
| Key.fvar n₁ a₁, Key.fvar n₂ a₂ => a₁ < a₂ -- Name.quickLt n₁.name n₂.name || (n₁ == n₂ && a₁ < a₂)
| Key.const n₁ a₁, Key.const n₂ a₂ => Name.quickLt n₁ n₂ || (n₁ == n₂ && a₁ < a₂)
| Key.proj s₁ i₁, Key.proj s₂ i₂ => Name.quickLt s₁ s₂... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | Key.lt | |
Key.format: Key → Format
| Key.star => "*"
| Key.other => "◾"
| Key.lit (Literal.natVal v) => Std.format v
| Key.lit (Literal.strVal v) => repr v
| Key.const k _ => Std.format k
| Key.proj s i => Std.format s ++ "." ++ Std.format i
| Key.fvar k... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | Key.format | |
Key.arity: Key → Nat
| Key.const _ a => a
| Key.fvar _ a => a
| Key.arrow => 2
| Key.proj .. => 1
| _ => 0 | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | Key.arity | |
empty: DiscrTree α := { root := {} } | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | empty | |
Trie.format[ToMessageData α] : Trie α → MessageData
| Trie.node vs cs => MessageData.group $ MessageData.paren $
"node" ++ (if vs.isEmpty then MessageData.nil else " " ++ toMessageData vs)
++ MessageData.joinSep (cs.toList.map $ fun ⟨k, c⟩ => MessageData.paren (toMessageData k ++ " => " ++ format c)) "," | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | Trie.format | |
Trie.formatClause: Trie (Clause × α) → MessageData
| Trie.node vs cs => MessageData.group $ MessageData.paren $
"node" ++ (if vs.isEmpty then MessageData.nil else " " ++ toMessageData (Array.map (fun x => x.1) vs))
++ MessageData.joinSep (cs.toList.map $ fun ⟨k, c⟩ => MessageData.paren (toMessageData k ++ " =... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | Trie.formatClause | |
format[ToMessageData α] (d : DiscrTree α) : MessageData :=
let (_, r) := d.root.foldl
(fun (p : Bool × MessageData) k c =>
(false, p.2 ++ MessageData.paren (toMessageData k ++ " => " ++ toMessageData c)))
(true, Format.nil)
MessageData.group r | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | format | |
formatClauses(d : DiscrTree (Clause × α)) : MessageData :=
let (_, r) := d.root.foldl
(fun (p : Bool × MessageData) k c =>
(false, p.2 ++ MessageData.paren (toMessageData k ++ " => " ++ toMessageData c)))
(true, Format.nil)
MessageData.group r | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | formatClauses | |
tmpMVarId: MVarId := { name := `_discr_tree_tmp } | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | tmpMVarId | |
tmpStar:= mkMVar tmpMVarId | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | tmpStar | |
ignoreArg(a : Expr) (i : Nat) (infos : Array Meta.ParamInfo) : RuleM Bool := do
if h : i < infos.size then
let info := infos.get ⟨i, h⟩
if info.isInstImplicit then
return true
else if info.isImplicit || info.isStrictImplicit then
return not (← Meta.isType a)
else
return false -- Prev... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | ignoreArg | |
mkNoindexAnnotation(e : Expr) : Expr :=
mkAnnotation `noindex e | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | mkNoindexAnnotation | |
hasNoindexAnnotation(e : Expr) : Bool :=
annotation? `noindex e |>.isSome | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | hasNoindexAnnotation | |
pushArgs(root : Bool) (todo : Array Expr) (e : Expr) : RuleM (Key × Array Expr) := do
if hasNoindexAnnotation e then
return (Key.star, todo)
else
let fn := e.getAppFn
let push (k : Key) (nargs : Nat) : RuleM (Key × Array Expr) := do
let info ← Meta.getFunInfoNArgs fn nargs
let todo ← pushArg... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | pushArgs | |
mkPathAux(root : Bool) (todo : Array Expr) (keys : Array Key) : RuleM (Array Key) := do
if todo.isEmpty then
return keys
else
let e := todo.back
let todo := todo.pop
let (k, todo) ← pushArgs root todo e
mkPathAux false todo (keys.push k) | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | mkPathAux | |
initCapacity:= 8 | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | initCapacity | |
mkPath(e : Expr) : RuleM (Array Key) := do
let todo : Array Expr := Array.mkEmpty initCapacity
let keys : Array Key := Array.mkEmpty initCapacity
mkPathAux (root := true) (todo.push e) keys
private partial def createNodes (keys : Array Key) (v : α) (i : Nat) : Trie α :=
if h : i < keys.size then
let k := ... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | mkPath | |
insertVal[BEq α] (vs : Array α) (v : α) : Array α :=
if vs.contains v then vs else vs.push v
private partial def insertAux [BEq α] (keys : Array Key) (v : α) : Nat → Trie α → Trie α
| i, Trie.node vs cs =>
if h : i < keys.size then
let k := keys.get ⟨i, h⟩
let c := Id.run $ cs.binInsertM
... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | insertVal | |
insertCore[BEq α] (d : DiscrTree α) (keys : Array Key) (v : α) : DiscrTree α :=
if keys.isEmpty then panic! "invalid key sequence"
else
let k := keys[0]!
match d.root.find? k with
| none =>
let c := createNodes keys v 1
{ d with root := d.root.insert k c }
| some c =>
let c := inse... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | insertCore | |
insert[BEq α] (d : DiscrTree α) (e : Expr) (v : α) : RuleM (DiscrTree α) := do
let keys ← mkPath e
return d.insertCore keys v
-/ | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | insert | |
getKeyArgs(e : Expr) (isMatch root : Bool) : RuleM (Key × Array Expr) := do
match e.getAppFn with
| Expr.lit v => return (Key.lit v, #[])
| Expr.const c _ =>
let nargs := e.getAppNumArgs
return (Key.const c nargs, e.getAppRevArgs)
| Expr.fvar fvarId =>
let nargs := e.getAppNumArgs
return... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | getKeyArgs | |
getMatchKeyArgs(e : Expr) (root : Bool) : RuleM (Key × Array Expr) :=
getKeyArgs e (isMatch := true) (root := root) | abbrev | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | getMatchKeyArgs | |
getUnifyKeyArgs(e : Expr) (root : Bool) : RuleM (Key × Array Expr) :=
getKeyArgs e (isMatch := false) (root := root) | abbrev | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | getUnifyKeyArgs | |
getStarResult(d : DiscrTree α) : Array α :=
let result : Array α := Array.mkEmpty initCapacity
match d.root.find? Key.star with
| none => result
| some (Trie.node vs _) => result ++ vs | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | getStarResult | |
findKey(cs : Array (Key × Trie α)) (k : Key) : Option (Key × Trie α) :=
cs.binSearch (k, default) (fun a b => a.1 < b.1)
private partial def getMatchLoop (todo : Array Expr) (c : Trie α) (result : Array α) : RuleM (Array α) := do
match c with
| Trie.node vs cs =>
if todo.isEmpty then
return result ++ v... | abbrev | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | findKey | |
getMatchRoot(d : DiscrTree α) (k : Key) (args : Array Expr) (result : Array α) : RuleM (Array α) :=
match d.root.find? k with
| none => return result
| some c => getMatchLoop args c result
private partial def getMatch' (d : DiscrTree α) (e : Expr) : RuleM (Array α) := do
Core.checkMaxHeartbeats "getMatch"
... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | getMatchRoot | |
getMatch(d : DiscrTree (Clause × α)) (e : Expr) : RuleM (Array (Clause × α)) := do
let unfiltered_result ← getMatch' d e
let filterSet := d.filterSet
return Array.filter (fun c => not (filterSet.contains c.1)) unfiltered_result
private partial def getUnify' (d : DiscrTree α) (e : Expr) : RuleM (Array α) := do
... | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | getMatch | |
getUnify(d : DiscrTree (Clause × α)) (e : Expr) : RuleM (Array (Clause × α)) := do
let unfiltered_result ← getUnify' d e
let filterSet := d.filterSet
return Array.filter (fun c => not (filterSet.contains c.1)) unfiltered_result | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | getUnify | |
delete(d : DiscrTree α) (c : Clause) : RuleM (DiscrTree α) := do
let root := d.root
let filterSet := d.filterSet.insert c
return { root := root, filterSet := filterSet } | def | Duper | [
"import Lean",
"import Duper.RuleM"
] | Duper/DiscrTree.lean | delete | |
ExprPos:= Array Nat | abbrev | Duper | [
"import Lean"
] | Duper/Expr.lean | ExprPos | |
empty: ExprPos := #[] | def | Duper | [
"import Lean"
] | Duper/Expr.lean | empty | |
hasAnyMVar(e : Expr) (p : MVarId → Bool) : Bool :=
let rec @[specialize] visit (e : Expr) := if !e.hasMVar then false else
match e with
| Expr.forallE _ d b _ => visit d || visit b
| Expr.lam _ d b _ => visit d || visit b
| Expr.mdata _ e => visit e
| Expr.letE _ t v b _ => visi... | def | Duper | [
"import Lean"
] | Duper/Expr.lean | hasAnyMVar | |
isMVar'(e : Expr) := e.consumeMData.isMVar
/-- Given `t` and `b`, determines whether `.forallE _ t b _` is an implication -/ | def | Duper | [
"import Lean"
] | Duper/Expr.lean | isMVar' |
End of preview. Expand in Data Studio
Lean4-Duper
Structured declarations from Duper - a proof-producing superposition theorem prover for Lean 4. Source: github.com/leanprover-community/duper
Schema
| Column | Type | Description |
|---|---|---|
fact |
string | Declaration body (without type keyword) |
type |
string | Declaration type (Lemma, Definition, etc.) |
library |
string | Source module |
imports |
list | Import statements |
filename |
string | Source file path |
symbolic_name |
string | Declaration identifier |
Statistics
- Total entries: 1556
- Unique files: 124
- Declaration types: abbrev, axiom, class, def, inductive, instance, lemma, opaque, structure, theorem
Usage
from datasets import load_dataset
ds = load_dataset("phanerozoic/Lean4-Duper")
License
apache-2.0
- Downloads last month
- 13