Search is not available for this dataset
name string | module string | type string |
|---|---|---|
_private.Init.Data.Iterators.Lemmas.Consumers.Collect.0.Std.Iterators.Iter.reverse_toListRev._simp_1_1 | Init.Data.Iterators.Lemmas.Consumers.Collect | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterators.Iterator α m β]
[inst_3 : Std.Iterators.Finite α m] [inst_4 : Std.Iterators.IteratorCollect α m m]
[Std.Iterators.LawfulIteratorCollect α m m] {it : Std.IterM m β}, it.toList = List.reverse <$> it.toListRev |
Lean.Meta.Grind.UnitLike.State.ctorIdx | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.UnitLike.State → Nat |
Int.add_neg | Init.Data.Int.Order | ∀ {a b : Int}, a < 0 → b < 0 → a + b < 0 |
Lean.Elab.Tactic.Do.Fuel.recOn | Lean.Elab.Tactic.Do.VCGen.Basic | {motive : Lean.Elab.Tactic.Do.Fuel → Sort u} →
(t : Lean.Elab.Tactic.Do.Fuel) →
((n : Nat) → motive (Lean.Elab.Tactic.Do.Fuel.limited n)) → motive Lean.Elab.Tactic.Do.Fuel.unlimited → motive t |
Int.instTransLe | Init.Data.Int.Order | Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 |
List.forIn_map | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} {init : γ} [inst : Monad m] [LawfulMonad m]
{l : List α} {g : α → β} {f : β → γ → m (ForInStep γ)},
forIn (List.map g l) init f = forIn l init fun a y => f (g a) y |
Int.natCast_toNat_eq_self | Init.Data.Int.LemmasAux | ∀ {a : Int}, ↑a.toNat = a ↔ 0 ≤ a |
Lean.AxiomVal.isUnsafeEx | Lean.Declaration | Lean.AxiomVal → Bool |
BitVec.not_or_self | Init.Data.BitVec.Lemmas | ∀ {w : Nat} (x : BitVec w), ~~~x ||| x = BitVec.allOnes w |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabLetE._sparseCasesOn_3 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(t.ctorIdx ≠ 8 → motive t) → motive t |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.splitStr._proof_1 | Lean.Server.FileWorker.SemanticHighlighting | ∀ (text : Lean.FileMap) (pos : String.Pos.Raw) (i : Nat),
i ∈ [(text.toPosition pos).line:text.positions.size] → i < text.positions.size |
Lean.Lsp.FoldingRangeParams.mk.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | ∀ (textDocument : Lean.Lsp.TextDocumentIdentifier), sizeOf { textDocument := textDocument } = 1 + sizeOf textDocument |
Std.IdempotentOp.idempotent | Init.Core | ∀ {α : Sort u} {op : α → α → α} [self : Std.IdempotentOp op] (x : α), op x x = x |
_private.Init.Data.Order.PackageFactories.0.Std.LinearPreorderPackage.ofOrd._simp_4 | Init.Data.Order.PackageFactories | ∀ {α : Type u} [inst : Ord α] [inst_1 : LE α] [Std.LawfulOrderOrd α] {a b : α}, ((compare a b).isGE = true) = (b ≤ a) |
Lean.Compiler.LCNF.Closure.State.rec | Lean.Compiler.LCNF.Closure | {motive : Lean.Compiler.LCNF.Closure.State → Sort u} →
((visited : Lean.FVarIdHashSet) →
(params : Array Lean.Compiler.LCNF.Param) →
(decls : Array Lean.Compiler.LCNF.CodeDecl) → motive { visited := visited, params := params, decls := decls }) →
(t : Lean.Compiler.LCNF.Closure.State) → motive t |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rcc.size_eq_if_roc._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxc.HasSize α]
[Std.Rxc.LawfulHasSize α] {lo hi : α}, (Std.Rxc.HasSize.size lo hi = 0) = ¬lo ≤ hi |
Lean.Grind.Linarith.lt_norm | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} [inst : Lean.Grind.IntModule α] [inst_1 : LE α] [inst_2 : LT α] [Std.LawfulOrderLT α]
[inst_4 : Std.IsPreorder α] [Lean.Grind.OrderedAdd α] (ctx : Lean.Grind.Linarith.Context α)
(lhs rhs : Lean.Grind.Linarith.Expr) (p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.norm_cert lhs rhs p = true →
Lean.Grind.Linarith.Expr.denote ctx lhs < Lean.Grind.Linarith.Expr.denote ctx rhs →
Lean.Grind.Linarith.Poly.denote' ctx p < 0 |
Lean.Grind.CommRing.Poly.degree | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly → Nat |
Lean.Meta.Simp.registerBuiltinSimproc | Lean.Meta.Tactic.Simp.Simproc | Lean.Name → Array Lean.Meta.SimpTheoremKey → Lean.Meta.Simp.Simproc → IO Unit |
Nat.reduceLeDiff._regBuiltin.Nat.reduceLeDiff.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.2466209926._hygCtx._hyg.24 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit |
Lean.Compiler.LCNF.ConfigOptions.mk | Lean.Compiler.LCNF.ConfigOptions | Nat → Nat → Nat → Bool → Bool → Lean.Compiler.LCNF.ConfigOptions |
Lean.Meta.Canonicalizer.CanonM.run' | Lean.Meta.Canonicalizer | {α : Type} →
Lean.Meta.CanonM α →
optParam Lean.Meta.TransparencyMode Lean.Meta.TransparencyMode.instances →
optParam Lean.Meta.Canonicalizer.State { } → Lean.MetaM α |
UInt8.ofFin | Init.Data.UInt.Basic | Fin UInt8.size → UInt8 |
Int32.ofIntLE_le_iff_le | Init.Data.SInt.Lemmas | ∀ {a b : Int} (ha₁ : Int32.minValue.toInt ≤ a) (ha₂ : a ≤ Int32.maxValue.toInt) (hb₁ : Int32.minValue.toInt ≤ b)
(hb₂ : b ≤ Int32.maxValue.toInt), Int32.ofIntLE a ha₁ ha₂ ≤ Int32.ofIntLE b hb₁ hb₂ ↔ a ≤ b |
Dyadic.neg.eq_1 | Init.Data.Dyadic.Basic | Dyadic.zero.neg = Dyadic.zero |
Lean.PrettyPrinter.Formatter.Context.mk.inj | Lean.PrettyPrinter.Formatter | ∀ {options : Lean.Options} {table : Lean.Parser.TokenTable} {options_1 : Lean.Options}
{table_1 : Lean.Parser.TokenTable},
{ options := options, table := table } = { options := options_1, table := table_1 } →
options = options_1 ∧ table = table_1 |
Lean.Lsp.instToJsonCodeActionClientCapabilities | Lean.Data.Lsp.CodeActions | Lean.ToJson Lean.Lsp.CodeActionClientCapabilities |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.mkPairs.loop | Lean.Elab.BuiltinNotation | Array Lean.Term → Nat → Lean.Term → Lean.MacroM Lean.Term |
Std.DTreeMap.Internal.Impl.getEntryLE!_eq_get!_getEntryLE? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α β} {k : α}
[inst_1 : Inhabited ((a : α) × β a)],
Std.DTreeMap.Internal.Impl.getEntryLE! k t = (Std.DTreeMap.Internal.Impl.getEntryLE? k t).get! |
_private.Lean.ReservedNameAction.0.Lean.initFn._@.Lean.ReservedNameAction.2721971034._hygCtx._hyg.2 | Lean.ReservedNameAction | IO (IO.Ref (Array Lean.ReservedNameAction)) |
BitVec.sshiftRight_xor_distrib | Init.Data.BitVec.Lemmas | ∀ {w : Nat} (x y : BitVec w) (n : Nat), (x ^^^ y).sshiftRight n = x.sshiftRight n ^^^ y.sshiftRight n |
Int.Linear.eq_def'_cert | Init.Data.Int.Linear | Int.Linear.Var → Int.Linear.Expr → Int.Linear.Poly → Bool |
UInt8.or_eq_zero_iff._simp_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt8}, (a ||| b = 0) = (a = 0 ∧ b = 0) |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} {k : Int} {c₁_1 c₂_1 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr}
{k_1 : Int},
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁ c₂ k =
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁_1 c₂_1 k_1 →
c₁ = c₁_1 ∧ c₂ = c₂_1 ∧ k = k_1 |
Lean.Meta.Grind.CongrKey.ctorIdx | Lean.Meta.Tactic.Grind.Types | {enodes : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodes → Nat |
Std.Internal.List.getKeyD_eq_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [LawfulBEq α] {l : List ((a : α) × β a)} {k fallback : α},
Std.Internal.List.containsKey k l = true → Std.Internal.List.getKeyD k l fallback = k |
_aux_Init_Notation___unexpand_Dvd_dvd_1 | Init.Notation | Lean.PrettyPrinter.Unexpander |
Std.DHashMap.Internal.Raw.fold_cons_key | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {l : Std.DHashMap.Raw α β} {acc : List α},
Std.DHashMap.Raw.fold (fun acc k x => k :: acc) acc l =
Std.Internal.List.keys (Std.DHashMap.Internal.toListModel l.buckets).reverse ++ acc |
Array.findIdx_extract | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {i : Nat} {p : α → Bool}, Array.findIdx p (xs.extract 0 i) = min i (Array.findIdx p xs) |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.mk.sizeOf_spec | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | ∀ (f fType : Lean.Expr) (args mvars : Array Lean.Expr) (bInfos : Array Lean.BinderInfo) (forceRegularApp : Bool),
sizeOf
{ f := f, fType := fType, args := args, mvars := mvars, bInfos := bInfos, forceRegularApp := forceRegularApp } =
1 + sizeOf f + sizeOf fType + sizeOf args + sizeOf mvars + sizeOf bInfos + sizeOf forceRegularApp |
Nat.lt_of_lt_of_eq | Init.Data.Nat.Basic | ∀ {n m k : Nat}, n < m → m = k → n < k |
Std.Iterators.IterM.step_filterMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β β' : Type w} {m : Type w → Type w'} [inst : Std.Iterators.Iterator α m β] {it : Std.IterM m β} [inst_1 : Monad m]
[LawfulMonad m] {f : β → Option β'},
(Std.Iterators.IterM.filterMap f it).step = do
let __do_lift ← it.step
match __do_lift.inflate with
| ⟨Std.Iterators.IterStep.yield it' out, h⟩ =>
match h' : f out with
| none =>
pure (Std.Shrink.deflate (Std.Iterators.PlausibleIterStep.skip (Std.Iterators.IterM.filterMap f it') ⋯))
| some out' =>
pure (Std.Shrink.deflate (Std.Iterators.PlausibleIterStep.yield (Std.Iterators.IterM.filterMap f it') out' ⋯))
| ⟨Std.Iterators.IterStep.skip it', h⟩ =>
pure (Std.Shrink.deflate (Std.Iterators.PlausibleIterStep.skip (Std.Iterators.IterM.filterMap f it') ⋯))
| ⟨Std.Iterators.IterStep.done, h⟩ => pure (Std.Shrink.deflate (Std.Iterators.PlausibleIterStep.done ⋯)) |
Lean.PrettyPrinter.Delaborator.OmissionReason.noConfusionType | Lean.PrettyPrinter.Delaborator.Basic | Sort u → Lean.PrettyPrinter.Delaborator.OmissionReason → Lean.PrettyPrinter.Delaborator.OmissionReason → Sort u |
Lean.Elab.Tactic.BVDecide.LRAT.trim.M.markUsed | Lean.Elab.Tactic.BVDecide.LRAT.Trim | Nat → Lean.Elab.Tactic.BVDecide.LRAT.trim.M Unit |
Lean.Lsp.instToJsonCompletionClientCapabilities.toJson | Lean.Data.Lsp.Capabilities | Lean.Lsp.CompletionClientCapabilities → Lean.Json |
dif_eq_if | Init.ByCases | ∀ (c : Prop) {h : Decidable c} {α : Sort u} (t e : α), (if x : c then t else e) = if c then t else e |
List.forall_getElem | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {p : α → Prop}, (∀ (i : Nat) (h : i < l.length), p l[i]) ↔ ∀ (a : α), a ∈ l → p a |
Std.HashSet.Raw.get?_union | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∪ m₂).get? k = (m₂.get? k).or (m₁.get? k) |
Lean.Meta.mkAuxTheorem | Lean.Meta.Closure | Lean.Expr →
Lean.Expr → optParam Bool false → optParam (Option Lean.Name) none → optParam Bool true → Lean.MetaM Lean.Expr |
Lean.Data.AC.EvalInformation.arbitrary | Init.Data.AC | {α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β |
_private.Init.PropLemmas.0.and_right_comm.match_1_1 | Init.PropLemmas | ∀ {a b c : Prop} (motive : (a ∧ b) ∧ c → Prop) (x : (a ∧ b) ∧ c), (∀ (ha : a) (hb : b) (hc : c), motive ⋯) → motive x |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.elabFunTarget.match_3 | Lean.Elab.Tactic.Induction | (motive : Lean.Meta.FunIndParamKind → Sort u_1) →
(kind : Lean.Meta.FunIndParamKind) →
(Unit → motive Lean.Meta.FunIndParamKind.dropped) →
(Unit → motive Lean.Meta.FunIndParamKind.param) → (Unit → motive Lean.Meta.FunIndParamKind.target) → motive kind |
Lean.Elab.Tactic.Do.SplitInfo | Lean.Elab.Tactic.Do.VCGen.Split | Type |
Lean.Elab.Term.Quotation.HeadInfo.casesOn | Lean.Elab.Quotation | {motive : Lean.Elab.Term.Quotation.HeadInfo → Sort u} →
(t : Lean.Elab.Term.Quotation.HeadInfo) →
((check : Lean.Elab.Term.Quotation.HeadCheck) →
(onMatch : Lean.Elab.Term.Quotation.HeadCheck → Lean.Elab.Term.Quotation.MatchResult) →
(doMatch :
(List Lean.Term → Lean.Elab.TermElabM Lean.Term) →
Lean.Elab.TermElabM Lean.Term → Lean.Elab.TermElabM Lean.Term) →
motive { check := check, onMatch := onMatch, doMatch := doMatch }) →
motive t |
Std.DTreeMap.Internal.Impl.size_containsThenInsert_eq_size | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [Ord α] (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.containsThenInsert.size t = t.size |
Int.tmod_eq_emod_of_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ {a b : Int}, 0 ≤ a → a.tmod b = a % b |
Lean.Meta.InductionSubgoal.mk | Lean.Meta.Tactic.Induction | Lean.MVarId → Array Lean.Expr → Lean.Meta.FVarSubst → Lean.Meta.InductionSubgoal |
_private.Lean.Server.CodeActions.Basic.0.Lean.Server.evalCodeActionProviderUnsafe | Lean.Server.CodeActions.Basic | {M : Type → Type} →
[Lean.MonadEnv M] →
[Lean.MonadOptions M] → [Lean.MonadError M] → [Monad M] → Lean.Name → M Lean.Server.CodeActionProvider |
_private.Init.Data.Range.Polymorphic.Iterators.0.Std.Rio.Internal.isPlausibleIndirectOutput_iter_iff._simp_1_1 | Init.Data.Range.Polymorphic.Iterators | ∀ {α : Type u} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : LT α} [self : Std.PRange.LawfulUpwardEnumerableLT α]
(a b : α), (a < b) = Std.PRange.UpwardEnumerable.LT a b |
Lean.Server.RequestHandler.mk.injEq | Lean.Server.Requests | ∀ (fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.FileIdent)
(handle : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse))
(fileSource_1 : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.FileIdent)
(handle_1 : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)),
({ fileSource := fileSource, handle := handle } = { fileSource := fileSource_1, handle := handle_1 }) =
(fileSource = fileSource_1 ∧ handle = handle_1) |
_private.Lean.Environment.0.Lean.Visibility.private.elim | Lean.Environment | {motive : Lean.Visibility✝ → Sort u} →
(t : Lean.Visibility✝¹) → Lean.Visibility.ctorIdx✝ t = 0 → motive Lean.Visibility.private✝ → motive t |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.bv_add | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | Lean.Meta.Simp.Simproc |
Std.DTreeMap.Internal.Impl.filter_eq_filter! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α β} {h : t.Balanced}
{f : (a : α) → β a → Bool}, (Std.DTreeMap.Internal.Impl.filter f t h).impl = Std.DTreeMap.Internal.Impl.filter! f t |
_private.Lean.Compiler.LCNF.PullFunDecls.0.Lean.Compiler.LCNF.PullFunDecls.attach.visit.match_1 | Lean.Compiler.LCNF.PullFunDecls | (motive : Lean.Compiler.LCNF.Code × Array Bool → Sort u_1) →
(x : Lean.Compiler.LCNF.Code × Array Bool) →
((k : Lean.Compiler.LCNF.Code) → (visited : Array Bool) → motive (k, visited)) → motive x |
Std.Internal.Parsec.pure | Std.Internal.Parsec.Basic | {α ι : Type} → α → Std.Internal.Parsec ι α |
Int8.toInt32_neg_of_ne | Init.Data.SInt.Lemmas | ∀ {x : Int8}, x ≠ -128 → (-x).toInt32 = -x.toInt32 |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.OfNatModule.0.Lean.Meta.Grind.Arith.Linear.ofNatModule'._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.OfNatModule | Lean.Expr → Lean.Meta.Grind.Arith.Linear.OfNatModuleM (Lean.Expr × Lean.Expr) |
_private.Lean.Elab.CheckTactic.0.Lean.Elab.CheckTactic.elabCheckTactic._sparseCasesOn_5 | Lean.Elab.CheckTactic | {α : Type u} → {motive : List α → Sort u_1} → (t : List α) → motive [] → (t.ctorIdx ≠ 0 → motive t) → motive t |
Std.DTreeMap.Internal.Impl.foldrM.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type u_1} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(init : δ), Std.DTreeMap.Internal.Impl.foldrM f init Std.DTreeMap.Internal.Impl.leaf = pure init |
Sum.getLeft.congr_simp | Init.Data.Sum.Basic | ∀ {α : Type u_1} {β : Type u_2} (ab ab_1 : α ⊕ β) (e_ab : ab = ab_1) (a : ab.isLeft = true),
ab.getLeft a = ab_1.getLeft ⋯ |
Lean.Grind.Linarith.eq_coeff_cert.eq_1 | Init.Grind.Ordered.Linarith | ∀ (p₁ p₂ : Lean.Grind.Linarith.Poly) (k : Nat), Lean.Grind.Linarith.eq_coeff_cert p₁ p₂ k = (k != 0 && p₁ == p₂.mul ↑k) |
Lean.Lsp.ParameterInformationLabel.range.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.ParameterInformationLabel → Sort u} →
(t : Lean.Lsp.ParameterInformationLabel) →
t.ctorIdx = 1 →
((startUtf16Offset endUtf16Offset : Nat) →
motive (Lean.Lsp.ParameterInformationLabel.range startUtf16Offset endUtf16Offset)) →
motive t |
Lean.Server.RpcEncodable.mk | Lean.Server.Rpc.Basic | {α : Type} →
(α → StateM Lean.Server.RpcObjectStore Lean.Json) →
(Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) α) → Lean.Server.RpcEncodable α |
Std.Internal.List.containsKey_of_perm | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l l' : List ((a : α) × β a)} {k : α},
l.Perm l' → Std.Internal.List.containsKey k l = Std.Internal.List.containsKey k l' |
BitVec.ushiftRight_eq'._simp_1 | Std.Tactic.BVDecide.Normalize.Canonicalize | ∀ {w₁ w₂ : Nat} (x : BitVec w₁) (y : BitVec w₂), x >>> y.toNat = x >>> y |
Lean.Parser.instInhabitedParserInfo.default | Lean.Parser.Types | Lean.Parser.ParserInfo |
Array.takeWhile_map | Init.Data.Array.Extract | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {p : β → Bool} {as : Array α},
Array.takeWhile p (Array.map f as) = Array.map f (Array.takeWhile (p ∘ f) as) |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpArgs.match_11 | Lean.Elab.Tactic.Simp | (motive : Lean.Elab.Tactic.ElabSimpArgResult → Sort u_1) →
(arg : Lean.Elab.Tactic.ElabSimpArgResult) →
((entries : Array Lean.Meta.SimpEntry) → motive (Lean.Elab.Tactic.ElabSimpArgResult.addEntries entries)) →
((fvarId : Lean.FVarId) → motive (Lean.Elab.Tactic.ElabSimpArgResult.addLetToUnfold fvarId)) →
((declName : Lean.Name) →
(post : Bool) → motive (Lean.Elab.Tactic.ElabSimpArgResult.addSimproc declName post)) →
((origin : Lean.Meta.Origin) → motive (Lean.Elab.Tactic.ElabSimpArgResult.erase origin)) →
((name : Lean.Name) → motive (Lean.Elab.Tactic.ElabSimpArgResult.eraseSimproc name)) →
((simpExt? : Option Lean.Meta.SimpExtension) →
(simprocExt? : Option Lean.Meta.Simp.SimprocExtension) →
(h : (simpExt?.isSome || simprocExt?.isSome) = true) →
motive (Lean.Elab.Tactic.ElabSimpArgResult.ext simpExt? simprocExt? h)) →
(Unit → motive Lean.Elab.Tactic.ElabSimpArgResult.star) →
(Unit → motive Lean.Elab.Tactic.ElabSimpArgResult.none) → motive arg |
Lean.Syntax.topDown | Lean.Syntax | Lean.Syntax → optParam Bool false → Lean.Syntax.TopDown |
List.eraseIdx_eq_self | Init.Data.List.Erase | ∀ {α : Type u_1} {l : List α} {k : Nat}, l.eraseIdx k = l ↔ l.length ≤ k |
Lean.Grind.IntModule.OfNatModule.r | Init.Grind.Module.Envelope | (α : Type u) → [Lean.Grind.NatModule α] → α × α → α × α → Prop |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorRefVecBlastClz | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Clz | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.RefVec fun {len} => Std.Tactic.BVDecide.BVExpr.bitblast.blastClz |
Option.any_none | Init.Data.Option.Basic | ∀ {α : Type u_1} {p : α → Bool}, Option.any p none = false |
Lean.Elab.enableInfoTree | Lean.Elab.InfoTree.Main | {m : Type → Type} → [Lean.Elab.MonadInfoTree m] → optParam Bool true → m Unit |
LLVM.CodegenFileType.ctorIdx | Lean.Compiler.IR.LLVMBindings | LLVM.CodegenFileType → Nat |
_private.Init.Data.SInt.Bitwise.0.Int8.not_eq_comm._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.expand.go.induct | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : Hashable α]
(motive : Nat → Array (Std.DHashMap.Internal.AssocList α β) → { d // 0 < d.size } → Prop),
(∀ (i : Nat) (source : Array (Std.DHashMap.Internal.AssocList α β)) (target : { d // 0 < d.size })
(h : i < source.size),
have es := source[i];
have source_1 := source.set i Std.DHashMap.Internal.AssocList.nil h;
have target_1 := Std.DHashMap.Internal.AssocList.foldl (Std.DHashMap.Internal.Raw₀.reinsertAux hash) target es;
motive (i + 1) source_1 target_1 → motive i source target) →
(∀ (i : Nat) (source : Array (Std.DHashMap.Internal.AssocList α β)) (target : { d // 0 < d.size }),
¬i < source.size → motive i source target) →
∀ (i : Nat) (source : Array (Std.DHashMap.Internal.AssocList α β)) (target : { d // 0 < d.size }),
motive i source target |
Std.Sat.AIG.RelabelNat.State.noConfusionType | Std.Sat.AIG.RelabelNat | {α : Type} →
[inst : DecidableEq α] →
[inst_1 : Hashable α] →
{decls : Array (Std.Sat.AIG.Decl α)} →
{idx : Nat} →
Sort u → Std.Sat.AIG.RelabelNat.State α decls idx → Std.Sat.AIG.RelabelNat.State α decls idx → Sort u |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.AssocList.foldrM.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(x : δ) (a : α) (b : β a) (es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldrM f x (Std.DHashMap.Internal.AssocList.cons a b es) = do
let d ← Std.DHashMap.Internal.AssocList.foldrM f x es
f a b d |
_private.Lean.Compiler.CSimpAttr.0.Lean.Compiler.CSimp.isConstantReplacement?._sparseCasesOn_1 | Lean.Compiler.CSimpAttr | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (t.ctorIdx ≠ 1 → motive t) → motive t |
Std.Sat.AIG.denote_idx_gate | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {start : Nat} {assign : α → Bool} {invert : Bool}
{lhs rhs : Std.Sat.AIG.Fanin} {aig : Std.Sat.AIG α} {hstart : start < aig.decls.size}
(h : aig.decls[start] = Std.Sat.AIG.Decl.gate lhs rhs),
⟦assign, { aig := aig, ref := { gate := start, invert := invert, hgate := hstart } }⟧ =
(⟦assign, { aig := aig, ref := { gate := lhs.gate, invert := lhs.invert, hgate := ⋯ } }⟧ &&
⟦assign, { aig := aig, ref := { gate := rhs.gate, invert := rhs.invert, hgate := ⋯ } }⟧ ^^
invert) |
Int.gcd_sub_right_right_of_dvd | Init.Data.Int.Gcd | ∀ {n k : Int} (m : Int), n ∣ k → n.gcd (m - k) = n.gcd m |
Lean.Meta.coeDeclAttr._regBuiltin.Lean.Meta.coeDeclAttr.declRange_3 | Lean.Meta.Coe | IO Unit |
Lean.Compiler.LCNF.Phase.le_refl._simp_1 | Lean.Compiler.LCNF.PassManager | ∀ (p : Lean.Compiler.LCNF.Phase), (p ≤ p) = True |
BitVec.reverse.eq_1 | Init.Data.BitVec.Lemmas | ∀ (x_2 : BitVec 0), x_2.reverse = x_2 |
Lean.Compiler.LCNF.SpecEntry.mk.sizeOf_spec | Lean.Compiler.LCNF.SpecInfo | ∀ (declName : Lean.Name) (paramsInfo : Array Lean.Compiler.LCNF.SpecParamInfo),
sizeOf { declName := declName, paramsInfo := paramsInfo } = 1 + sizeOf declName + sizeOf paramsInfo |
Std.DTreeMap.Internal.Impl.get?ₘ_eq_getValueCast? | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : Std.LawfulEqOrd α] [inst_3 : BEq α]
[inst_4 : Std.LawfulBEqOrd α] {k : α} {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get?ₘ k = Std.Internal.List.getValueCast? k t.toListModel |
_private.Init.Data.Slice.List.Lemmas.0.Std.Slice.List.instLawfulSliceSizeListSliceData._simp_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u} {s : ListSlice α}, Std.Iterators.ToIterator.iter s = Std.Slice.Internal.iter s |
Lean.Meta.Tactic.Backtrack.BacktrackConfig.discharge._default | Lean.Meta.Tactic.Backtrack | Lean.MVarId → Lean.MetaM (Option (List Lean.MVarId)) |
Std.Tactic.BVDecide.LRAT.Internal.Clause.isUnit | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : outParam (Type u)} →
{β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] → β → Option (Std.Sat.Literal α) |
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 24