name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.PreservesPullback.iso_hom | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullb... | true |
_private.Mathlib.Data.List.Chain.0.List.exists_isChain_ne_nil_of_relationReflTransGen._proof_1_3 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {a : α} (l : List α), ¬(a :: l).length - 1 = 0 → (a :: l).length - 2 < l.length | false |
CategoryTheory.Equivalence.cancel_unit_left._simp_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D) {X Y : C} (f f' : e.inverse.obj (e.functor.obj Y) ⟶ X),
(CategoryTheory.CategoryStruct.comp (e.unit.app Y) f = CategoryTheory.CategoryStruct.comp (e.unit.app Y) f') =
(f = f') | false |
cauchySeq_range_of_norm_bounded | Mathlib.Analysis.Normed.Group.InfiniteSum | ∀ {E : Type u_3} [inst : SeminormedAddCommGroup E] {f : ℕ → E} {g : ℕ → ℝ},
(CauchySeq fun n => ∑ i ∈ Finset.range n, g i) →
(∀ (i : ℕ), ‖f i‖ ≤ g i) → CauchySeq fun n => ∑ i ∈ Finset.range n, f i | true |
lp.norm_eq_card_dsupport | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_3} {E : α → Type u_4} [inst : (i : α) → NormedAddCommGroup (E i)] (f : ↥(lp E 0)), ‖f‖ = ↑⋯.toFinset.card | true |
CategoryTheory.Functor.Elements.isColimitCoconeπOpCompShrinkYonedaObj._proof_1 | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
(F : CategoryTheory.Functor C (Type u_1)) (X : C)
(x :
(((CategoryTheory.CategoryOfElements.π F).op.comp
(CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.obj X)).coconeTypesEquiv.sym... | false |
ContinuousAlgEquiv.trans._proof_1 | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_4} {A : Type u_1} {B : Type u_3} {C : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Semiring C]
[inst_6 : TopologicalSpace C] [inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : Algebra R C] (e₁ :... | false |
Lean.Elab.Tactic.Try.TrySuggestionEntry._sizeOf_1 | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.TrySuggestionEntry → ℕ | false |
Lean.Grind.Linarith.instBEqPoly.beq._sparseCasesOn_1.else_eq | Init.Grind.Ordered.Linarith | ∀ {motive : Lean.Grind.Linarith.Poly → Sort u} (t : Lean.Grind.Linarith.Poly)
(nil : motive Lean.Grind.Linarith.Poly.nil) («else» : Nat.hasNotBit 1 t.ctorIdx → motive t)
(h : Nat.hasNotBit 1 t.ctorIdx), Lean.Grind.Linarith.instBEqPoly.beq._sparseCasesOn_1 t nil «else» = «else» h | false |
nilpotencyClass_eq_quotient_center_plus_one | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [hH : Group.IsNilpotent G] [Nontrivial G],
Group.nilpotencyClass G = Group.nilpotencyClass (G ⧸ Subgroup.center G) + 1 | true |
CategoryTheory.Lax.LaxTrans.Hom.noConfusionType | Mathlib.CategoryTheory.Bicategory.Modification.Lax | Sort u →
{B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{η θ : F ⟶ G} →
CategoryTheory.Lax.LaxTrans.Hom η θ →
{B' : Type u₁} →
... | false |
StarRingEquiv.noConfusion | Mathlib.Algebra.Star.StarRingHom | {P : Sort u} →
{A : Type u_1} →
{B : Type u_2} →
{inst : Add A} →
{inst_1 : Add B} →
{inst_2 : Mul A} →
{inst_3 : Mul B} →
{inst_4 : Star A} →
{inst_5 : Star B} →
{t : A ≃⋆+* B} →
{A' : Type u_1} →
... | false |
SmoothBumpCovering.IsSubordinate.toSmoothPartitionOfUnity | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH}
[inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M]
[inst_4 : ChartedSpace H M] [inst_5 : FiniteDimensional ℝ E] {s : Set M} [inst_6 : T2Space M]
[inst_7 : IsMani... | true |
Lean.Grind.ToInt.Zero.rec | Init.Grind.ToInt | {α : Type u} →
[inst : Zero α] →
{I : Lean.Grind.IntInterval} →
[inst_1 : Lean.Grind.ToInt α I] →
{motive : Lean.Grind.ToInt.Zero α I → Sort u_1} →
((toInt_zero : ↑0 = 0) → motive ⋯) → (t : Lean.Grind.ToInt.Zero α I) → motive t | false |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.instRankFiniteMapEmbedding._proof_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_2} {β : Type u_1} {M : Matroid α} [M.RankFinite] {f : α ↪ β}, (M.mapEmbedding f).RankFinite | false |
EReal.bot_lt_zero | Mathlib.Data.EReal.Basic | ⊥ < 0 | true |
ContinuousLineDeriv.rec | Mathlib.Analysis.Distribution.DerivNotation | {V : Type u} →
{E : Type v} →
{F : Type w} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace F] →
[inst_2 : LineDeriv V E F] →
{motive : ContinuousLineDeriv V E F → Sort u_1} →
((continuous_lineDerivOp : ∀ (v : V), Continuous (LineDeriv.lineDerivOp v)) → ... | false |
UniqueDiffWithinAt.mono_nhds | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
UniqueDiffWithinAt 𝕜 s x → nhdsWithin x s ≤ nhdsWithin x t → UniqueDiffWithinAt 𝕜 t x | true |
eq_of_mabs_div_le_one | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G}, |a / b|ₘ ≤ 1 → a = b | true |
Fin.insertNthEquiv_symm_apply | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} (α : Fin (n + 1) → Type u) (p : Fin (n + 1)) (f : (i : Fin (n + 1)) → α i),
(Fin.insertNthEquiv α p).symm f = (f p, p.removeNth f) | true |
CategoryTheory.ihom.ev_naturality_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A : C)
[inst_2 : CategoryTheory.Closed A] {X Y : C} (f : X ⟶ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft A ((CategoryTheory.ihom A).map f))
... | true |
meromorphicTrailingCoeffAt.eq_1 | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 → E) (x : 𝕜),
meromorphicTrailingCoeffAt f x =
if h₁ : MeromorphicAt f x then if h₂ : meromorphicOrderAt f x = ⊤ then 0 else ⋯.choose x else 0 | true |
CommRingCat.instCategory | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.Category.{u_1, u_1 + 1} CommRingCat | true |
CategoryTheory.Pi.instLaxBraidedForallPi | 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)] →
[inst_2 : (i : I) → CategoryTheory.BraidedCategory (C i)] →
{D : I → Type u₂} →
[inst_3 : (i : I) → CategoryTheory.Catego... | true |
MonoidWithZero.toMulActionWithZero._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Defs | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] (b : M₀), 1 • b = b | false |
exteriorPower.linearMap_ext_iff | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {n : ℕ} {M : Type u_1} {N : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f g : ↥(⋀[R]^n M) →ₗ[R] N},
f = g ↔ f.compAlternatingMap (exteriorPower.ιMulti R n) = g.compAlternatingMap (exteriorPower.ιMulti R n) | true |
CliffordAlgebra.EquivEven.e0_mul_e0 | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), CliffordAlgebra.EquivEven.e0 Q * CliffordAlgebra.EquivEven.e0 Q = -1 | true |
MeasureTheory.predictablePart | Mathlib.Probability.Martingale.Centering | {Ω : Type u_1} →
{E : Type u_2} →
[inst : NormedAddCommGroup E] →
[NormedSpace ℝ E] →
[CompleteSpace E] →
{m0 : MeasurableSpace Ω} → (ℕ → Ω → E) → MeasureTheory.Filtration ℕ m0 → MeasureTheory.Measure Ω → ℕ → Ω → E | true |
CategoryTheory.yonedaCommGrpGrpObj._proof_6 | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (G : CategoryTheory.CommGrp C) {X Y Z : (CategoryTheory.Grp C)ᵒᵖ}
(f : X ⟶ Y) (g : Y ⟶ Z),
CommGrpCat.ofHom
{ toFun := fun x => CategoryTheory.Cate... | false |
_private.Init.Data.Nat.Lemmas.0.Nat.add_eq_three_iff._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {m n : ℕ}, ¬(m + n = 3 ↔ m = 0 ∧ n = 3 ∨ m = 1 ∧ n = 2 ∨ m = 2 ∧ n = 1 ∨ m = 3 ∧ n = 0) → False | false |
_private.Batteries.Data.Array.Basic.0.Array.scanlMFast._proof_1 | Batteries.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (stop : ℕ), (USize.ofNat (min stop as.size)).toNat ≤ as.size | false |
ContinuousMultilinearMap.instCompleteSpace | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup... | true |
TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivInverse_map_hom | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasProducts C] {X : TopCat}
(F : TopCat.Presheaf C X) {ι : Type v'} (U : ι → TopologicalSpace.Opens ↑X)
{c c' : CategoryTheory.Limits.Cone (TopCat.Presheaf.SheafConditionEqualizerProducts.diagram F U)} (f : c ⟶ c'),
((TopCat.... | true |
ConcaveOn.right_le_of_le_left' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : SMul 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConcaveOn 𝕜 s f... | true |
CategoryTheory.PreZeroHypercover.inv_hom_h₀_assoc | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S} (e : E ≅ F)
(i : F.I₀) {Z : C} (h : F.X (e.hom.s₀ (e.inv.s₀ i)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.inv.h₀ i) (CategoryTheory.CategoryStruct.comp (e.hom.h₀ (e.inv.s₀ i)) h) =
CategoryTheory.Catego... | true |
RootPairing.pairingIn_eq_add_of_root_eq_add | Mathlib.LinearAlgebra.RootSystem.IsValuedIn | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {S : Type u_6}
[inst_5 : CommRing S] [inst_6 : Algebra S R] [FaithfulSMul S R] [inst_8 : P.IsValuedIn S] {i j k ... | true |
_private.Lean.Meta.ExprTraverse.0.Lean.Meta.traverseForallWithPos.visit._sunfold | Lean.Meta.ExprTraverse | {M : Type → Type u_1} →
[Monad M] →
[MonadLiftT Lean.MetaM M] →
[MonadControlT Lean.MetaM M] →
(Lean.SubExpr.Pos → Lean.Expr → M Lean.Expr) → Array Lean.Expr → Lean.SubExpr.Pos → Lean.Expr → M Lean.Expr | false |
ContinuousLinearMapWOT.seminormFamily | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | {𝕜₁ : Type u_1} →
{𝕜₂ : Type u_2} →
[inst : NormedField 𝕜₁] →
[inst_1 : NormedField 𝕜₂] →
(σ : 𝕜₁ →+* 𝕜₂) →
(E : Type u_3) →
(F : Type u_4) →
[inst_2 : AddCommGroup E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : Module 𝕜₁ E... | true |
SubarrayIterator.step.eq_1 | Init.Data.Slice.Array.Iterator | ∀ {α : Type u} {m : Type u → Type u_1} (xs : Subarray α),
SubarrayIterator.step { internalState := { xs := xs } } =
if h : xs.start < xs.stop then
have this := ⋯;
have this := ⋯;
Std.IterStep.yield
{
internalState :=
{
xs :=
{
... | true |
_private.Init.Data.String.Extra.0.String.removeNumLeadingSpaces.consumeSpaces._mutual._proof_2 | Init.Data.String.Extra | ∀ {s : String} (n : ℕ) (it : s.Pos) (r : String),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun n it => PSigma.casesOn it fun it r => (it, 1)) fun _x =>
PSigma.casesOn _x fun it r => (it, 0))
Prod.instWellFoundedRelation).1
(PSum.inr ⟨it, r⟩) (PSum.inl ⟨... | false |
Fin.orderIsoPair.match_1 | Mathlib.Order.Fin.Finset | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α) (motive : ↥{a, b} → Prop) (x : ↥{a, b}),
(∀ (x : α) (hx : x ∈ {a, b}), motive ⟨x, hx⟩) → motive x | false |
Lean.IR.SimpleGroundArg.rawReference.noConfusion | Lean.Compiler.IR.SimpleGroundExpr | {P : Sort u} →
{s s' : String} → Lean.IR.SimpleGroundArg.rawReference s = Lean.IR.SimpleGroundArg.rawReference s' → (s = s' → P) → P | false |
CategoryTheory.Limits.equalizerPullbackMapIso_hom_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasEqualizers C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] {X Y S T : C} {f g : X ⟶ Y} {s : X ⟶ S} {t : Y ⟶ S}
(hf : CategoryTheory.CategoryStruct.comp f t = s) (hg : CategoryTheory.CategoryStruct.comp g t = s) (v : T ⟶ S... | true |
Matrix.conjTranspose_fromRows_eq_fromCols_conjTranspose | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} [inst : Star R] (A₁ : Matrix m₁ n R)
(A₂ : Matrix m₂ n R), (A₁.fromRows A₂).conjTranspose = A₁.conjTranspose.fromCols A₂.conjTranspose | true |
MeasureTheory.Measure.count.instSigmaFinite | Mathlib.MeasureTheory.Measure.Count | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] [Countable α],
MeasureTheory.SigmaFinite MeasureTheory.Measure.count | true |
_private.Mathlib.CategoryTheory.Functor.Category.0.CategoryTheory.Functor.rightUnitor._proof_5 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (x : C),
(CategoryTheory.CategoryStruct.comp { app := fun X => CategoryTheory.CategoryStruct.id (F.obj X), naturality := ⋯ }
{ app := fun X => Cate... | false |
CategoryTheory.MorphismProperty.HasQuotient.mk | Mathlib.CategoryTheory.MorphismProperty.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C}
{homRel : HomRel C} [inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel]
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel],
(∀ ⦃X Y : C⦄ ⦃f g : X ⟶ Y⦄, homRel f g → (W f ↔ W g)) → W.HasQuotie... | true |
ProbabilityTheory.strong_law_Lp | Mathlib.Probability.StrongLaw | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [inst_3 : MeasurableSpace E] [BorelSpace E] {p : ENNReal},
1 ≤ p →
p ≠ ⊤ →
∀ (X : ℕ → Ω → E),
MeasureTheory.MemLp (X 0) p μ →
... | true |
Std.TreeSet.min!_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.min! ∈ t | true |
MulDissociated.subset | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : CommGroup α] {s t : Set α}, s ⊆ t → MulDissociated t → MulDissociated s | true |
CategoryTheory.Limits.PullbackCone.combineIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Pullbacks | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_4, u_3} D] {F G H : CategoryTheory.Functor D C} (f : F ⟶ H) (g : G ⟶ H)
(c : (X : D) → CategoryTheory.Limits.PullbackCone (f.app X) (g.app X))
(hc : (X : D) → CategoryTheory.Limits.IsLimit (c X)) (k ... | false |
Lean.mkListNode | Lean.Syntax | Array Lean.Syntax → Lean.Syntax | true |
CategoryTheory.Arrow.AugmentedCechNerve.extraDegeneracy._proof_3 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
(S : CategoryTheory.SplitEpi f.hom),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp S.secti... | false |
SubgroupClass.coe_zpow._simp_2 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {S : Type u_4} {H : S} [inst_1 : SetLike S G] [inst_2 : SubgroupClass S G] (x : ↥H)
(n : ℤ), ↑x ^ n = ↑(x ^ n) | false |
Monotone.ae_hasDerivAt | Mathlib.Analysis.Calculus.Monotone | ∀ {f : ℝ → ℝ} (hf : Monotone f),
∀ᵐ (x : ℝ), HasDerivAt f (hf.stieltjesFunction.measure.rnDeriv MeasureTheory.volume x).toReal x | true |
CategoryTheory.Limits.coneUnopOfCoconeEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ}
{X Y : (CategoryTheory.Limits.Cocone F)ᵒᵖ} (f : Y ⟶ X) (j : J),
CategoryTheory.CategoryStruct.comp f.unop.hom.unop
((CategoryTheory.Limits.coneUn... | false |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree.0.groupCohomology.mem_cocycles₁_iff._simp_1_3 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
Std.TreeMap.instSliceableRcoSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax | false |
CommRingCat.Colimits.Relation.below.mul | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
{motive : (a a_1 : CommRingCat.Colimits.Prequotient F) → CommRingCat.Colimits.Relation F a a_1 → Prop} (j : J)
(x y : ↑(F.obj j)), CommRingCat.Colimits.Relation.below ⋯ | true |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.State.found | Lean.Util.ParamMinimizer | Lean.Util.ParamMinimizer.State✝ → Bool | true |
nnnorm_pow_le_mul_norm | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] {a : E} {n : ℕ}, ‖a ^ n‖₊ ≤ ↑n * ‖a‖₊ | true |
Matrix.updateCol_self | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {j : n} {c : m → α} [inst : DecidableEq n],
M.updateCol j c i j = c i | true |
Lean.Nat.mkInstPow | Lean.Expr | Lean.Expr | true |
WithCStarModule.instUniformSpace | Mathlib.Analysis.CStarAlgebra.Module.Synonym | {A : Type u_3} → {E : Type u_4} → [u : UniformSpace E] → UniformSpace (WithCStarModule A E) | true |
Fin.univ_succAbove._proof_1 | Mathlib.Data.Fintype.Basic | ∀ (n : ℕ) (p : Fin (n + 1)), p ∉ Finset.map p.succAboveEmb Finset.univ | false |
RingTheory.Sequence.IsRegular.recIterModByRegularWithRing | Mathlib.RingTheory.Regular.RegularSequence | {motive :
(R : Type u) →
[inst : CommRing R] →
(M : Type v) →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (rs : List R) → RingTheory.Sequence.IsRegular M rs → Sort u_7} →
((R : Type u) →
[inst : CommRing R] →
(M : Type v) → [inst_1 : AddCommGroup M] → [ins... | true |
CategoryTheory.ObjectProperty.monotone_retractClosure | Mathlib.CategoryTheory.ObjectProperty.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : CategoryTheory.ObjectProperty C},
P ≤ Q → P.retractClosure ≤ Q.retractClosure | true |
PseudoMetricSpace.toPseudoEMetricSpace | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u} → [PseudoMetricSpace α] → PseudoEMetricSpace α | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getMsbD_add._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {i_lt : i < w}, ¬w - 1 - i < w → False | false |
CategoryTheory.ObjectProperty.colimitsClosure.recOn | Mathlib.CategoryTheory.ObjectProperty.ColimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)]
{motive : (a : C) → P.colimitsClosure J a → Prop} {a : C} (t : P.colimitsClosure J a),
(∀ (X : C) (hX : P X), motive X ⋯) →
... | false |
CategoryTheory.Center.ofBraidedObj_fst | Mathlib.CategoryTheory.Monoidal.Center | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C), (CategoryTheory.Center.ofBraidedObj X).fst = X | true |
_private.Mathlib.Algebra.Order.Star.Basic.0.StarOrderedRing.pos_iff._simp_1_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) | false |
Std.ExtDHashMap.getKey!_inter_of_mem_right | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {k : α}, k ∈ m₂ → (m₁ ∩ m₂).getKey! k = m₁.getKey! k | true |
CategoryTheory.PreZeroHypercover.pullback₁_X | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T : C} (f : S ⟶ T) (E : CategoryTheory.PreZeroHypercover T)
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback f (E.f i)] (i : E.I₀),
(CategoryTheory.PreZeroHypercover.pullback₁ f E).X i = CategoryTheory.Limits.pullback f (E.f i) | true |
Aesop.LIFOQueue.rec | Aesop.Search.Queue | {motive : Aesop.LIFOQueue → Sort u} →
((goals : Array Aesop.GoalRef) → motive { goals := goals }) → (t : Aesop.LIFOQueue) → motive t | false |
RKHS.kernel.congr_simp | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] (H : Type u_4) [inst_3 : NormedAddCommGroup H] [inst_4 : InnerProductSpace 𝕜 H]
[inst_5 : RKHS 𝕜 H X V] [inst_6 : CompleteSpace H] [inst_7 : CompleteSpace V] (a a_1 : X),
a = a_1 ... | true |
List.findIdx_eq_findIdx?.match_1 | Batteries.Data.List.Lemmas | (motive : Option ℕ → Sort u_1) → (x : Option ℕ) → ((i : ℕ) → motive (some i)) → (Unit → motive none) → motive x | false |
Stoch._proof_1 | Mathlib.Probability.Kernel.Category.Stoch | StochHom.IsMultiplicative | false |
Metric.sphere_union_ball | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.sphere x ε ∪ Metric.ball x ε = Metric.closedBall x ε | true |
Rat.exists_eq_mul_div_num_and_eq_mul_div_den | Mathlib.Data.Rat.Lemmas | ∀ (n : ℤ) {d : ℤ}, d ≠ 0 → ∃ c, n = c * (↑n / ↑d).num ∧ d = c * ↑(↑n / ↑d).den | true |
AdicCompletion.AdicCauchySequence.instSMul._proof_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(r : R) (x : AdicCompletion.AdicCauchySequence I M) {m n : ℕ}, m ≤ n → r • ↑x m ≡ r • ↑x n [SMOD I ^ m • ⊤] | false |
RingHom.frobenius_comm | Mathlib.Algebra.CharP.Frobenius | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] (g : R →+* S) (p : ℕ)
[inst_2 : ExpChar R p] [inst_3 : ExpChar S p], g.comp (frobenius R p) = (frobenius S p).comp g | true |
Insert.mk.noConfusion | Init.Core | {α : outParam (Type u)} →
{γ : Type v} →
{P : Sort u_1} →
{insert insert' : α → γ → γ} → { insert := insert } = { insert := insert' } → (insert ≍ insert' → P) → P | false |
MvPolynomial.X_mul_pderiv_monomial | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} [inst : CommSemiring R] {i : σ} {m : σ →₀ ℕ} {r : R},
MvPolynomial.X i * (MvPolynomial.pderiv i) ((MvPolynomial.monomial m) r) = m i • (MvPolynomial.monomial m) r | true |
MvPolynomial.constantCoeff_comp_algebraMap | Mathlib.Algebra.MvPolynomial.Basic | ∀ (R : Type u) (σ : Type u_1) [inst : CommSemiring R],
MvPolynomial.constantCoeff.comp (algebraMap R (MvPolynomial σ R)) = RingHom.id R | true |
Finset.toSet | Mathlib.Data.Finset.Defs | {α : Type u_1} → Finset α → Set α | true |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.quadrant_III._simp_1_4 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) | false |
Std.TreeMap.contains_insertIfNew | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k a : α} {v : β},
(t.insertIfNew k v).contains a = (cmp k a == Ordering.eq || t.contains a) | true |
IsNonstrictStrictOrder.right_iff_left_not_left | Mathlib.Order.RelClasses | ∀ {α : Type u_1} {r : semiOutParam (α → α → Prop)} {s : α → α → Prop} [self : IsNonstrictStrictOrder α r s] (a b : α),
s a b ↔ r a b ∧ ¬r b a | true |
Ideal.isLocal_of_isMaximal_radical | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, I.radical.IsMaximal → I.IsLocal | true |
CategoryTheory.SmallObject.FunctorObjIndex.i | Mathlib.CategoryTheory.SmallObject.Construction | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type w} →
{A B : I → C} →
{f : (i : I) → A i ⟶ B i} → {S X : C} → {πX : X ⟶ S} → CategoryTheory.SmallObject.FunctorObjIndex f πX → I | true |
star_finsuppSum | Mathlib.Algebra.Star.BigOperators | ∀ {R : Type u_1} {ι : Type u_2} {M : Type u_3} [inst : Zero M] [inst_1 : AddCommMonoid R] [inst_2 : StarAddMonoid R]
(s : ι →₀ M) (f : ι → M → R), star (s.sum f) = s.sum fun i m => star f i m | true |
AlgebraicGeometry.StructureSheaf.instAlgebraCarrierStalkCommRingCatObjPresheafTopObjPushforwardTopMapObjFunctorOppositeOpensCarrierTopIsSheafGrothendieckTopologyStructureSheaf | Mathlib.AlgebraicGeometry.Spec | {R S : CommRingCat} →
(f : R ⟶ S) →
(p : PrimeSpectrum ↑R) →
Algebra ↑R
↑(((TopCat.Presheaf.pushforward CommRingCat (AlgebraicGeometry.Spec.topMap f)).obj
(AlgebraicGeometry.Spec.structureSheaf ↑S).obj).stalk
p) | true |
_private.Lean.Parser.Extension.0.Lean.Parser.ParserExtension.OLeanEntry.toEntry | Lean.Parser.Extension | Lean.Parser.ParserExtension.State →
Lean.Parser.ParserExtension.OLeanEntry → Lean.ImportM Lean.Parser.ParserExtension.Entry | true |
AddCircle.measurableEquivIoc | Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic | (T : ℝ) → [hT : Fact (0 < T)] → (a : ℝ) → AddCircle T ≃ᵐ ↑(Set.Ioc a (a + T)) | true |
CategoryTheory.functorProdFunctorEquivCounitIso._proof_4 | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u_4) [inst : CategoryTheory.Category.{u_1, u_4} A] (B : Type u_6)
[inst_1 : CategoryTheory.Category.{u_2, u_6} B] (C : Type u_5) [inst_2 : CategoryTheory.Category.{u_3, u_5} C]
{X Y : CategoryTheory.Functor A (B × C)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.functorProdT... | false |
BoundedContinuousFunction.tendsto_integral_of_forall_integral_le_liminf_integral | Mathlib.MeasureTheory.Integral.BoundedContinuousFunction | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] [OpensMeasurableSpace X] {ι : Type u_2}
{L : Filter ι} {μ : MeasureTheory.Measure X} [MeasureTheory.IsProbabilityMeasure μ] {μs : ι → MeasureTheory.Measure X}
[∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μs i)],
(∀ (f : BoundedContinuous... | true |
finprod_mem_union | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {s t : Set α},
Disjoint s t →
s.Finite → t.Finite → ∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i = (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i | true |
Quiver.HasInvolutiveReverse.rec | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} →
[inst : Quiver V] →
{motive : Quiver.HasInvolutiveReverse V → Sort u} →
([toHasReverse : Quiver.HasReverse V] →
(inv' : ∀ {a b : V} (f : a ⟶ b), Quiver.reverse (Quiver.reverse f) = f) →
motive { toHasReverse := toHasReverse, inv' := inv' }) →
(t : Quiver.HasInv... | false |
_private.Aesop.Forward.State.0.Aesop.InstMap.insertMatch.match_1 | Aesop.Forward.State | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((inst : Lean.Expr) → motive (some inst)) → ((x : Option Lean.Expr) → motive x) → motive x | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.