name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
RingHom.finitePresentation_ofLocalizationSpanTarget | Mathlib.RingTheory.RingHom.FinitePresentation | RingHom.OfLocalizationSpanTarget @RingHom.FinitePresentation | Finite-presentation can be checked on a standard covering of the target. | true |
Std.Do.SPred.entails.eq_1 | Std.Do.SPred.Laws | ∀ (P_2 Q_2 : Std.Do.SPred []), (P_2 ⊢ₛ Q_2) = (P_2.down → Q_2.down) | null | true |
CategoryTheory.Limits.Bicone.toBinaryBiconeFunctor._proof_8 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {X_1 Y_1 : CategoryTheory.Limits.Bicone (CategoryTheory.Limits.pairFunction X Y)} (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp f.hom
{ pt := Y_1.pt, fst := Y_1.π CategoryTheory.L... | null | false |
Lean.Widget.RpcEncodablePacket._sizeOf_1._@.Lean.Widget.UserWidget.577854155._hygCtx._hyg.1 | Lean.Widget.UserWidget | Lean.Widget.RpcEncodablePacket✝ → ℕ | null | false |
SSet.Subcomplex.Pairing.ofIso.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | ∀ {X : SSet} {A : X.Subcomplex} (P P_1 : A.Pairing),
P = P_1 →
∀ {Y : SSet} {B : Y.Subcomplex} (e e_1 : Y ≅ X) (e_e : e = e_1) (hA : A.preimage e.hom = B),
P.ofIso e hA = P_1.ofIso e_1 ⋯ | null | true |
_private.Mathlib.RingTheory.Localization.Integral.0.IsLocalization.integerNormalization_eval₂_eq_zero.match_1_1 | Mathlib.RingTheory.Localization.Integral | ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : IsLocalization M S] (p : Polynomial S)
(motive : (∃ b ∈ M, Polynomial.map (algebraMap R S) (IsLocalization.integerNormalization M p) = b • p) → Prop)
(x : ∃ b ∈ M, Polynomial.map (algebraMa... | null | false |
Colex.instAddCancelMonoid._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddCancelMonoid α], IsRightCancelAdd (Colex α) | null | false |
_private.Lean.Environment.0.Lean.Environment.ConstPromiseVal.mk.injEq | Lean.Environment | ∀ (privateConstInfo exportedConstInfo : Lean.ConstantInfo) (exts : Array Lean.EnvExtensionState)
(nestedConsts : Lean.VisibilityMap✝ Lean.AsyncConsts✝) (privateConstInfo_1 exportedConstInfo_1 : Lean.ConstantInfo)
(exts_1 : Array Lean.EnvExtensionState) (nestedConsts_1 : Lean.VisibilityMap✝ Lean.AsyncConsts✝),
({ ... | null | true |
_private.Mathlib.Analysis.Convex.Between.0.sbtw_of_sbtw_of_sbtw_of_mem_affineSpan_pair._simp_1_3 | Mathlib.Analysis.Convex.Between | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α] [inst_2 : DecidableLT α] {a : α}, (SignType.sign a = 1) = (0 < a) | null | false |
DFinsupp.coeFnLinearMap_apply | Mathlib.Data.DFinsupp.Module | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : Semiring γ] [inst_1 : (i : ι) → AddCommMonoid (β i)]
[inst_2 : (i : ι) → Module γ (β i)] (v : Π₀ (i : ι), β i), (DFinsupp.coeFnLinearMap γ) v = ⇑v | null | true |
Std.Http.URI.Port.omitted.sizeOf_spec | Std.Http.Data.URI.Basic | sizeOf Std.Http.URI.Port.omitted = 1 | null | true |
Bimod.instCategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{A B : CategoryTheory.Mon C} {X Y : Bimod A B} (f : X.Hom Y), Bimod.comp X.id' f = f | null | false |
Lean.Doc.MdRendererState.mk.inj | Lean.DocString.Markdown | ∀ {imported current imported_1 current_1 : Lean.NameMap Lean.Name},
{ imported := imported, current := current } = { imported := imported_1, current := current_1 } →
imported = imported_1 ∧ current = current_1 | null | true |
AddConstMap.mk.injEq | Mathlib.Algebra.AddConstMap.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H} (toFun : G → H)
(map_add_const' : ∀ (x : G), toFun (x + a) = toFun x + b) (toFun_1 : G → H)
(map_add_const'_1 : ∀ (x : G), toFun_1 (x + a) = toFun_1 x + b),
({ toFun := toFun, map_add_const' := map_add_const' } = { toFun := toFun_1, m... | null | true |
solvable_of_solvable_injective | Mathlib.GroupTheory.Solvable | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] {f : G →* G'},
Function.Injective ⇑f → ∀ [Group.IsSolvable G'], Group.IsSolvable G | **Alias** of `Group.isSolvable_of_isSolvable_injective`. | true |
CategoryTheory.Limits.cokernelOrderHom_coe | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasCokernels C] (X : C) (a : CategoryTheory.Subobject X),
(CategoryTheory.Limits.cokernelOrderHom X) a =
CategoryTheory.Subobject.lift (fun x f x_1 => CategoryTheory.Subob... | null | true |
CategoryTheory.WithInitial.liftUnique | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
{Z : D} →
(F : CategoryTheory.Functor C D) →
(M : (x : C) → Z ⟶ F.obj x) →
(hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.co... | The uniqueness of `lift`. | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.mkEMatchTheoremWithKind'? | Lean.Meta.Tactic.Grind.Internalize | Lean.Meta.Grind.Origin →
Array Lean.Name →
Lean.Expr →
Lean.Meta.Grind.EMatchTheoremKind →
Lean.Meta.Grind.SymbolPriorities → Lean.MetaM (Option Lean.Meta.Grind.EMatchTheorem) | null | true |
Stream'.WSeq.LiftRelO.eq_2 | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (C : Stream'.WSeq α → Stream'.WSeq β → Prop) (a : α) (s : Stream'.WSeq α)
(b : β) (t : Stream'.WSeq β), Stream'.WSeq.LiftRelO R C (some (a, s)) (some (b, t)) = (R a b ∧ C s t) | null | true |
SatisfiesM_Id_eq | Batteries.Recycling.MonadSatisfying.Basic | ∀ {type : Type u_1} {p : type → Prop} {x : Id type}, SatisfiesM p x ↔ p x | null | true |
CategoryTheory.Functor.PushoutObjObj.ι_iso_of_iso_right._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_5} {C₂ : Type u_6} {C₃ : Type u_2} [inst : CategoryTheory.Category.{u_3, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_4, u_6} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {f₁ : CategoryTheory.Arrow C₁}
{f₂ f₂' : CategoryTheory.... | null | false |
nonunits | Mathlib.RingTheory.Ideal.Nonunits | (α : Type u_4) → [Monoid α] → Set α | The set of non-invertible elements of a monoid. | true |
_private.Mathlib.Algebra.Group.Pointwise.Finset.Basic.0.Finset.card_le_card_sub_left.match_1_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} {s : Finset α} (motive : s.Nonempty → Prop) (hs : s.Nonempty),
(∀ (w : α) (ha : w ∈ s), motive ⋯) → motive hs | null | false |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Widget.InteractiveGoal.3114798910._hygCtx._hyg.1.recOn | Lean.Widget.InteractiveGoal | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
(t : Lean.Widget.RpcEncodablePacket✝) →
((hyps type ctx : Lean.Json) →
(userName? : Option Lean.Json) →
(goalPrefix mvarId : Lean.Json) →
(isInserted? isRemoved? : Option Lean.Json) →
motive
{ hyps :=... | null | false |
_private.Mathlib.Data.Nat.Choose.Basic.0.Nat.choose_mul_add._proof_1_1 | Mathlib.Data.Nat.Choose.Basic | ∀ {m n : ℕ},
(m * (n - 1 + 1) + (n - 1 + 1)).choose (n - 1 + 1) * ((m * (n - 1 + 1)).factorial * (n - 1 + 1).factorial) =
(m * (n - 1 + 1) + (n - 1 + 1)).choose (n - 1 + 1) * (m * (n - 1 + 1)).factorial * (n - 1 + 1).factorial | null | false |
MonoidHom.noncommPiCoprodEquiv._proof_4 | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {M : Type u_2} [inst : Monoid M] {ι : Type u_1} {N : ι → Type u_3} [inst_1 : (i : ι) → Monoid (N i)]
[inst_2 : DecidableEq ι] (f : ((i : ι) → N i) →* M) (x x_1 : ι),
x ≠ x_1 → ∀ (x_2 : N x) (y : N x_1), Commute (f (Pi.mulSingle x x_2)) (f (Pi.mulSingle x_1 y)) | null | false |
_private.Mathlib.Data.Set.Sigma.0.Set.sigma_eq_empty_iff._simp_1_3 | Mathlib.Data.Set.Sigma | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
Std.Time.OffsetX.hourMinuteSecond | Std.Time.Format.Modifier | Std.Time.OffsetX | Hour, minute, and second without colon (e.g., "+013015")
| true |
_private.Init.Data.SInt.Lemmas.0.Int8.toBitVec_max._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, (a ≤ b) = (a.toBitVec.sle b.toBitVec = true) | null | false |
LinearIsometry.extend._proof_7 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {V : Type u_2} [inst_1 : NormedAddCommGroup V] [inst_2 : InnerProductSpace 𝕜 V]
[FiniteDimensional 𝕜 V] {S : Submodule 𝕜 V} (L : ↥S →ₗᵢ[𝕜] V), FiniteDimensional 𝕜 ↥L.rangeᗮ | null | false |
MeasureTheory.SMulInvariantMeasure.mk | Mathlib.MeasureTheory.Group.Defs | ∀ {M : Type u_1} {α : Type u_2} [inst : SMul M α] {x : MeasurableSpace α} {μ : MeasureTheory.Measure α},
(∀ (c : M) ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c • x) ⁻¹' s) = μ s) → MeasureTheory.SMulInvariantMeasure M α μ | null | true |
MvPFunctor.WPath.child.noConfusion | Mathlib.Data.PFunctor.Multivariate.W | {n : ℕ} →
{P : MvPFunctor.{u} (n + 1)} →
{P_1 : Sort u_1} →
{a : P.A} →
{f : P.last.B a → P.last.W} →
{i : Fin2 n} →
{j : P.last.B a} →
{c : P.WPath (f j) i} →
{a' : P.A} →
{f' : P.last.B a' → P.last.W} →
{i' :... | null | false |
_private.Mathlib.CategoryTheory.Bicategory.Span.Basic.0.CategoryTheory.Span.SpanBicat.instBicategory._proof_49 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
AbstractSimplicialComplex.ext | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ {ι : Type u_1} {x y : AbstractSimplicialComplex ι}, x.faces = y.faces → x = y | null | true |
SimpleGraph.Iso.induce._proof_5 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} {s : Set V} {t : Set W} (φ : G ≃g G'),
Set.BijOn (⇑φ) s t → ∀ (w : ↑t), φ.symm ↑w ∈ s | null | false |
Std.Tactic.BVDecide.BVExpr._impl.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : (a : ℕ) → Std.Tactic.BVDecide.BVExpr._impl a → Sort u} →
{a : ℕ} →
(t : Std.Tactic.BVDecide.BVExpr._impl a) →
((hashCode : UInt64) → {w : ℕ} → (idx : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var._impl hashCode idx)) →
((hashCode : UInt64) →
{w : ℕ} → (val : BitVec w) → motive ... | null | false |
Std.Internal.List.getKey?._f | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [BEq α] → α → (x : List ((a : α) × β a)) → List.below x → Option α | null | false |
Nat.lt_of_shiftLeft_lt | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b c : ℕ}, a <<< b < c → a < c | null | true |
dite_mem | Mathlib.Basic.Logic.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Membership α β] {p : Prop} [inst_1 : Decidable p] {a : p → α} {b : ¬p → α}
{s : β}, (if h : p then a h else b h) ∈ s ↔ (∀ (h : p), a h ∈ s) ∧ ∀ (h : ¬p), b h ∈ s | null | true |
MeasureTheory.Measure.ext_of_sUnion_eq_univ | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {S : Set (Set α)},
S.Countable → ⋃₀ S = Set.univ → (∀ s ∈ S, μ.restrict s = ν.restrict s) → μ = ν | **Alias** of the reverse direction of `MeasureTheory.Measure.ext_iff_of_sUnion_eq_univ`.
---
Two measures are equal if they have equal restrictions on a spanning collection of sets
(formulated using `sUnion`). | true |
UpperHalfPlane.instNontrivial | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | Nontrivial UpperHalfPlane | null | true |
CategoryTheory.Limits.reflexiveCoequalizerIsoCoequalizer.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C)
[inst_1 :
CategoryTheory.Limits.HasCoequalizer (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.left)
(F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.right)],
Cat... | null | true |
WittVector.instAddCommGroupStandardOneDimIsocrystal._proof_10 | Mathlib.RingTheory.WittVector.Isocrystal | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (k : Type u_1) [inst_1 : CommRing k] (_m : ℤ),
autoParam (∀ (x : WittVector.StandardOneDimIsocrystal p k _m), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
SkewMonoidAlgebra.single_eq_zero | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {a : G} {b : k}, SkewMonoidAlgebra.single a b = 0 ↔ b = 0 | null | true |
Unitization.instMulOneClass._proof_4 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : DistribMulAction R A]
(a : Unitization R A), a * 1 = a | null | false |
CochainComplex.mappingCone.descShortComplex_naturality | Mathlib.Algebra.Homology.HomotopyCategory.ShortExact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{S₁ S₂ : CategoryTheory.ShortComplex (CochainComplex C ℤ)} (f : S₁ ⟶ S₂),
CategoryTheory.CategoryStruct.comp (CochainComplex.mappingCone.map S₁.f S₂.f f.τ₁ f.τ₂ ⋯)
(CochainComplex.mappingCone.descShortComplex S₂... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Hall.0.SimpleGraph.hall_subgraph._proof_3 | Mathlib.Combinatorics.SimpleGraph.Hall | ∀ {V : Type u_1} {G : SimpleGraph V} {p : Set V} [inst : DecidablePred fun x => x ∈ p] (f : ↑p → V),
(∀ (x : ↑p), G.Adj (↑x) (f x)) →
∀ {v w : V}, (if h : v ∈ p then f ⟨v, h⟩ = w else if h : w ∈ p then f ⟨w, h⟩ = v else False) → G.Adj v w | null | false |
Convexity.ConvexSpace.AffineMap.coe_mk | Mathlib.Geometry.Convex.ConvexSpace.AffineMap | ∀ {R : Type u_1} [inst : PartialOrder R] [inst_1 : Semiring R] [inst_2 : IsStrictOrderedRing R] {X : Type u_2}
{Y : Type u_3} [inst_3 : Convexity.ConvexSpace R X] [inst_4 : Convexity.ConvexSpace R Y] (toFun : X → Y)
(isAffineMap_toFun : Convexity.IsAffineMap R toFun),
⇑{ toFun := toFun, isAffineMap_toFun := isAff... | null | true |
Set.encard_insert_le | Mathlib.Data.Set.Card | ∀ {α : Type u_1} (s : Set α) (x : α), (insert x s).encard ≤ s.encard + 1 | null | true |
String.Slice.copy_sliceFrom_cast | Init.Data.String.Lemmas.Splits | ∀ {s t : String.Slice} (hst : s.copy = t.copy) {pos : s.Pos}, (t.sliceFrom (pos.cast hst)).copy = (s.sliceFrom pos).copy | null | true |
CategoryTheory.GrothendieckTopology.pseudofunctorOver_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_obj_str_id_hom_app | Mathlib.CategoryTheory.Sites.PseudofunctorSheafOver | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} A] (b : CategoryTheory.LocallyDiscrete Cᵒᵖ)
(X : CategoryTheory.ObjectProperty.FullSubcategory (CategoryTheory.Presheaf.IsSheaf (J.over (Opposite.unop b.as)))... | null | true |
OrderedFinpartition.eraseLeft | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | {n : ℕ} → (c : OrderedFinpartition (n + 1)) → Set.range (c.emb 0) = {0} → OrderedFinpartition n | Given an ordered finpartition of `n+1`, with a leftmost atom equal to `{0}`, remove this
atom to form an ordered finpartition of `n`. | true |
groupHomology.isoShortComplexH1._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | (ComplexShape.down ℕ).prev 1 = 2 | null | false |
Quiver.SingleObj.toPrefunctor_apply_obj | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (a : Quiver.SingleObj α), (Quiver.SingleObj.toPrefunctor f).obj a = id a | null | true |
SheafOfModules.GeneratingSections.I | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | {C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] → {M : SheafOfModules R} → M.Gen... | the index type for the sections | true |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_29 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (cache : Std.Tactic.BVDecide.BVExpr.Cache aig) (w n : ℕ)
(lhs : Std.Tactic.BVDecide.BVExpr w) (rhs : Std.Tactic.BVDecide.BVExpr n),
(invImage
(fun x =>
PSum.casesOn x
(fun _x =>
PSigma.casesOn _x fun w aig =>
... | null | false |
CategoryTheory.Regular.instMonoDesc | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Regular C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono (CategoryTheory.Limits.coequalizer.desc f ⋯) | null | true |
List.isPrefixOf_nil_left | Init.Data.List.Basic | ∀ {α : Type u} {l : List α} [inst : BEq α], [].isPrefixOf l = true | null | true |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.of.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | ∀ (η : Mathlib.Tactic.BicategoryLike.HorizontalComp),
sizeOf (Mathlib.Tactic.BicategoryLike.WhiskerLeft.of η) = 1 + sizeOf η | null | true |
smul_preimage_set_subsetₛₗ | Mathlib.GroupTheory.GroupAction.Pointwise | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_3} {α : Type u_4} {β : Type u_5} {σ : M → N} [inst : SMul M α]
[inst_1 : SMul N β] [inst_2 : FunLike F α β] [MulActionSemiHomClass F σ α β] (f : F) (c : M) (t : Set β),
c • ⇑f ⁻¹' t ⊆ ⇑f ⁻¹' (σ c • t) | Translation of preimage is contained in preimage of translation | true |
pathComponent_subset_component | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X), pathComponent x ⊆ connectedComponent x | null | true |
CoalgEquiv.toCoalgIso | Mathlib.Algebra.Category.CoalgCat.Basic | {R : Type u} →
[inst : CommRing R] →
{X Y : Type v} →
[inst_1 : AddCommGroup X] →
[inst_2 : Module R X] →
[inst_3 : AddCommGroup Y] →
[inst_4 : Module R Y] → [inst_5 : Coalgebra R X] → [inst_6 : Coalgebra R Y] → (X ≃ₗc[R] Y) → (↧X ≅ ↧Y) | Build an isomorphism in the category `CoalgCat R` from a
`CoalgEquiv`. | true |
Std.DTreeMap.Internal.Impl.link._unsafe_rec | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
(k : α) →
β k →
(l r : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → r.Balanced → Std.DTreeMap.Internal.Impl.Tree α β (l.size + 1 + r.size) | null | false |
ProbabilityTheory.«term𝔼[_]» | Mathlib.Probability.Notation | Lean.ParserDescr | `𝔼[X]` is the expectation of `X`, defined as its Lebesgue integral. | true |
_private.Mathlib.RingTheory.SimpleModule.WedderburnArtin.0.isSemisimpleRing_iff_pi_matrix_divisionRing.match_1_1 | Mathlib.RingTheory.SimpleModule.WedderburnArtin | ∀ {R : Type u_1} [inst : Ring R]
(motive :
(∃ n D d x, (∀ (i : Fin n), NeZero (d i)) ∧ Nonempty (R ≃+* ((i : Fin n) → Matrix (Fin (d i)) (Fin (d i)) (D i)))) →
Prop)
(x :
∃ n D d x, (∀ (i : Fin n), NeZero (d i)) ∧ Nonempty (R ≃+* ((i : Fin n) → Matrix (Fin (d i)) (Fin (d i)) (D i)))),
(∀ (n : ℕ) (D ... | null | false |
IsOpen.analyticSet_image | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_3} [inst_1 : TopologicalSpace β] [PolishSpace β] {s : Set β},
IsOpen s → ∀ {f : β → α}, Continuous f → MeasureTheory.AnalyticSet (f '' s) | The image of an open set under a continuous map is analytic. | true |
AlgebraicTopology.DoldKan.N₁Γ₀_app | Mathlib.AlgebraicTopology.DoldKan.GammaCompN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ),
AlgebraicTopology.DoldKan.N₁Γ₀.app K =
(AlgebraicTopology.DoldKan.Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.symm ≪≫
(Categ... | null | true |
Subalgebra.copy_eq | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S : Subalgebra R A)
(s : Set A) (hs : s = ↑S), S.copy s hs = S | null | true |
AntisymmRel.not_incompRel | Mathlib.Order.Comparable | ∀ {α : Type u_1} {a b : α} {r : α → α → Prop}, AntisymmRel r a b → ¬IncompRel r a b | null | true |
Std.PRange.instToStreamRiiIterIteratorOfUpwardEnumerableOfLeast? | Init.Data.Range.Polymorphic.Stream | {α : Type} → [Std.PRange.UpwardEnumerable α] → [Std.PRange.Least? α] → Std.ToStream (Std.Rii α) (Std.Iter α) | null | true |
IO.TaskState.noConfusionType | Init.System.IO | Sort v✝ → IO.TaskState → IO.TaskState → Sort v✝ | null | true |
closedPoints | Mathlib.Topology.JacobsonSpace | (X : Type u_1) → [TopologicalSpace X] → Set X | The set of closed points. | true |
Lean.Grind.Field.NormNum.inv_eq | Init.Grind.FieldNormNum | ∀ {α : Type u_1} [inst : Lean.Grind.Field α] (a : α) (v₁ v : ℚ),
(v == v₁⁻¹) = true → a = Lean.Grind.Field.NormNum.ofRat v₁ → a⁻¹ = Lean.Grind.Field.NormNum.ofRat v | null | true |
nhds_zero_symm' | Mathlib.Topology.Algebra.Group.Basic | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G],
Filter.map Neg.neg (nhds 0) = nhds 0 | null | true |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.solve.match_1 | Mathlib.Tactic.Positivity.Core | (motive : Bool → Sort u_1) → (__x : Bool) → (Unit → motive true) → ((x : Bool) → motive x) → motive __x | null | false |
List.dropLast_cons₂ | Init.Data.List.Basic | ∀ {α : Type u_1} {x y : α} {zs : List α}, (x :: y :: zs).dropLast = x :: (y :: zs).dropLast | null | true |
_private.Mathlib.Combinatorics.Derangements.Finite.0.card_derangements_fin_eq_numDerangements._proof_1_2 | Mathlib.Combinatorics.Derangements.Finite | ∀ (n : ℕ), n < n + 1 + 1 | null | false |
AddSubmonoid.LocalizationMap.of_addEquivOfAddEquiv | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [inst_3 : AddCommMonoid Q]
{k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S ... | null | true |
_private.Mathlib.Data.Finset.Prod.0.Finset.nontrivial_prod_iff._simp_1_2 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {s : Finset α}, s.Nontrivial = (1 < s.card) | null | false |
LieAdmissibleAlgebra.noConfusionType | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | Sort u →
{R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieAdmissibleRing L] →
LieAdmissibleAlgebra R L →
{R' : Type u_1} →
{L' : Type u_2} →
[inst' : CommRing R'] → [inst'_1 : LieAdmissibleRing L'] → LieAdmissibleAlgebra R' L' →... | null | false |
one_divp | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), 1 /ₚ u = ↑u⁻¹ | null | true |
unitInterval.image_coe_preimage_symm | Mathlib.Topology.UnitInterval | ∀ {s : Set ↑unitInterval}, Subtype.val '' unitInterval.symm ⁻¹' s = (fun x => 1 - x) ⁻¹' Subtype.val '' s | null | true |
CategoryTheory.StructuredArrow.mapIso_unitIso_inv_app_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S S' : D} {T : CategoryTheory.Functor C D} (i : S ≅ S')
(X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) T),
((CategoryTheory.StructuredArrow.mapIso i).unitIso.inv.app X).right = ... | null | true |
Ordnode.foldr._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → {β : Sort u_2} → (α → β → β) → Ordnode α → β → β | null | false |
Algebra.pushoutDesc_left | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type v₃} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {R' : Type u_6}
(S' : Type u_7) [inst_3 : CommSemiring R'] [inst_4 : CommSemiring S'] [inst_5 : Algebra R R'] [inst_6 : Algebra S S']
[inst_7 : Algebra R' S'] [inst_8 : Algebra R S'] [inst_9 : IsScalarTower R R' ... | null | true |
CategoryTheory.ObjectProperty.prop_iSup_iff._simp_1 | Mathlib.CategoryTheory.ObjectProperty.CompleteLattice | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Sort u_1} (P : α → CategoryTheory.ObjectProperty C)
(X : C), (⨆ a, P a) X = ∃ a, P a X | null | false |
Orientation.basisRightAngleRotation | Mathlib.Analysis.InnerProductSpace.TwoDim | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : InnerProductSpace ℝ E] →
[Fact (Module.finrank ℝ E = 2)] → Orientation ℝ E (Fin 2) → (x : E) → x ≠ 0 → Module.Basis (Fin 2) ℝ E | For a nonzero vector `x` in an oriented two-dimensional real inner product space `E`,
`![x, J x]` forms an (orthogonal) basis for `E`. | true |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toBasicOpenₗ | Mathlib.AlgebraicGeometry.StructureSheaf | (R M : Type u) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(f : R) →
LocalizedModule.Away f M →ₗ[R]
(AlgebraicGeometry.structureSheafInType R M).obj.obj (Opposite.op (PrimeSpectrum.basicOpen f)) | The canonical linear map interpreting `s ∈ M_f` as a section of the structure sheaf
on the basic open defined by `f ∈ R`. | true |
_private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.type_eq_one_iff_unique.match_1_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u_1} (motive : Nonempty (Unique α) → Prop) (x : Nonempty (Unique α)),
(∀ (val : Unique α), motive ⋯) → motive x | null | false |
IsometryEquiv.instEquivLike | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} → {β : Type v} → [inst : PseudoEMetricSpace α] → [inst_1 : PseudoEMetricSpace β] → EquivLike (α ≃ᵢ β) α β | null | true |
isAtomistic_dual_iff_isCoatomistic._simp_1 | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : OrderTop α], IsAtomistic αᵒᵈ = IsCoatomistic α | null | false |
WithTop.lt_iff_exists_coe | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] {x y : WithTop α}, y < x ↔ ∃ b, y = ↑b ∧ ↑b < x | null | true |
List.subset_cons_of_subset._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, l₁ ⊆ l₂ → (l₁ ⊆ a :: l₂) = True | null | false |
PNat.XgcdType.vp | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ × ℕ | The map `v` gives the product of the matrix
`[[w, x], [y, z]] = [[wp + 1, x], [y, zp + 1]]`
and the vector `[a, b] = [ap + 1, bp + 1]`. The map
`vp` gives `[sp, tp]` such that `v = [sp + 1, tp + 1]`.
| true |
Filter.map_sumElim_eq | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (l : Filter (α ⊕ β)) (m₁ : α → γ) (m₂ : β → γ),
Filter.map (Sum.elim m₁ m₂) l = Filter.map m₁ (Filter.comap Sum.inl l) ⊔ Filter.map m₂ (Filter.comap Sum.inr l) | null | true |
ArchimedeanClass.mk_neg | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (a : M),
ArchimedeanClass.mk (-a) = ArchimedeanClass.mk a | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Hall.0.SimpleGraph.exists_bijective_of_forall_ncard_le._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Hall | ∀ {V : Type u_1} {p₁ p₂ : Set V} (f : V → V),
(∀ x ∈ p₁, f x ∉ p₁) → (∀ (x : V), f x ∈ p₁ ∨ f x ∈ p₂) → ∀ (x : ↑p₁), f ↑x ∈ p₂ | null | false |
Manifold.IsSubmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_4 | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_2} {E'' : Type u_3} {F : Type u_4} {H : Type u_5} {G : Type u_6} {E : Type u_1}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace 𝕜 F]... | null | false |
IsMulFG.mk._flat_ctor | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_3} [inst : Mul M], (∃ S, Subsemigroup.closure ↑S = ⊤) → IsMulFG M | null | false |
Lean.Compiler.LCNF.Specialize.findSpecCache? | Lean.Compiler.LCNF.Specialize | Lean.Expr → Lean.CoreM (Option Lean.Name) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.