name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.ExtDTreeMap.Const.get! | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{β : Type v} → [Std.TransCmp cmp] → [Inhabited β] → Std.ExtDTreeMap α (fun x => β) cmp → α → β |
Filter.Realizer.cofinite | Mathlib.Data.Analysis.Filter | {α : Type u_1} → [DecidableEq α] → Filter.cofinite.Realizer |
CategoryTheory.IsPushout.isVanKampen_iff | Mathlib.CategoryTheory.Adhesive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z}
(H : CategoryTheory.IsPushout f g h i),
H.IsVanKampen ↔ CategoryTheory.IsVanKampenColimit (CategoryTheory.Limits.PushoutCocone.mk h i ⋯) |
CochainComplex.mappingConeCompTriangle._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ : CochainComplex C ℤ} (f : X₁ ⟶ X₂),
HomologicalComplex.HasHomotopyCofiber f |
sup_eq_of_isMaxOn | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup β] [inst_1 : OrderBot β] {D : α → β} {s : Finset α} {a : α},
a ∈ s → IsMaxOn D (↑s) a → s.sup D = D a |
Lean.Lsp.CompletionClientCapabilities.rec | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.CompletionClientCapabilities → Sort u} →
((completionItem? : Option Lean.Lsp.CompletionItemCapabilities) → motive { completionItem? := completionItem? }) →
(t : Lean.Lsp.CompletionClientCapabilities) → motive t |
ULift.normedRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : NormedRing α] (x y : ULift.{u_1, u_2} α), dist x y = ‖-x + y‖ |
CategoryTheory.MonoidalCategory.DayConvolutionUnit.instIsLeftKanExtensionProdDiscretePUnitExternalProductExtensionUnitLeftφ | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
(U : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolutionUnit U]
(F : CategoryTheory.Functor C V)
[∀ (v : V) (d : C),
CategoryTheory.Limits.PreservesColimitsOfShape
(CategoryTheory.CostructuredArrow
(CategoryTheory.Functor.fromPUnit (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) d)
(CategoryTheory.MonoidalCategory.tensorRight v)],
(CategoryTheory.MonoidalCategory.externalProduct U F).IsLeftKanExtension
(CategoryTheory.MonoidalCategory.ExternalProduct.extensionUnitLeft U
(CategoryTheory.MonoidalCategory.DayConvolutionUnit.φ U) F) |
Std.Broadcast.Sync.Receiver.recv | Std.Sync.Broadcast | {α : Type} → [Inhabited α] → Std.Broadcast.Sync.Receiver α → BaseIO (Option α) |
Lean.Lsp.InlayHintOptions.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{toWorkDoneProgressOptions : Lean.Lsp.WorkDoneProgressOptions} →
{resolveProvider? : Option Bool} →
{toWorkDoneProgressOptions' : Lean.Lsp.WorkDoneProgressOptions} →
{resolveProvider?' : Option Bool} →
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions, resolveProvider? := resolveProvider? } =
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions', resolveProvider? := resolveProvider?' } →
(toWorkDoneProgressOptions = toWorkDoneProgressOptions' → resolveProvider? = resolveProvider?' → P) → P |
CategoryTheory.ShiftedHom.homEquiv | Mathlib.CategoryTheory.Shift.ShiftedHom | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{M : Type u_4} →
[inst_1 : AddMonoid M] →
[inst_2 : CategoryTheory.HasShift C M] →
{X Y : C} → (m₀ : M) → m₀ = 0 → (X ⟶ Y) ≃ CategoryTheory.ShiftedHom X Y m₀ |
_private.Mathlib.Order.Filter.Cofinite.0.Filter.coprodᵢ_cofinite._simp_1_1 | Mathlib.Order.Filter.Cofinite | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : Set ((i : ι) → α i)},
(sᶜ ∈ Filter.coprodᵢ f) = ∀ (i : ι), (Function.eval i '' s)ᶜ ∈ f i |
DerivedCategory.instIsTriangulated | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C], CategoryTheory.IsTriangulated (DerivedCategory C) |
EuclideanGeometry.concyclic_singleton | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (p : P), EuclideanGeometry.Concyclic {p} |
_private.Mathlib.Logic.Denumerable.0.Nat.Subtype.le_succ_of_forall_lt_le._proof_1_2 | Mathlib.Logic.Denumerable | ∀ {s : Set ℕ} [inst : DecidablePred fun x => x ∈ s] {y : ↑s} (hx : ∃ m, ↑y + m + 1 ∈ s), ↑y < ↑y + Nat.find hx + 1 |
_private.Mathlib.Data.ZMod.Basic.0.Nat.range_mul_add._simp_1_6 | Mathlib.Data.ZMod.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0) |
sInf_add | Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice | ∀ {M : Type u_1} [inst : CompleteLattice M] [inst_1 : AddGroup M] [AddLeftMono M] [AddRightMono M] (s t : Set M),
sInf (s + t) = sInf s + sInf t |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.toNat_toInt_add_one_sub_toInt.match_1_1 | Init.Data.Range.Polymorphic.SInt | ∀ (motive : (n : ℕ) → {lo hi : BitVec n} → n > 0 → Prop) (n : ℕ) {lo hi : BitVec n} (h : n > 0),
(∀ (lo hi : BitVec 0) (h : 0 > 0), motive 0 h) →
(∀ (n : ℕ) (lo hi : BitVec (n + 1)) (h : n + 1 > 0), motive n.succ h) → motive n h |
_private.Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor.0.CategoryTheory.MonoidalCategory.DayFunctor.hom_ext._proof_1_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {V : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] {F G : CategoryTheory.MonoidalCategory.DayFunctor C V}
(natTrans natTrans_1 : F.functor ⟶ G.functor),
{ natTrans := natTrans }.natTrans = { natTrans := natTrans_1 }.natTrans →
{ natTrans := natTrans } = { natTrans := natTrans_1 } |
CategoryTheory.Adjunction.mkOfUnitCounit._proof_2 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : CategoryTheory.Adjunction.CoreUnitCounit F G) (Y : D),
CategoryTheory.CategoryStruct.comp (adj.unit.app (G.obj Y)) (G.map (adj.counit.app Y)) =
CategoryTheory.CategoryStruct.id (G.obj Y) |
AEMeasurable.snd | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
[inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {f : α → β × γ},
AEMeasurable f μ → AEMeasurable (fun x => (f x).2) μ |
not_injective_infinite_finite | Mathlib.Data.Fintype.EquivFin | ∀ {α : Sort u_4} {β : Sort u_5} [Infinite α] [Finite β] (f : α → β), ¬Function.Injective f |
Lean.Parser.Command.importPath | Lean.Parser.Command | Lean.Parser.Parser |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.go._unary._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w n : ℕ} (aig : Std.Sat.AIG α) (distance : aig.RefVec n)
(curr : ℕ) (acc : aig.RefVec w),
curr < n - 1 →
∀
(this :
aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.twoPowShift aig
{ n := n, lhs := acc, rhs := distance, pow := curr + 1 }).aig.decls.size),
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSigma.casesOn x fun aig distance =>
PSigma.casesOn distance fun distance curr => PSigma.casesOn curr fun curr acc => n - 1 - curr)
⟨(Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.twoPowShift aig
{ n := n, lhs := acc, rhs := distance, pow := curr + 1 }).aig,
⟨distance.cast this,
⟨curr + 1,
(Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.twoPowShift aig
{ n := n, lhs := acc, rhs := distance, pow := curr + 1 }).vec⟩⟩⟩
⟨aig, ⟨distance, ⟨curr, acc⟩⟩⟩ |
IsSl2Triple.HasPrimitiveVectorWith.mk._flat_ctor | Mathlib.Algebra.Lie.Sl2 | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {h e f : L} {t : IsSl2Triple h e f} {m : M} {μ : R},
m ≠ 0 → ⁅h, m⁆ = μ • m → ⁅e, m⁆ = 0 → t.HasPrimitiveVectorWith m μ |
toIcoDiv_ofNat_mul_add | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℕ) [inst_4 : m.AtLeastTwo],
toIcoDiv hp a (OfNat.ofNat m * p + b) = OfNat.ofNat m + toIcoDiv hp a b |
Stream'.Seq.BisimO._sparseCasesOn_2.else_eq | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Stream'.Seq.BisimO._sparseCasesOn_2 t some «else» = «else» h |
FreeAddGroup.instAddGroup._proof_8 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (n : ℕ) (a : FreeAddGroup α), zsmulRec nsmulRec (↑n.succ) a = zsmulRec nsmulRec (↑n) a + a |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification.0.NumberField.InfinitePlace._aux_Mathlib_NumberTheory_NumberField_InfinitePlace_Ramification___unexpand_MulAction_stabilizer_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | Lean.PrettyPrinter.Unexpander |
ZSpan.quotientEquiv_apply_mk | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] (x : E),
(ZSpan.quotientEquiv b) (Submodule.Quotient.mk x) = ZSpan.fractRestrict b x |
iteratedDeriv_fun_const_zero | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {x : 𝕜}, iteratedDeriv n (fun x => 0) x = 0 |
SeparationQuotient.instCommSemigroup._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : CommSemigroup M] [inst_2 : ContinuousMul M] (a b : M),
SeparationQuotient.mk (a * b) = SeparationQuotient.mk a * SeparationQuotient.mk b |
Bornology.isCobounded_compl_iff | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {x : Bornology α} {s : Set α}, Bornology.IsCobounded sᶜ ↔ Bornology.IsBounded s |
Lean.Elab.Do.ControlStack.mk.injEq | Lean.Elab.Do.Control | ∀ (description : Unit → Lean.MessageData) (m : Lean.Elab.Do.DoElabM Lean.Expr)
(stM runInBase : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr)
(restoreCont : Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont)
(description_1 : Unit → Lean.MessageData) (m_1 : Lean.Elab.Do.DoElabM Lean.Expr)
(stM_1 runInBase_1 : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr)
(restoreCont_1 : Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont),
({ description := description, m := m, stM := stM, runInBase := runInBase, restoreCont := restoreCont } =
{ description := description_1, m := m_1, stM := stM_1, runInBase := runInBase_1,
restoreCont := restoreCont_1 }) =
(description = description_1 ∧ m = m_1 ∧ stM = stM_1 ∧ runInBase = runInBase_1 ∧ restoreCont = restoreCont_1) |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitQuotLift | Lean.Compiler.LCNF.ToLCNF | Lean.Expr → Lean.Compiler.LCNF.ToLCNF.M (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) |
Batteries.Tactic.tactic_ | Batteries.Tactic.Init | Lean.ParserDescr |
Lean.Compiler.LCNF.Check.Pure.checkParams | Lean.Compiler.LCNF.Check | Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) → Lean.Compiler.LCNF.Check.Pure.CheckM Unit |
Valuation.leSubmodule_zero | Mathlib.RingTheory.Valuation.Integers | ∀ {Γ₀ : Type v} [inst : LinearOrderedCommGroupWithZero Γ₀] (K : Type u_1) [inst_1 : Field K] (v : Valuation K Γ₀),
v.leSubmodule 0 = ⊥ |
CategoryTheory.ReflQuiver.mk | Mathlib.Combinatorics.Quiver.ReflQuiver | {obj : Type u} → [toQuiver : Quiver obj] → ((X : obj) → X ⟶ X) → CategoryTheory.ReflQuiver obj |
Real.arsinh_bijective | Mathlib.Analysis.SpecialFunctions.Arsinh | Function.Bijective Real.arsinh |
AddMonoidHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : Mᵃᵒᵖ →+ Nᵃᵒᵖ) (a : M),
(AddMonoidHom.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a |
Submonoid.mk_eq_top._simp_2 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] (toSubsemigroup : Subsemigroup M) (one_mem' : 1 ∈ toSubsemigroup.carrier),
({ toSubsemigroup := toSubsemigroup, one_mem' := one_mem' } = ⊤) = (toSubsemigroup = ⊤) |
Lean.Compiler.LCNF.CtorFieldInfo.object.inj | Lean.Compiler.LCNF.ToImpureType | ∀ {i : ℕ} {type : Lean.Expr} {i_1 : ℕ} {type_1 : Lean.Expr},
Lean.Compiler.LCNF.CtorFieldInfo.object i type = Lean.Compiler.LCNF.CtorFieldInfo.object i_1 type_1 →
i = i_1 ∧ type = type_1 |
Std.Internal.List.Const.containsKey_filterMap | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [EquivBEq α] {β : Type v} {γ : Type w} {f : α → β → Option γ} {l : List ((_ : α) × β)}
{k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k (List.filterMap (fun p => Option.map (fun x => ⟨p.fst, x⟩) (f p.fst p.snd)) l) =
if h : Std.Internal.List.containsKey k l = true then
(f (Std.Internal.List.getKey k l h) (Std.Internal.List.getValue k l h)).isSome
else false |
Lean.Parser.Command.notationItem.formatter | Lean.Parser.Syntax | Lean.PrettyPrinter.Formatter |
CategoryTheory.Limits.LimitPresentation.noConfusionType | Mathlib.CategoryTheory.Limits.Presentation | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
CategoryTheory.Limits.LimitPresentation J X →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{J' : Type w} →
[inst'_1 : CategoryTheory.Category.{t, w} J'] →
{X' : C'} → CategoryTheory.Limits.LimitPresentation J' X' → Sort u_1 |
Cardinal.lt_one_iff_zero | Mathlib.SetTheory.Cardinal.Basic | ∀ {c : Cardinal.{u_1}}, c < 1 ↔ c = 0 |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.SpectrumRestricts.nnreal_iff_spectralRadius_le._simp_1_2 | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_6} [inst : CompleteLattice α] {a : α} {f : (i : ι) → κ i → α},
(⨆ i, ⨆ j, f i j ≤ a) = ∀ (i : ι) (j : κ i), f i j ≤ a |
IsLocalization.exist_integer_multiples_of_finite | Mathlib.RingTheory.Localization.Integer | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] {ι : Type u_4} [Finite ι] (f : ι → S),
∃ b, ∀ (i : ι), IsLocalization.IsInteger R (↑b • f i) |
_private.Mathlib.Data.Set.List.0.Option.getD.match_1.eq_1 | Mathlib.Data.Set.List | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (x : α) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match some x with
| some x => h_1 x
| none => h_2 ()) =
h_1 x |
CategoryTheory.Functor.exact_tfae | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
[∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).ShortExact,
∀ (S : CategoryTheory.ShortComplex C), S.Exact → (S.map F).Exact, F.PreservesHomology,
CategoryTheory.Limits.PreservesFiniteLimits F ∧ CategoryTheory.Limits.PreservesFiniteColimits F].TFAE |
Std.IterM.step_intermediateDropWhile | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
{it : Std.IterM m β} {P : β → Bool} {dropping : Bool},
(Std.IterM.Intermediate.dropWhile P dropping it).step = do
let __do_lift ← it.step
match __do_lift.inflate with
| ⟨Std.IterStep.yield it' out, h⟩ =>
if h' : dropping = true then
match hP : P out with
| true =>
pure (Std.Shrink.deflate (Std.PlausibleIterStep.skip (Std.IterM.Intermediate.dropWhile P true it') ⋯))
| false =>
pure (Std.Shrink.deflate (Std.PlausibleIterStep.yield (Std.IterM.Intermediate.dropWhile P false it') out ⋯))
else
pure (Std.Shrink.deflate (Std.PlausibleIterStep.yield (Std.IterM.Intermediate.dropWhile P false it') out ⋯))
| ⟨Std.IterStep.skip it', h⟩ =>
pure (Std.Shrink.deflate (Std.PlausibleIterStep.skip (Std.IterM.Intermediate.dropWhile P dropping it') ⋯))
| ⟨Std.IterStep.done, h⟩ => pure (Std.Shrink.deflate (Std.PlausibleIterStep.done ⋯)) |
Filter.Germ.instAddMonoid._proof_6 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_2} [inst : AddMonoid M] (a : l.Germ M), a + 0 = a |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabUsingElabFnsAux._sunfold | Lean.Elab.Term.TermElabM | Lean.Elab.Term.SavedState →
Lean.Syntax →
Option Lean.Expr →
Bool → List (Lean.KeyedDeclsAttribute.AttributeEntry Lean.Elab.Term.TermElab) → Lean.Elab.TermElabM Lean.Expr |
Isometry.preimage_closedBall | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
Isometry f → ∀ (x : α) (r : ℝ), f ⁻¹' Metric.closedBall (f x) r = Metric.closedBall x r |
Lean.Lsp.FileEvent.noConfusion | Lean.Data.Lsp.Workspace | {P : Sort u} → {t t' : Lean.Lsp.FileEvent} → t = t' → Lean.Lsp.FileEvent.noConfusionType P t t' |
Nat.ascFactorial._sunfold | Mathlib.Data.Nat.Factorial.Basic | ℕ → ℕ → ℕ |
CategoryTheory.GrothendieckTopology.rec | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.GrothendieckTopology C → Sort u_1} →
((sieves : (X : C) → Set (CategoryTheory.Sieve X)) →
(top_mem' : ∀ (X : C), ⊤ ∈ sieves X) →
(pullback_stable' :
∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve X⦄ (f : Y ⟶ X),
S ∈ sieves X → CategoryTheory.Sieve.pullback f S ∈ sieves Y) →
(transitive' :
∀ ⦃X : C⦄ ⦃S : CategoryTheory.Sieve X⦄,
S ∈ sieves X →
∀ (R : CategoryTheory.Sieve X),
(∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → CategoryTheory.Sieve.pullback f R ∈ sieves Y) →
R ∈ sieves X) →
motive
{ sieves := sieves, top_mem' := top_mem', pullback_stable' := pullback_stable',
transitive' := transitive' }) →
(t : CategoryTheory.GrothendieckTopology C) → motive t |
Lean.Elab.Tactic.evalSimpAllArith._regBuiltin.Lean.Elab.Tactic.evalSimpAllArith_1 | Lean.Elab.Tactic.SimpArith | IO Unit |
UpperSet.completeLattice._proof_8 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], (⇑OrderDual.toDual ∘ SetLike.coe) ⊥ = (⇑OrderDual.toDual ∘ SetLike.coe) ⊥ |
Std.Sat.CNF.sat_relabel | Std.Sat.CNF.Relabel | ∀ {α : Type u_1} {β : Type u_2} {r1 : β → Bool} {r2 : α → β} {f : Std.Sat.CNF α},
Std.Sat.CNF.Sat (r1 ∘ r2) f → Std.Sat.CNF.Sat r1 (Std.Sat.CNF.relabel r2 f) |
Fin.castLE._proof_1 | Init.Data.Fin.Basic | ∀ {n m : ℕ}, n ≤ m → ∀ (i : Fin n), ↑i < m |
CoheytingHom.instFunLike._proof_1 | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] (f g : CoheytingHom α β),
(fun f => f.toFun) f = (fun f => f.toFun) g → f = g |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.instReprCongrArgKind.repr.match_1 | Lean.Meta.CongrTheorems | (motive : Lean.Meta.CongrArgKind → Sort u_1) →
(x : Lean.Meta.CongrArgKind) →
(Unit → motive Lean.Meta.CongrArgKind.fixed) →
(Unit → motive Lean.Meta.CongrArgKind.fixedNoParam) →
(Unit → motive Lean.Meta.CongrArgKind.eq) →
(Unit → motive Lean.Meta.CongrArgKind.cast) →
(Unit → motive Lean.Meta.CongrArgKind.heq) →
(Unit → motive Lean.Meta.CongrArgKind.subsingletonInst) → motive x |
Set.Countable.setOf_finite | Mathlib.Data.Set.Countable | ∀ {α : Type u} [Countable α], {s | s.Finite}.Countable |
_private.Mathlib.Combinatorics.SetFamily.LYM.0.Finset.slice_union_shadow_falling_succ._simp_1_1 | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) |
Lean.Exception.isInterrupt | Lean.Exception | Lean.Exception → Bool |
Lean.Grind.isLE | Init.Grind.Offset | ℕ → ℕ → Bool |
ValuationSubring.principalUnitGroupEquiv._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K) (x : ↥A.principalUnitGroup),
(fun x => ⟨↑(A.unitGroupMulEquiv.symm ↑x), ⋯⟩) ((fun x => ⟨A.unitGroupMulEquiv ⟨↑x, ⋯⟩, ⋯⟩) x) = x |
Aesop.Frontend.RuleExpr | Aesop.Frontend.RuleExpr | Type |
GroupTopology.instTop | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u} → [inst : Group α] → Top (GroupTopology α) |
PartitionOfUnity.le_one | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : PartitionOfUnity ι X s) (i : ι) (x : X),
(f i) x ≤ 1 |
ContDiffMapSupportedIn.toBoundedContinuousFunctionLM._proof_5 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
Continuous ⇑f |
_private.Mathlib.LinearAlgebra.QuadraticForm.Basic.0.QuadraticMap.map_sum._simp_1_2 | Mathlib.LinearAlgebra.QuadraticForm.Basic | (¬True) = False |
MeasureTheory.MemLp.norm_rpow_div | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f : α → E},
MeasureTheory.MemLp f p μ → ∀ (q : ENNReal), MeasureTheory.MemLp (fun x => ‖f x‖ ^ q.toReal) (p / q) μ |
Std.Iter.toList_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.drop n it).toList = List.drop n it.toList |
ContDiffMapSupportedInClass.instContinuousMapClass | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (B : Type u_5) (E : outParam (Type u_6)) (F : outParam (Type u_7)) [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ E] [inst_3 : NormedSpace ℝ F] (n : outParam ℕ∞)
(K : outParam (TopologicalSpace.Compacts E)) [inst_4 : ContDiffMapSupportedInClass B E F n K],
ContinuousMapClass B E F |
tsum_setProd_singleton_left | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (b : β)
(t : Set γ) (f : β × γ → α), ∑' (x : ↑({b} ×ˢ t)), f ↑x = ∑' (c : ↑t), f (b, ↑c) |
Set.centralizer_centralizer_centralizer | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] (S : Set M), S.centralizer.centralizer.centralizer = S.centralizer |
instIsBoundedSMulSeparationQuotient | Mathlib.Topology.MetricSpace.Algebra | ∀ {α : Type u_4} {β : Type u_5} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : Zero α]
[inst_3 : Zero β] [inst_4 : SMul α β] [inst_5 : IsBoundedSMul α β], IsBoundedSMul α (SeparationQuotient β) |
CategoryTheory.Monad.algebraFunctorOfMonadHomId._proof_5 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T₁ : CategoryTheory.Monad C} {X Y : T₁.Algebra}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.id T₁)).map f)
((fun X =>
CategoryTheory.Monad.Algebra.isoMk
(CategoryTheory.Iso.refl
((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.id T₁)).obj X).A)
⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X =>
CategoryTheory.Monad.Algebra.isoMk
(CategoryTheory.Iso.refl
((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.id T₁)).obj X).A)
⋯)
X).hom
((CategoryTheory.Functor.id T₁.Algebra).map f) |
Std.TreeSet.Raw.get?_eq_some_getD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {a fallback : α}, a ∈ t → t.get? a = some (t.getD a fallback) |
CategoryTheory.AsSmall.abelian | Mathlib.CategoryTheory.Abelian.Transfer | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Abelian C] → CategoryTheory.Abelian (CategoryTheory.AsSmall C) |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.size_eq_if_roo._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxo.HasSize α]
[Std.Rxo.LawfulHasSize α] {lo hi : α}, (Std.Rxo.HasSize.size lo hi = 0) = ¬lo < hi |
Finset.truncatedInf_union | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : SemilatticeInf α] {s t : Finset α} {a : α} [inst_1 : DecidableLE α] [inst_2 : BoundedOrder α]
[inst_3 : DecidableEq α],
a ∈ upperClosure ↑s → a ∈ upperClosure ↑t → (s ∪ t).truncatedInf a = s.truncatedInf a ⊓ t.truncatedInf a |
GenContFract.succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} {n : ℕ} {s : Stream'.Seq (GenContFract.Pair K)} [inst : DivisionRing K],
GenContFract.convs'Aux s (n + 2) = GenContFract.convs'Aux (GenContFract.squashSeq s n) (n + 1) |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.matchAtomic | Lean.Server.Completion.CompletionCollectors | Lean.Name → Lean.Name → Bool → Bool |
UniformSpace.Completion.instNormedRing._proof_15 | Mathlib.Analysis.Normed.Module.Completion | ∀ (A : Type u_1) [inst : SeminormedRing A] (n : ℕ) (x : UniformSpace.Completion A),
Semiring.npow (n + 1) x = Semiring.npow n x * x |
ByteArray.extract_eq_extract_iff_getElem | Init.Data.ByteArray.Lemmas | ∀ {as bs : ByteArray} {i j len : ℕ} (hi : i + len ≤ as.size) (hj : j + len ≤ bs.size),
as.extract i (i + len) = bs.extract j (j + len) ↔ ∀ (k : ℕ) (hk : k < len), as[i + k] = bs[j + k] |
Std.Tactic.BVDecide.BVBinPred.eval | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {w : ℕ} → Std.Tactic.BVDecide.BVBinPred → BitVec w → BitVec w → Bool |
expandLemma | Mathlib.Tactic.Lemma | Lean.Macro |
ByteArray.toList.loop._unary.eq_def | Init.Data.ByteArray.Basic | ∀ (bs : ByteArray) (_x : (_ : ℕ) ×' List UInt8),
ByteArray.toList.loop._unary bs _x =
PSigma.casesOn _x fun i r =>
if i < bs.size then ByteArray.toList.loop._unary bs ⟨i + 1, bs.get! i :: r⟩ else r.reverse |
TwoUniqueSums.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_2} (G : ι → Type u_1) [inst : (i : ι) → Add (G i)] [∀ (i : ι), TwoUniqueSums (G i)],
TwoUniqueSums ((i : ι) → G i) |
EuclideanGeometry.Sphere.IsExtTangentAt.mem_left | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s₁ s₂ : EuclideanGeometry.Sphere P} {p : P}, s₁.IsExtTangentAt s₂ p → p ∈ s₁ |
Qq.Impl.isIrrefutablePattern | Qq.Match | Lean.Term → Bool |
_private.Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated.0.MeasurableSpace.CountablySeparated.mono._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α],
MeasurableSpace.CountablySeparated α = HasCountableSeparatingOn α MeasurableSet Set.univ |
Int.getElem!_toArray_roo | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, (m<...n).toArray[i]! = if i < (n - (m + 1)).toNat then m + 1 + ↑i else 0 |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_1 | Init.Data.String.FindPos | ∀ (s : String.Slice), ∀ offset ≤ s.rawEndPos, ¬String.Pos.Raw.IsValidForSlice s offset → offset < s.rawEndPos |
Subrepresentation.mk._flat_ctor | Mathlib.RepresentationTheory.Subrepresentation | {A : Type u_1} →
{G : Type u_2} →
{W : Type u_3} →
[inst : CommRing A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid W] →
[inst_3 : Module A W] →
{ρ : Representation A G W} →
(toSubmodule : Submodule A W) →
(∀ (g : G) ⦃v : W⦄, v ∈ toSubmodule → (ρ g) v ∈ toSubmodule) → Subrepresentation ρ |
Lean.VersoModuleDocs.Snippet.mk.injEq | Lean.DocString.Extension | ∀ (text : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(sections : Array (ℕ × Lean.DeclarationRange × Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty))
(declarationRange : Lean.DeclarationRange) (text_1 : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(sections_1 : Array (ℕ × Lean.DeclarationRange × Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty))
(declarationRange_1 : Lean.DeclarationRange),
({ text := text, sections := sections, declarationRange := declarationRange } =
{ text := text_1, sections := sections_1, declarationRange := declarationRange_1 }) =
(text = text_1 ∧ sections = sections_1 ∧ declarationRange = declarationRange_1) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.