name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.WalkingMultispan.instFintype | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | {J : CategoryTheory.Limits.MultispanShape} →
[Fintype J.L] → [Fintype J.R] → Fintype (CategoryTheory.Limits.WalkingMultispan J) | true |
ReaderT | Init.Prelude | Type u → (Type u → Type v) → Type u → Type (max u v) | true |
ULift.addGroup._proof_5 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : AddGroup α] (x : ULift.{u_1, u_2} α) (x_1 : ℕ), Equiv.ulift (x_1 • x) = Equiv.ulift (x_1 • x) | false |
ISize.toInt_minValue | Init.Data.SInt.Lemmas | ISize.minValue.toInt = -2 ^ (System.Platform.numBits - 1) | true |
WittVector.map_verschiebung | Mathlib.RingTheory.WittVector.Verschiebung | ∀ {p : ℕ} {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [hp : Fact (Nat.Prime p)]
(f : R →+* S) (x : WittVector p R),
(WittVector.map f) (WittVector.verschiebung x) = WittVector.verschiebung ((WittVector.map f) x) | true |
NonUnitalSubring.ofClass._proof_2 | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {S : Type u_2} {R : Type u_1} [inst : NonUnitalNonAssocRing R] [inst_1 : SetLike S R] [NonUnitalSubringClass S R]
(s : S), 0 ∈ s | false |
Lean.IR.SimpleGroundExpr.noConfusionType | Lean.Compiler.IR.SimpleGroundExpr | Sort u → Lean.IR.SimpleGroundExpr → Lean.IR.SimpleGroundExpr → Sort u | false |
Seminorm.rescale_to_shell_zpow | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
(p : Seminorm 𝕜 E) {c : 𝕜},
1 < ‖c‖ →
∀ {ε : ℝ},
0 < ε →
∀ {x : E}, p x ≠ 0 → ∃ n, c ^ n ≠ 0 ∧ p (c ^ n • x) < ε ∧ ε / ‖c‖ ≤ p (c ^ n • x) ∧ ‖c ^ n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x | true |
Filter.mem_comap'' | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : Filter β} {s : Set α}, s ∈ Filter.comap f l ↔ Set.kernImage f s ∈ l | true |
Finsets | Mathlib.SetTheory.Lists | Type u_2 → Type u_2 | true |
CategoryTheory.coalgebraEquivOver._proof_1 | Mathlib.CategoryTheory.Monad.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C)
[inst_1 : CategoryTheory.Limits.HasBinaryProducts C] (A : (CategoryTheory.prodComonad X).Coalgebra),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.prodComonad X).Coalgebr... | false |
Lean.Parser.Attr.tactic_tag._regBuiltin.Lean.Parser.Attr.tactic_tag.docString_3 | Lean.Parser.Attr | IO Unit | false |
_private.Lean.Meta.FunInfo.0.Lean.Meta.FunInfoEnvCacheKey.noConfusionType | Lean.Meta.FunInfo | Sort u → Lean.Meta.FunInfoEnvCacheKey✝ → Lean.Meta.FunInfoEnvCacheKey✝ → Sort u | false |
Quantale.noConfusionType | Mathlib.Algebra.Order.Quantale | Sort u →
{α : Type u_1} →
[inst : Semigroup α] →
[inst_1 : CompleteLattice α] →
[inst_2 : IsQuantale α] →
Quantale α →
{α' : Type u_1} →
[inst' : Semigroup α'] → [inst'_1 : CompleteLattice α'] → [inst'_2 : IsQuantale α'] → Quantale α' → Sort u | false |
Set.EqOn.mapsTo_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f₁ f₂ : α → β},
Set.EqOn f₁ f₂ s → (Set.MapsTo f₁ s t ↔ Set.MapsTo f₂ s t) | true |
FinBddDistLat.toBddDistLat | Mathlib.Order.Category.FinBddDistLat | FinBddDistLat → BddDistLat | true |
Equiv.lpPiLp._proof_1 | Mathlib.Analysis.Normed.Lp.LpEquiv | ∀ {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] {p : ENNReal} [inst_1 : Finite α],
Function.LeftInverse (fun f => ⟨f.ofLp, ⋯⟩) fun f => WithLp.toLp p ↑f | false |
Nat.exists_strictAnti | Mathlib.Order.Monotone.Basic | ∀ (α : Type u) [inst : Preorder α] [Nonempty α] [NoMinOrder α], ∃ f, StrictAnti f | true |
USize.toBitVec_shiftRight | Init.Data.UInt.Bitwise | ∀ (a b : USize), (a >>> b).toBitVec = a.toBitVec >>> (b.toBitVec % ↑System.Platform.numBits) | true |
modelWithCornersEuclideanHalfSpace._proof_11 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (n : ℕ) [inst : NeZero n], ∀ x ∈ Set.univ, ⟨WithLp.toLp 2 (Function.update (↑x).ofLp 0 (max ((↑x).ofLp 0) 0)), ⋯⟩ = x | false |
Setoid.ext | Mathlib.Data.Quot | ∀ {α : Sort u_3} {s t : Setoid α}, (∀ (a b : α), s a b ↔ t a b) → s = t | true |
KaehlerDifferential.module'._proof_4 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
IsScalarTower (TensorProduct R S S) (TensorProduct R S S) ↥(KaehlerDifferential.ideal R S) | false |
Module.Flat.dfinsupp | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u} [inst : CommSemiring R] {ι : Type v} {M : ι → Type w} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] [∀ (i : ι), Module.Flat R (M i)], Module.Flat R (Π₀ (i : ι), M i) | true |
CartanMatrix.cₙ | Mathlib.Algebra.Lie.SerreConstruction | (R : Type u_1) → [CommRing R] → ℕ → Type u_1 | true |
ProofWidgets.Util.foldInlsM | ProofWidgets.Util | {α β : Type u_1} → {m : Type u_1 → Type u_2} → [Monad m] → Array (α ⊕ β) → (Array α → m β) → m (Array β) | true |
analyticOrderNatAt_of_not_analyticAt | Mathlib.Analysis.Analytic.Order | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {z₀ : 𝕜}, ¬AnalyticAt 𝕜 f z₀ → analyticOrderNatAt f z₀ = 0 | true |
ULift.addSemigroup._proof_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : AddSemigroup α], Function.Injective ⇑AddEquiv.ulift | false |
CategoryTheory.NatTrans.removeRightOp_id | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor Cᵒᵖ D},
CategoryTheory.NatTrans.removeRightOp (CategoryTheory.CategoryStruct.id F.rightOp) =
CategoryTheory.CategoryStruct.id F | true |
IsCompact.exists_finite_cover_vadd | Mathlib.Dynamics.Minimal | ∀ (G : Type u_2) {α : Type u_3} [inst : AddGroup G] [inst_1 : TopologicalSpace α] [inst_2 : AddAction G α]
[AddAction.IsMinimal G α] [ContinuousConstVAdd G α] {K U : Set α},
IsCompact K → IsOpen U → U.Nonempty → ∃ I, K ⊆ ⋃ g ∈ I, g +ᵥ U | true |
Nat.succ_descFactorial | Mathlib.Data.Nat.Factorial.Basic | ∀ (n k : ℕ), (n + 1 - k) * (n + 1).descFactorial k = (n + 1) * n.descFactorial k | true |
CategoryTheory.Limits.WalkingMultispan.Hom.ctorElim | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MultispanShape} →
{motive : (x x_1 : CategoryTheory.Limits.WalkingMultispan J) → x.Hom x_1 → Sort u} →
(ctorIdx : ℕ) →
{x x_1 : CategoryTheory.Limits.WalkingMultispan J} →
(t : x.Hom x_1) →
ctorIdx = t.ctorIdx → CategoryTheory.Limits.WalkingMultispan.Hom.ctorElim... | false |
CategoryTheory.StrongMonoCategory.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
(∀ {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f], CategoryTheory.StrongMono f) → CategoryTheory.StrongMonoCategory C | false |
CommGrpCat.epi_iff_surjective | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : CommGrpCat} (f : A ⟶ B), CategoryTheory.Epi f ↔ Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f) | true |
_private.Mathlib.Data.Nat.PSub.0.Nat.ppred_eq_some.match_1_1 | Mathlib.Data.Nat.PSub | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | false |
Mathlib.Tactic.TFAE.Parser.tfaeHavePatDecl.parenthesizer | Mathlib.Tactic.TFAE | Lean.PrettyPrinter.Parenthesizer | true |
FiberBundleCore | Mathlib.Topology.FiberBundle.Basic | Type u_5 → (B : Type u_6) → [TopologicalSpace B] → (F : Type u_7) → [TopologicalSpace F] → Type (max (max u_5 u_6) u_7) | true |
_private.Mathlib.Algebra.Order.BigOperators.GroupWithZero.List.0.List.prod_nonneg._simp_1_1 | Mathlib.Algebra.Order.BigOperators.GroupWithZero.List | ∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) | false |
nhdsWithin_eq_nhds._simp_1 | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, (nhdsWithin a s = nhds a) = (s ∈ nhds a) | false |
RingFilterBasis.casesOn | Mathlib.Topology.Algebra.FilterBasis | {R : Type u} →
[inst : Ring R] →
{motive : RingFilterBasis R → Sort u_1} →
(t : RingFilterBasis R) →
([toAddGroupFilterBasis : AddGroupFilterBasis R] →
(mul' : ∀ {U : Set R}, U ∈ toAddGroupFilterBasis.sets → ∃ V ∈ toAddGroupFilterBasis.sets, V * V ⊆ U) →
(mul_left' :
... | false |
MvPFunctor.wpMk | Mathlib.Data.PFunctor.Multivariate.W | {n : ℕ} →
(P : MvPFunctor.{u} (n + 1)) →
{α : TypeVec.{u} n} → (a : P.A) → (f : P.last.B a → P.last.W) → TypeVec.Arrow (P.WPath (WType.mk a f)) α → P.W α | true |
Matrix.NormedAddCommGroup.ofMatrix | Mathlib.Analysis.Matrix.PosDef | {n : Type u_2} →
{𝕜 : Type u_3} → [Fintype n] → [inst : RCLike 𝕜] → (M : Matrix n n 𝕜) → M.PosDef → NormedAddCommGroup (n → 𝕜) | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Util.0.Lean.Grind.Linarith.Poly.eval?.go | Lean.Meta.Tactic.Grind.Arith.Linear.Util | Lean.PArray ℚ → ℚ → Lean.Grind.Linarith.Poly → Option ℚ | true |
_private.Mathlib.Analysis.Calculus.Implicit.0.HasStrictFDerivAt.map_implicitFunctionOfComplemented_eq.match_1_1 | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_1} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {f : E → F} {f' : E →L[𝕜] F} {a : E}
(hf : HasStrictFDe... | false |
CompositionSeries.exists_last_eq_snoc_equivalent | Mathlib.Order.JordanHolder | ∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] (s : CompositionSeries X) (x : X)
(hm : JordanHolderLattice.IsMaximal x (RelSeries.last s)),
RelSeries.head s ≤ x →
∃ t,
RelSeries.head t = RelSeries.head s ∧
t.length + 1 = s.length ∧ ∃ (htx : RelSeries.last t = x), s.Equivalent (... | true |
Cycle.card_toMultiset | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} (s : Cycle α), s.toMultiset.card = s.length | true |
TopCat.Presheaf.isLimitOpensLeCoverEquivPairwise._proof_1 | Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections | ∀ {X : TopCat} {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑X),
(TopCat.Presheaf.SheafCondition.pairwiseToOpensLeCover U).op.Initial | false |
Complex.differentiableAt_Gamma_one | Mathlib.Analysis.SpecialFunctions.Gamma.Deriv | DifferentiableAt ℂ Complex.Gamma 1 | true |
Std.Sat.AIG.mkGateCached._proof_2 | Std.Sat.AIG.Cached | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (decls : Array (Std.Sat.AIG.Decl α))
(cache : Std.Sat.AIG.Cache α decls) (hdag : Std.Sat.AIG.IsDAG α decls) (hzero : 0 < decls.size)
(hconst : decls[0] = Std.Sat.AIG.Decl.false)
(input : { decls := decls, cache := cache, hdag := hdag, hzero := hzero, hcons... | false |
CategoryTheory.TwistShiftData.shiftFunctor_map | Mathlib.CategoryTheory.Shift.Twist | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (t : CategoryTheory.TwistShiftData C A) {X Y : t.Category} (f : X ⟶ Y) (m : A),
(CategoryTheory.shiftFunctor t.Category m).map f =
CategoryTheory.CategoryStruct.comp ((t.shiftIso m... | true |
Std.DHashMap.Internal.Raw₀.getKey!_eq_get!_getKey? | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited α], (↑m).WF → ∀ {a : α}, m.getKey! a = (m.getKey? a).get! | true |
Equiv.Perm.Basis.ofPermHom._proof_9 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis)
(σ τ : ↥(Equiv.Perm.OnCycleFactors.range_toPermHom' g)),
{ toFun := a.ofPermHomFun (σ * τ), invFun := a.ofPermHomFun (σ * τ)⁻¹, left_inv := ⋯, right_inv := ⋯ } =
{ toFun := a.ofPermHomFun σ, invFun := a.ofPermHomFun σ⁻... | false |
_private.Mathlib.GroupTheory.Torsion.0.not_isMulTorsionFree_of_isTorsion.match_1_1 | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : CommGroup G] (motive : (∃ y, y ≠ 1) → Prop) (x : ∃ y, y ≠ 1),
(∀ (x : G) (hx : x ≠ 1), motive ⋯) → motive x | false |
Submodule.coe_inner | Mathlib.Analysis.InnerProductSpace.Subspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(W : Submodule 𝕜 E) (x y : ↥W), inner 𝕜 x y = inner 𝕜 ↑x ↑y | true |
RootPairing.Equiv.symm._proof_3 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_2} {R : Type u_4} {M : Type u_5} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₂ : Type u_6} {M₂ : Type u_7} {N₂ : Type u_1}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | false |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.NatIso.cancel_natIso_inv_right_assoc._simp_1_3 | Mathlib.CategoryTheory.NatIso | ∀ {α : Sort u_1} {r : α → α → Prop} [Std.Refl r] (a : α), r a a = True | false |
ULiftable.symm | Mathlib.Control.ULiftable | (f : Type u₀ → Type u₁) → (g : Type v₀ → Type v₁) → [ULiftable f g] → ULiftable g f | true |
TopologicalSpace.Opens.mem_comap._simp_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : C(α, β)}
{U : TopologicalSpace.Opens β} {x : α}, (x ∈ (TopologicalSpace.Opens.comap f) U) = (f x ∈ U) | false |
CategoryTheory.Pi.right_unitor_inv_apply | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {X : (i : I) → C i} {i : I},
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv i =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (X i)).inv | true |
SimpleGraph.Subgraph.restrict | Mathlib.Combinatorics.SimpleGraph.Subgraph | {V : Type u} → {G : SimpleGraph V} → {G' : G.Subgraph} → G.Subgraph → G'.coe.Subgraph | true |
Finsupp.sigma_sum | Mathlib.Data.Finsupp.Basic | ∀ {ι : Type u_4} {M : Type u_5} {N : Type u_6} {αs : ι → Type u_12} [inst : Zero M] (l : (i : ι) × αs i →₀ M)
[inst_1 : AddCommMonoid N] (f : (i : ι) × αs i → M → N),
l.sum f = ∑ i ∈ l.splitSupport, (l.split i).sum fun a b => f ⟨i, a⟩ b | true |
ENNReal.le_of_forall_pos_nnreal_lt | Mathlib.Data.ENNReal.Inv | ∀ {x y : ENNReal}, (∀ (r : NNReal), 0 < r → ↑r < x → ↑r ≤ y) → x ≤ y | true |
BitVec.neg_eq_zero_iff._simp_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, (-x = 0#w) = (x = 0#w) | false |
EStateM.run'_set | Batteries.Lean.EStateM | ∀ {σ ε : Type u_1} (v s : σ), (set v).run' s = some PUnit.unit | true |
Std.Packages.LinearPreorderOfLEArgs.le_total._autoParam | Init.Data.Order.PackageFactories | Lean.Syntax | false |
Equiv.coe_toHomeomorph | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y)
(he : ∀ (s : Set Y), IsOpen (⇑e ⁻¹' s) ↔ IsOpen s), ⇑(e.toHomeomorph he) = ⇑e | true |
_private.Mathlib.Topology.Continuous.0.Equiv.continuous_symm_iff._simp_1_1 | Mathlib.Topology.Continuous | ∀ {X : Type u_1} {Y : Type u_2} {x : TopologicalSpace X} {x_1 : TopologicalSpace Y} {f : X → Y},
Continuous f = ∀ (s : Set Y), IsOpen s → IsOpen (f ⁻¹' s) | false |
Filter.not_tendsto_const_atTop | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [NoTopOrder α] (x : α) (l : Filter β) [l.NeBot],
¬Filter.Tendsto (fun x_1 => x) l Filter.atTop | true |
Std.HashSet.get?_beq | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k : α},
Option.all (fun x_2 => x_2 == k) (m.get? k) = true | true |
Submodule.factorPow.congr_simp | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m n : ℕ}
(le : m ≤ n), Submodule.factorPow I M le = Submodule.factorPow I M le | true |
List.chains | Mathlib.Data.List.Chain | {α : Type u_1} → (α → α → Prop) → Type (max 0 u_1) | true |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Real.le_aeval_of_isMonicOfDegree | Mathlib.Analysis.Normed.Algebra.GelfandMazur | ∀ {F : Type u_1} [inst : NormedRing F] [inst_1 : NormedAlgebra ℝ F] [NormOneClass F] [NormMulClass F] {x : F} {M : ℝ},
0 ≤ M →
(∀ (z : ℝ × ℝ), M ≤ ‖NormedAlgebra.Real.φ✝ x z‖) →
∀ {p : Polynomial ℝ} {n : ℕ}, p.IsMonicOfDegree (2 * n) → M ^ n ≤ ‖(Polynomial.aeval x) p‖ | true |
Lean.Elab.Term.elabParserName | Lean.Elab.Syntax | Lean.Ident → optParam Bool true → Lean.Elab.TermElabM Lean.Parser.ParserResolution | true |
_private.Mathlib.AlgebraicTopology.DoldKan.Degeneracies.0.AlgebraicTopology.DoldKan.σ_comp_P_eq_zero._proof_1_3 | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {n : ℕ} (q : ℕ) (i : Fin (n + 1)), n + 1 ≤ ↑i + (q + 1) → ¬n + 1 ≤ ↑i + q → n = ↑i + q | false |
CategoryTheory.InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_hom_naturality_assoc | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasInjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X)
(J : ... | true |
Stream'.WSeq.take | Mathlib.Data.WSeq.Defs | {α : Type u} → Stream'.WSeq α → ℕ → Stream'.WSeq α | true |
Lean.Grind.LinarithConfig.revert._inherited_default | Init.Grind.Config | Bool | false |
Rat.den_neg_eq_den | Mathlib.Data.Rat.Defs | ∀ (q : ℚ), (-q).den = q.den | true |
ProbabilityTheory.poissonMeasure.eq_1 | Mathlib.Probability.Distributions.Poisson.Basic | ∀ (r : NNReal),
ProbabilityTheory.poissonMeasure r =
MeasureTheory.Measure.sum fun n =>
ENNReal.ofReal (Real.exp (-↑r) * ↑r ^ n / ↑n.factorial) • MeasureTheory.Measure.dirac n | true |
Std.HashSet.Equiv.get!_eq | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, m₁.Equiv m₂ → m₁.get! k = m₂.get! k | true |
subset_closure | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, s ⊆ closure s | true |
IO.AsyncList.cons.noConfusion | Lean.Server.AsyncList | {ε : Type u} →
{α : Type v} →
{P : Sort u_1} →
{hd : α} →
{tl : IO.AsyncList ε α} →
{hd' : α} →
{tl' : IO.AsyncList ε α} →
IO.AsyncList.cons hd tl = IO.AsyncList.cons hd' tl' → (hd ≍ hd' → tl ≍ tl' → P) → P | false |
IsBoundedBilinearMap.linearDeriv | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : SeminormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{F : Type u_3} →
[inst_3 : SeminormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
{G : Type u_4} →
... | true |
CategoryTheory.Functor.Final.isColimitWhiskerEquiv | Mathlib.CategoryTheory.Limits.Final | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[F.Final] →
{E : Type u₃} →
[inst_3 : CategoryTheory.Category.{v₃, u₃} E] →
{G : Catego... | true |
_private.Mathlib.Algebra.GroupWithZero.Range.0.MonoidWithZeroHom.valueGroup_eq_range._simp_1_2 | Mathlib.Algebra.GroupWithZero.Range | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
_private.Lean.Meta.DiscrTree.Main.0.Lean.Meta.DiscrTree.pushArgsAux._sparseCasesOn_1 | Lean.Meta.DiscrTree.Main | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
Aesop.Percent.noConfusionType | Aesop.Percent | Sort u → Aesop.Percent → Aesop.Percent → Sort u | false |
Lean.Lsp.Position.rec | Lean.Data.Lsp.BasicAux | {motive : Lean.Lsp.Position → Sort u} →
((line character : ℕ) → motive { line := line, character := character }) → (t : Lean.Lsp.Position) → motive t | false |
UniformSpace.ball_inter | Mathlib.Topology.UniformSpace.Defs | ∀ {β : Type ub} (x : β) (V W : Set (β × β)), UniformSpace.ball x (V ∩ W) = UniformSpace.ball x V ∩ UniformSpace.ball x W | true |
PartialDiffeomorph._sizeOf_inst | Mathlib.Geometry.Manifold.LocalDiffeomorph | {𝕜 : Type u_1} →
{inst : NontriviallyNormedField 𝕜} →
{E : Type u_2} →
{inst_1 : NormedAddCommGroup E} →
{inst_2 : NormedSpace 𝕜 E} →
{F : Type u_3} →
{inst_3 : NormedAddCommGroup F} →
{inst_4 : NormedSpace 𝕜 F} →
{H : Type u_4} →
... | false |
discrim_eq_zero_of_existsUnique | Mathlib.Algebra.QuadraticDiscriminant | ∀ {K : Type u_1} [inst : Field K] [NeZero 2] {a b c : K},
a ≠ 0 → (∃! x, a * (x * x) + b * x + c = 0) → discrim a b c = 0 | true |
IsLocalMax.bicomp_mono | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type x} [inst : TopologicalSpace α] [inst_1 : Preorder β]
[inst_2 : Preorder γ] {f : α → β} {a : α} [inst_3 : Preorder δ] {op : β → γ → δ},
Relator.LiftFun (fun x1 x2 => x1 ≤ x2) (Relator.LiftFun (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2) op op →
IsLocalMax f a → ... | true |
_private.Mathlib.Algebra.Group.Subgroup.Basic.0.IsConj.normalClosure_eq_top_of._simp_1_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a : α} {h : p a} {a' : α} {h' : p a'}, (⟨a, h⟩ = ⟨a', h'⟩) = (a = a') | false |
Std.HashMap.size | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → ℕ | true |
SimpleGraph.ComponentCompl.hom_refl | Mathlib.Combinatorics.SimpleGraph.Ends.Defs | ∀ {V : Type u} {G : SimpleGraph V} {L : Set V} (C : G.ComponentCompl L), SimpleGraph.ComponentCompl.hom ⋯ C = C | true |
UniformEquiv.preimage_image | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} {β : Type u_1} [inst : UniformSpace α] [inst_1 : UniformSpace β] (h : α ≃ᵤ β) (s : Set α),
⇑h ⁻¹' (⇑h '' s) = s | true |
CategoryTheory.MonoidalCategory.inv_hom_whiskerRight | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ≅ Y) (Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f.inv Z)
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f.hom Z) =
CategoryTheory... | true |
Lean.Elab.Term.SyntheticMVarKind.typeClass | Lean.Elab.Term.TermElabM | Option Lean.MessageData → Lean.Elab.Term.SyntheticMVarKind | true |
MonoidAlgebra.supported_eq_map | Mathlib.Algebra.MonoidAlgebra.Module | ∀ (R : Type u_2) {M : Type u_4} (S : Type u_5) [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S]
(s : Set M),
MonoidAlgebra.supported R S s = Submodule.map (↑(MonoidAlgebra.coeffLinearEquiv R).symm) (Finsupp.supported S R s) | true |
MulOpposite.semiconjBy_op._simp_2 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Mul α] {a x y : α},
SemiconjBy (MulOpposite.op a) (MulOpposite.op y) (MulOpposite.op x) = SemiconjBy a x y | false |
Lean.Lsp.InitializedParams.toCtorIdx | Lean.Data.Lsp.InitShutdown | Lean.Lsp.InitializedParams → ℕ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.