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
- 212