name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Do.PostCond.0.Std.Do.ExceptConds.entails.match_1.eq_3 | Std.Do.PostCond | ∀ (motive : (ps : Std.Do.PostShape) → Std.Do.ExceptConds ps → Std.Do.ExceptConds ps → Sort u_2) (ε : Type u_1)
(ps : Std.Do.PostShape) (x y : Std.Do.ExceptConds (Std.Do.PostShape.except ε ps))
(h_1 : (x y : Std.Do.ExceptConds Std.Do.PostShape.pure) → motive Std.Do.PostShape.pure x y)
(h_2 :
(σ : Type u_1) →
... | null | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.dense_iff_iUnion_ball._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
CategoryTheory.Enriched.FunctorCategory.isLimitConeFunctorEnrichedHom._proof_1 | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{C : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} C] {J : Type u_4}
[inst_3 : CategoryTheory.Category.{u_3, u_4} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C]
(F₁ F₂ : CategoryTheory.F... | null | false |
_private.Mathlib.Topology.Order.IsLUB.0.ConditionallyCompleteLinearOrder.isCompact_Icc.match_1_6 | Mathlib.Topology.Order.IsLUB | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] (f : Ultrafilter α) (c : α)
(motive : (∃ x, c < x ∧ Set.Iio x ∉ f) → Prop) (x : ∃ x, c < x ∧ Set.Iio x ∉ f),
(∀ (x : α) (hx : c < x) (hxf : Set.Iio x ∉ f), motive ⋯) → motive x | null | false |
MulAction.IsPreprimitive.isQuasiPreprimitive | Mathlib.GroupTheory.GroupAction.Primitive | ∀ {M : Type u_3} [inst : Group M] {α : Type u_4} [inst_1 : MulAction M α] [MulAction.IsPreprimitive M α],
MulAction.IsQuasiPreprimitive M α | In a preprimitive action, any normal subgroup that acts nontrivially is pretransitive
(Wielandt, th. 7.1). | true |
Lean.Meta.ExprConfigCacheKey.expr | Lean.Meta.Basic | Lean.Meta.ExprConfigCacheKey → Lean.Expr | null | true |
_private.Mathlib.Analysis.Complex.Convex.0.Complex.rectangle_eq_convexHull._simp_1_2 | Mathlib.Analysis.Complex.Convex | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (x y : 𝕜),
Set.uIcc x y = segment 𝕜 x y | null | false |
_private.Mathlib.RingTheory.QuasiFinite.Weakly.0.Algebra.WeaklyQuasiFiniteAt.of_quasiFiniteAt_residueField._simp_1_1 | Mathlib.RingTheory.QuasiFinite.Weakly | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A],
(algebraMap S A).comp (algebraMap R S) = algebraMap R A | null | false |
IsAtom.uniqueFinpartition._proof_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} {P : Finpartition a} (ha : IsAtom a)
(P : Finpartition a), P = Finpartition.indiscrete ⋯ | null | false |
SSet.horn₂₁.isPushout | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | CategoryTheory.IsPushout (SSet.stdSimplex.δ 0) (SSet.stdSimplex.δ 1) SSet.horn₂₁.ι₀₁ SSet.horn₂₁.ι₁₂ | null | true |
MulChar.val_neg_one_eq_one_of_odd_order | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} {R' : Type u_2} [inst : CommRing R] [inst_1 : CommMonoidWithZero R'] {χ : MulChar R R'} {n : ℕ},
Odd n → χ ^ n = 1 → χ (-1) = 1 | If `χ` is of odd order, then `χ(-1) = 1` | true |
Lean.OLeanLevel.casesOn | Lean.Environment | {motive : Lean.OLeanLevel → Sort u} →
(t : Lean.OLeanLevel) →
motive Lean.OLeanLevel.exported → motive Lean.OLeanLevel.server → motive Lean.OLeanLevel.private → motive t | null | false |
CalcPanel.rpc._rpc_wrapped | Mathlib.Tactic.Widget.Calc | Lean.Server.RpcProcedure | null | false |
FirstOrder.Language.Substructure.closure._proof_1 | Mathlib.ModelTheory.Substructures | ∀ (L : FirstOrder.Language) {M : Type u_1} [inst : L.Structure M] (x : Set M) (x_1 : L.Substructure M),
sInf {S | x ⊆ ↑S} ≤ x_1 ↔ x ⊆ ↑x_1 | null | false |
CategoryTheory.Presieve.CoverByImageStructure.mk._flat_ctor | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{G : CategoryTheory.Functor C D} →
{V U : D} →
{f : V ⟶ U} →
(obj : C) →
(lift : V ⟶ G.obj obj) →
... | null | false |
FirstOrder.Field.FieldAxiom.addAssoc.elim | Mathlib.ModelTheory.Algebra.Field.Basic | {motive : FirstOrder.Field.FieldAxiom → Sort u} →
(t : FirstOrder.Field.FieldAxiom) → t.ctorIdx = 0 → motive FirstOrder.Field.FieldAxiom.addAssoc → motive t | null | false |
isNoetherian_mk | Mathlib.RingTheory.Noetherian.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
WellFoundedGT (Submodule R M) → IsNoetherian R M | **Alias** of the reverse direction of `isNoetherian_iff`. | true |
GenLoop.Homotopic | Mathlib.Topology.Homotopy.HomotopyGroup | {N : Type u_1} → {X : Type u_2} → [inst : TopologicalSpace X] → {x : X} → ↑(GenLoop N X x) → ↑(GenLoop N X x) → Prop | The "homotopic relative to boundary" relation between `GenLoop`s. | true |
TopologicalSpace.IsSeparable.of_separableSpace | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] [h : TopologicalSpace.SeparableSpace α] (s : Set α),
TopologicalSpace.IsSeparable s | null | true |
Lean.Lsp.ResolvableCompletionItemData._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.ResolvableCompletionItemData | null | false |
QuadraticModuleCat.cliffordAlgebra_map | Mathlib.LinearAlgebra.CliffordAlgebra.CategoryTheory | ∀ {R : Type u} [inst : CommRing R] {_M _N : QuadraticModuleCat R} (f : _M ⟶ _N),
QuadraticModuleCat.cliffordAlgebra.map f = AlgCat.ofHom (CliffordAlgebra.map (QuadraticModuleCat.Hom.toIsometry f)) | null | true |
List.length_permutationsAux | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} (ts is : List α),
(ts.permutationsAux is).length + is.length.factorial = (ts.length + is.length).factorial | null | true |
Lean.Server.LspResponse.mk.noConfusion | Lean.Server.Requests | {α : Type} →
{P : Sort u} →
{response : α} →
{isComplete : Bool} →
{response' : α} →
{isComplete' : Bool} →
{ response := response, isComplete := isComplete } = { response := response', isComplete := isComplete' } →
(response ≍ response' → isComplete = isComplete'... | null | false |
Asymptotics.IsBigOWith.comp_tendsto | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E}
{g : α → F} {l : Filter α},
Asymptotics.IsBigOWith c l f g →
∀ {k : β → α} {l' : Filter β}, Filter.Tendsto k l' l → Asymptotics.IsBigOWith c l' (f ∘ k) (g ∘ k) | null | true |
Std.DTreeMap.Equiv.maxEntry_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
{he : t₁.isEmpty = false} (h : t₁.Equiv t₂), t₁.maxEntry he = t₂.maxEntry ⋯ | null | true |
Std.Time.Week.OfYear.instOrdOrdinal | Std.Time.Date.Unit.Week | Ord Std.Time.Week.OfYear.Ordinal | null | true |
Mathlib.Tactic.Ring.Common.evalAtom | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute bt sα →
Mathlib.Tactic.Ring.Common.RingCompute Mathlib.Tactic.Ring.Common.btℕ Mathlib.Tactic.Ring.Common.sℕ →
(e : Q(«$α»)) →
Mathlib.... | Evaluates an atom, an expression where `ring` can find no additional structure.
* `a = a ^ 1 * 1 + 0`
| true |
_private.Lean.Parser.Tactic.Doc.0.Lean.Parser.Tactic.Doc.initFn.match_3._@.Lean.Parser.Tactic.Doc.710499956._hygCtx._hyg.2 | Lean.Parser.Tactic.Doc | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → ((tgt' : Lean.Name) → motive (some tgt')) → ((x : Option Lean.Name) → motive x) → motive x | null | false |
Polynomial.instNormalizationMonoid._proof_5 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u_1} [inst : CommRing R] [NoZeroDivisors R] [inst_2 : NormalizationMonoid R] {a : Polynomial R}
(u : (Polynomial R)ˣ),
a ≠ 0 →
↑{ val := Polynomial.C ↑(normUnit (a * ↑u).leadingCoeff), inv := Polynomial.C ↑(normUnit (a * ↑u).leadingCoeff)⁻¹,
val_inv := ⋯, inv_val := ⋯ } =
↑(u⁻¹ *
... | null | false |
mdifferentiableAt_atlas | Mathlib.Geometry.Manifold.MFDeriv.Atlas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {e : OpenPartialHomeomorph M H} [IsMani... | null | true |
AlgebraicGeometry.Scheme.Modules.instHasLimits | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme}, CategoryTheory.Limits.HasLimits X.Modules | null | true |
MeasureTheory.OuterMeasure.comap | Mathlib.MeasureTheory.OuterMeasure.Operations | {α : Type u_1} → {β : Type u_3} → (α → β) → MeasureTheory.OuterMeasure β →ₗ[ENNReal] MeasureTheory.OuterMeasure α | Pullback of an `OuterMeasure`: `comap f μ s = μ (f '' s)`. | true |
StarAlgEquiv.isometry | Mathlib.Analysis.CStarAlgebra.Spectrum | ∀ {F : Type u_1} {A : Type u_2} {B : Type u_3} [inst : NonUnitalCStarAlgebra A] [inst_1 : NonUnitalCStarAlgebra B]
[inst_2 : EquivLike F A B] [NonUnitalAlgEquivClass F ℂ A B] [StarHomClass F A B] (φ : F), Isometry ⇑φ | null | true |
Rep.instModuleHom._proof_1 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_2} {G : Type u_3} [inst : CommSemiring k] [inst_1 : Monoid G] {M N : Rep.{u_1, u_2, u_3} k G} (c : k)
(x : M ⟶ N),
{ toFun := Rep.Hom.hom, map_zero' := ⋯, map_add' := ⋯ } (c • x) =
c • { toFun := Rep.Hom.hom, map_zero' := ⋯, map_add' := ⋯ } x | null | false |
Std.ExtDTreeMap.minEntry! | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → [Inhabited ((a : α) × β a)] → Std.ExtDTreeMap α β cmp → (a : α) × β a | Tries to retrieve the key-value pair with the smallest key in the tree map, panicking if the map is
empty.
| true |
Ideal.exists_mem_pow_notMem_pow_succ | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {A : Type u_2} [inst : CommRing A] [IsDedekindDomain A] (I : Ideal A),
I ≠ ⊥ → I ≠ ⊤ → ∀ (e : ℕ), ∃ x ∈ I ^ e, x ∉ I ^ (e + 1) | null | true |
Set.Ico_subset_Ico_left | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b : α}, a₁ ≤ a₂ → Set.Ico a₂ b ⊆ Set.Ico a₁ b | null | true |
StarOrderedRing.nonneg_iff_spectrum_nonneg | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [ContinuousSqrt R]
[StarOrderedRing R] [inst_8 : TopologicalSpace A] [inst_9 : Ring A] [inst_10 : StarRing A]... | null | true |
ConvexCone.map.match_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_3} {M : Type u_2} {N : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N] (f : M →ₗ[R] N) (C : ConvexCone R M) (x : N)
(motive : x ∈ ⇑f '' ↑C → Prop) (x_1 : x ∈ ⇑f '' ↑C),
(∀ (x_2 : M) (hx : x_2 ∈ ... | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.AssocList.forInStep.go.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m]
(f : (a : α) → β a → δ → m (ForInStep δ)) (a : δ) (k : α) (v : β k) (t : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.forInStep.go✝ f (Std.DHashMap.Internal.AssocList.cons k v t) a = do
let __do_lift ← ... | null | true |
MatrixEquivTensor.toFunBilinear | Mathlib.RingTheory.MatrixAlgebra | (n : Type u_3) →
(R : Type u_5) →
(A : Type u_7) →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → A →ₗ[R] Matrix n n R →ₗ[R] Matrix n n A | (Implementation detail).
The function underlying `(A ⊗[R] Matrix n n R) →ₐ[R] Matrix n n A`,
as an `R`-bilinear map.
| true |
ENNReal.ofNat_lt_ofReal | Mathlib.Basic.ENNReal.Real | ∀ {n : ℕ} [inst : n.AtLeastTwo] {r : ℝ}, OfNat.ofNat n < ENNReal.ofReal r ↔ OfNat.ofNat n < r | null | true |
sdiff_subset_closure_iff | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, s \ t ⊆ closure t ↔ s ⊆ closure t | null | true |
Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Linear.Types | SizeOf Lean.Meta.Grind.Arith.Linear.EqCnstr | null | false |
CategoryTheory.MorphismProperty.HasPullbacksAgainst | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.MorphismProperty C → CategoryTheory.MorphismProperty C → Prop | `P.HasPullbacksAgainst P'` states that for any morphism `f` satisfying `P'`,
`P` has pullbacks along `f`. | true |
Lean.Lsp.TextDocumentEdit | Lean.Data.Lsp.Basic | Type | A batch of `TextEdit`s to perform on a versioned text document.
[reference](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocumentEdit) | true |
Measurable.sub_stronglyMeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_5} {E : Type u_6} {x : MeasurableSpace α} [inst : AddGroup E] [inst_1 : TopologicalSpace E]
[inst_2 : MeasurableSpace E] [BorelSpace E] [ContinuousAdd E] [ContinuousNeg E]
[TopologicalSpace.PseudoMetrizableSpace E] {g f : α → E},
Measurable g → MeasureTheory.StronglyMeasurable f → Measurable (g - f) | In a normed vector space, the subtraction of a measurable function and a strongly measurable
function is measurable. Note that this is not true without further second-countability assumptions
for the subtraction of two measurable functions. | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.State._sizeOf_inst | Mathlib.Tactic.GRewrite.Core | SizeOf Mathlib.Tactic.GRewrite.State✝ | null | false |
_private.Mathlib.Topology.MetricSpace.PartitionOfUnity.0.Metric.eventually_nhds_zero_forall_closedEBall_subset._simp_1_3 | Mathlib.Topology.MetricSpace.PartitionOfUnity | ∀ {a b : Prop}, (¬a → ¬b) = (b → a) | null | false |
CategoryTheory.Functor.IsContinuous.mk | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {J : CategoryTheory.GrothendieckTopology C}
{K : CategoryTheory.GrothendieckTopology D},
(∀ (G : CategoryTheory.Sheaf K (Type (max u₁ v₁ u₂ v₂))), CategoryTheory... | null | true |
OrderIso.map_ciSup | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α]
[inst_1 : ConditionallyCompleteLattice β] [Nonempty ι] (e : α ≃o β) {f : ι → α},
BddAbove (Set.range f) → e (⨆ i, f i) = ⨆ i, e (f i) | null | true |
CategoryTheory.Functor.congr_inv_of_congr_hom | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F G : CategoryTheory.Functor C D) {X Y : C} (e : X ≅ Y) (hX : F.obj X = G.obj X) (hY : F.obj Y = G.obj Y),
F.map e.hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
... | null | true |
Nat.floor_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] (n : ℕ)
[inst_3 : n.AtLeastTwo], ⌊OfNat.ofNat n⌋₊ = OfNat.ofNat n | null | true |
CategoryTheory.Comonad.coalgebraPreadditive_homGroup_zsmul_f | Mathlib.CategoryTheory.Preadditive.EilenbergMoore | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C]
(U : CategoryTheory.Comonad C) [inst_2 : U.Additive] (F G : U.Coalgebra) (r : ℤ) (α : F ⟶ G), (r • α).f = r • α.f | null | true |
AffineIsometry.mk._flat_ctor | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_4} →
{P : Type u_7} →
{P₂ : Type u_8} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[inst_4 : Norme... | null | false |
Finset.card_div_eq | Mathlib.Combinatorics.Additive.Convolution | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (A B : Finset G) (x : G),
{ab ∈ A ×ˢ B | ab.1 / ab.2 = x}.card = A.convolution B⁻¹ x | null | true |
HopfAlgebraStruct.antipode | Mathlib.RingTheory.HopfAlgebra.Basic | (R : Type u) →
{A : Type v} → {inst : CommSemiring R} → {inst_1 : Semiring A} → [self : HopfAlgebraStruct R A] → A →ₗ[R] A | The antipode of the Hopf algebra. | true |
WithBot.unbot_eq_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : WithBot α} {b : α} (h : a ≠ ⊥), a.unbot h = b ↔ a = ↑b | null | true |
Option.pmap_bind_id_eq_pmap_join | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {f : (a : α) → p a → β} {x : Option (Option α)}
(H : ∀ (a : Option α), x = some a → ∀ (a_2 : α), a = some a_2 → p a_2),
((Option.pmap (Option.pmap f) x H).bind fun a => a) = Option.pmap f x.join ⋯ | null | true |
CategoryTheory.Limits.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Terminal___macroRules_CategoryTheory_Limits_term⊤___1» | Mathlib.CategoryTheory.Limits.Shapes.Terminal | Lean.Macro | null | false |
Real.range_log | Mathlib.Analysis.SpecialFunctions.Log.Basic | Set.range Real.log = Set.univ | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal.0.SSet.Truncated.IsStrictSegal.hom_ext._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) {F : D → D → Type uF} {carrier : D → Type w}
{instFunLike : (X Y : D) → FunLike (F X Y) (carrier X) (carrier Y)} [inst_2 : C... | null | false |
Equiv.subtypeUnivEquiv._proof_2 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {p : α → Prop} (h : ∀ (x : α), p x) (x : Subtype p), ⟨↑x, ⋯⟩ = x | null | false |
Lean.Omega.Coeffs.findIdx? | Init.Omega.Coeffs | (ℤ → Bool) → Lean.Omega.Coeffs → Option ℕ | Shim for `.enum.find?`. | true |
CategoryTheory.Abelian.hasFiniteLimits | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C],
CategoryTheory.Limits.HasFiniteLimits C | null | true |
CompleteSublattice.mem_top._simp_1 | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {x : X}, (x ∈ ⊤) = True | null | false |
Lean.Lsp.SymbolKind.variable.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.variable = 1 | null | true |
Lean.Lsp.Ipc.CallHierarchy.noConfusion | Lean.Data.Lsp.Ipc | {P : Sort u} → {t t' : Lean.Lsp.Ipc.CallHierarchy} → t = t' → Lean.Lsp.Ipc.CallHierarchy.noConfusionType P t t' | null | false |
Lean.PersistentArray.getAux | Lean.Data.PersistentArray | {α : Type u} → [Inhabited α] → Lean.PersistentArrayNode α → USize → USize → α | null | true |
AlgebraicGeometry.IsImmersion.instMapDescScheme | Mathlib.AlgebraicGeometry.Morphisms.Immersion | ∀ {X Y S T : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S) (i : S ⟶ T),
AlgebraicGeometry.IsImmersion (CategoryTheory.Limits.pullback.mapDesc f g i) | The map `X ×[S] Y ⟶ X ×[T] Y` induced by any `S ⟶ T` is always an immersion. | true |
inf_le_inf_right | Mathlib.Order.Defs.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α} (c : α), b ≤ a → b ⊓ c ≤ a ⊓ c | null | true |
ArchimedeanClass.mk_add_lt_mk_left_iff._simp_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {a b : M},
(ArchimedeanClass.mk (a + b) < ArchimedeanClass.mk a) = (ArchimedeanClass.mk b < ArchimedeanClass.mk a) | null | false |
Real.smul_map_diagonal_volume_pi | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {D : ι → ℝ},
(Matrix.diagonal D).det ≠ 0 →
ENNReal.ofReal |(Matrix.diagonal D).det| •
MeasureTheory.Measure.map (⇑(Matrix.toLin' (Matrix.diagonal D))) MeasureTheory.volume =
MeasureTheory.volume | A diagonal matrix rescales Lebesgue according to its determinant. This is a special case of
`Real.map_matrix_volume_pi_eq_smul_volume_pi`, that one should use instead (and whose proof
uses this particular case). | true |
_private.Init.Data.List.Lemmas.0.List.eq_replicate_of_mem.match_1_3 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (b : α) (l : List α) (motive : (a : α) → (b = a ∧ ∀ x ∈ l, x = a) → (∀ b_1 ∈ b :: l, b_1 = a) → Prop)
(a : α) (x : b = a ∧ ∀ x ∈ l, x = a) (H : ∀ b_1 ∈ b :: l, b_1 = a),
(∀ (H₂ : ∀ x ∈ l, x = b) (H : ∀ b_1 ∈ b :: l, b_1 = b), motive b ⋯ H) → motive a x H | null | false |
CategoryTheory.Limits.Fork.IsLimit.mk._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} {X Y : C} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : X ⟶ Y}
(t : CategoryTheory.Limits.Fork f g) (lift : (s : CategoryTheory.Limits.Fork f g) → s.pt ⟶ t.pt),
(∀ (s : CategoryTheory.Limits.Fork f g), CategoryTheory.CategoryStruct.comp (lift s) t.ι = s.ι) →
∀ (s : CategoryTheory.Limits.... | null | false |
antitone_vecEmpty._simp_1 | Mathlib.Order.Fin.Tuple | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Antitone ![a] = True | null | false |
List.mem_union_left | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} {l₁ : List α} {a : α} [inst : DecidableEq α], a ∈ l₁ → ∀ (l₂ : List α), a ∈ l₁ ∪ l₂ | null | true |
Subgroup.focalSubgroup_le | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.focalSubgroup ≤ H | Lemma: The focal subgroup is indeed a subgroup of H. | true |
_private.Init.Meta.Defs.0.Lean.Syntax.decodeScientificLitVal?.decodeAfterExp | Init.Meta.Defs | String → String.Pos.Raw → ℕ → ℕ → Bool → ℕ → Option (ℕ × Bool × ℕ) | null | true |
Localization.le_comap_primeCompl_iff | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {P : Type u_3} [inst_1 : CommSemiring P] {I : Ideal R} [hI : I.IsPrime]
{J : Ideal P} [inst_2 : J.IsPrime] {f : R →+* P}, I.primeCompl ≤ Submonoid.comap f J.primeCompl ↔ Ideal.comap f J ≤ I | null | true |
Complex.UnitDisc.instSMulCommClass_circle_right | Mathlib.Analysis.Complex.UnitDisc.Basic | SMulCommClass Complex.UnitDisc Circle Complex.UnitDisc | null | true |
Std.ExtTreeMap.keyAtIdxD | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → ℕ → α → α | Returns the `n`-th smallest key, or `fallback` if `n` is at least `t.size`. | true |
Std.Format.MonadPrettyFormat.pushOutput | Init.Data.Format.Basic | {m : Type → Type} → [self : Std.Format.MonadPrettyFormat m] → String → m Unit | Emits the string `s`.
| true |
Multiset.singleton_eq_cons_iff | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {a b : α} (m : Multiset α), {a} = b ::ₘ m ↔ a = b ∧ m = 0 | null | true |
List.tailsTR | Batteries.Data.List.Basic | {α : Type u_1} → List α → List (List α) | Tail-recursive version of `tails`. | true |
FGModuleCat.ulift | Mathlib.Algebra.Category.FGModuleCat.Basic | (R : Type u) → [inst : Ring R] → CategoryTheory.Functor (FGModuleCat R) (FGModuleCat R) | Universe lifting as a functor on `FGModuleCat`. | true |
Cardinal.cast_toNat_eq_iff_lt_aleph0 | Mathlib.SetTheory.Cardinal.ToNat | ∀ {c : Cardinal.{u_1}}, ↑(Cardinal.toNat c) = c ↔ c < Cardinal.aleph0 | null | true |
SignType.intCast_cast | Mathlib.Basic.Sign.Basic | ∀ {α : Type u_1} [inst : AddGroupWithOne α] (s : SignType), ↑↑s = ↑s | Casting `SignType → ℤ → α` is the same as casting directly `SignType → α`. | true |
CategoryTheory.LiftLeftAdjoint.constructLeftAdjointObj._proof_1 | Mathlib.CategoryTheory.Adjunction.Lifting.Left | ∀ {A : Type u_2} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
{U : CategoryTheory.Functor B C} {F : CategoryTheory.Functor C B} (R : CategoryTheory.Functor A B)
(F' : CategoryTheory.Funct... | null | false |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.addMonToLaxMonoidalObj_ε | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(A : CategoryTheory.AddMon C),
CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.addMonToLaxMonoidalObj A) =
CategoryTheory.AddMonObj.zero | null | true |
AddMonoidAlgebra.le_inf_support_coeff_add | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : SemilatticeInf T] [inst_1 : OrderTop T] [inst_2 : Semiring R]
(degt : A → T) (f g : AddMonoidAlgebra R A),
f.coeff.support.inf degt ⊓ g.coeff.support.inf degt ≤ (f + g).coeff.support.inf degt | null | true |
RatFunc.CompletionAtInfty.instField._proof_72 | Mathlib.FieldTheory.RatFunc.Valuation | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)],
autoParam (∀ (a : ℚ) (x : RatFunc.CompletionAtInfty F), RatFunc.CompletionAtInfty.instField._aux_70 F a x = ↑a * x)
DivisionRing.qsmul_def._autoParam | null | false |
RingCon.lift_surjective_of_surjective | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring P] {c : RingCon M} {f : M →+* P}
(h : c ≤ RingCon.ker f), Function.Surjective ⇑f → Function.Surjective ⇑(c.lift f h) | Surjective ring homomorphisms constant on the equivalence classes
of a ring congruence relation induce a surjective homomorphism on the quotient. | true |
_private.Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic.0.Function.locallyFinsuppWithin.logCounting_mono._simp_1_5 | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
_private.Init.Data.String.Basic.0.String.Pos.lt_of_lt_of_le._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {l r : s.Pos}, (l < r) = (l.offset < r.offset) | null | false |
List.IsChain.iff_of_mem_tail_imp | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {R S : α → α → Prop} {l : List α},
(∀ (a b : α), a ∈ l → b ∈ l.tail → (R a b ↔ S a b)) → (List.IsChain R l ↔ List.IsChain S l) | null | true |
Submodule.quotientEquivOfIsCompl._proof_2 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_2} [inst : Ring R] {E : Type u_1} [inst_1 : AddCommGroup E] [inst_2 : Module R E] (p q : Submodule R E)
(h : IsCompl p q), p ≤ (q.projectionOnto p ⋯).ker | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.mk | Mathlib.CategoryTheory.Monoidal.Action.Basic | {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.MonoidalCategory C] →
[toMonoidalRightActionStruct : CategoryTheory.MonoidalCategory.MonoidalRightActionStruct C D] →
aut... | null | true |
CategoryTheory.HopfObj.noConfusion | Mathlib.CategoryTheory.Monoidal.Hopf_ | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} →
{X : C} →
{t : CategoryTheory.HopfObj X} →
{C' : Type u₁} →
{inst' : CategoryT... | null | false |
_private.Mathlib.RingTheory.Coalgebra.CoassocSimps.0.CoassocSimps.assoc_comp_rid_symm_assoc._simp_1_1 | Mathlib.RingTheory.Coalgebra.CoassocSimps | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N],
TensorProduct.map LinearMap.id ↑(TensorProduct.rid R N).symm =
↑(TensorProduct.assoc R M N R) ∘ₗ ↑(TensorProduct.rid R (TensorProduct R M N)).... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.