name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_rev_Ico._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
Filter.GenerateSets.brecOn | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {g : Set (Set α)} {motive : (a : Set α) → Filter.GenerateSets g a → Prop} {a : Set α}
(t : Filter.GenerateSets g a),
(∀ (a : Set α) (t : Filter.GenerateSets g a), Filter.GenerateSets.below t → motive a t) → motive a t | null | true |
_private.Mathlib.Dynamics.PeriodicPts.Lemmas.0.Function.Injective.mem_periodicPts._proof_1_1 | Mathlib.Dynamics.PeriodicPts.Lemmas | ∀ (m n : ℕ), m < n → 0 < n - m | null | false |
Int16.toInt64_le._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a.toInt64 ≤ b.toInt64) = (a ≤ b) | null | false |
LinearMap.finrank_genEigenspace_le | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {K : Type u_2} {M : Type u_3} [inst : Field K] [inst_1 : AddCommGroup M] [inst_2 : Module K M]
[inst_3 : Module.Finite K M] (φ : Module.End K M) (μ : K) (k : ℕ),
Module.finrank K ↥((φ.genEigenspace μ) ↑k) ≤ Polynomial.rootMultiplicity μ (LinearMap.charpoly φ) | null | true |
Graph.le_noEdge_iff | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β} {X : Set α}, G ≤ Graph.noEdge X β ↔ G.vertexSet ⊆ X ∧ G.edgeSet = ∅ | null | true |
Subgroup.subset_normalClosure | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {s : Set G}, s ⊆ ↑(Subgroup.normalClosure s) | null | true |
CategoryTheory.isIso_iff_of_thin | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [Quiver.IsThin C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.IsIso f ↔ Nonempty (Y ⟶ X) | null | true |
Monotone.iSup | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : Preorder α] [inst_1 : CompleteLattice β] {f : ι → α → β},
(∀ (i : ι), Monotone (f i)) → Monotone (⨆ i, f i) | null | true |
CategoryTheory.Adjunction.counitSplitMonoOfRFull | Mathlib.CategoryTheory.Adjunction.FullyFaithful | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{L : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor D C} →
(h : L ⊣ R) → [R.Full] → (X : D) → CategoryTheory.SplitMono (h.counit.app X) | If the right adjoint is full, then each component of the counit is a split monomorphism. | true |
IsUnital.toCStarAlgebra._proof_3 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] (a b : A), a + b = b + a | null | false |
SchwartzMap.instLaplacian._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ F]
[inst_3 : InnerProductSpace ℝ E], LineDerivSMul ℝ E (SchwartzMap E F) (SchwartzMap E F) | null | false |
Ordinal.typein_le_typein._simp_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u} (r : α → α → Prop) [inst : IsWellOrder α r] {a b : α},
((Ordinal.typein r).toRelEmbedding a ≤ (Ordinal.typein r).toRelEmbedding b) = ¬r b a | null | false |
Std.DTreeMap.Internal.Impl.Const.maxEntry.match_1.congr_eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → Sort u_3)
(x : Std.DTreeMap.Internal.Impl α fun x => β) (x_1 : x.isEmpty = false)
(h_1 :
(size : ℕ) →
(k : α) →
(v : β) →
(l : Std.DTreeMap.Internal.Impl α fun x => β) →
... | null | true |
Lean.Meta.LibrarySearch.DeclMod.casesOn | Lean.Meta.Tactic.LibrarySearch | {motive : Lean.Meta.LibrarySearch.DeclMod → Sort u} →
(t : Lean.Meta.LibrarySearch.DeclMod) →
motive Lean.Meta.LibrarySearch.DeclMod.none →
motive Lean.Meta.LibrarySearch.DeclMod.mp → motive Lean.Meta.LibrarySearch.DeclMod.mpr → motive t | null | false |
Batteries.BinomialHeap.Imp.Heap.WF.deleteMin | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} {le : α → α → Bool} {n : ℕ} {a : α} {s' s : Batteries.BinomialHeap.Imp.Heap α},
Batteries.BinomialHeap.Imp.Heap.WF le n s →
Batteries.BinomialHeap.Imp.Heap.deleteMin le s = some (a, s') → Batteries.BinomialHeap.Imp.Heap.WF le 0 s' | null | true |
gradient.congr_simp | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] (f f_1 : F → 𝕜), f = f_1 → ∀ (x x_1 : F), x = x_1 → gradient f x = gradient f_1 x_1 | null | true |
LinearMap.smulRightₗ._proof_4 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_3} {M : Type u_1} {M₂ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M] [inst_4 : Module R M₂] (c : R) (f : M₂ →ₗ[R] R),
{ toFun := (c • f).smulRight, map_add' := ⋯, map_smul' := ⋯ } =
(RingHom.id R) c • { toFun := f.smulRight, map_add... | null | false |
CategoryTheory.ExactPairing.ofFullyFaithful._proof_2 | Mathlib.CategoryTheory.Monoidal.Rigid.OfEquivalence | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory D] (F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] [inst_5 : F.Full]
(X Y : C) [inst_6 : Categ... | null | false |
Lean.Lsp.CodeActionOptions | Lean.Data.Lsp.CodeActions | Type | Capabilities of the server for handling code actions. | true |
AffineSubspace.direction_inf | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (s₁ s₂ : AffineSubspace k P), (s₁ ⊓ s₂).direction ≤ s₁.direction ⊓ s₂.direction | The direction of the inf of two affine subspaces is less than or equal to the inf of their
directions. | true |
MeasureTheory.measurableCylinders.finset._proof_1 | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)] {t : Set ((i : ι) → α i)},
t ∈ MeasureTheory.measurableCylinders α → ∃ s S, MeasurableSet S ∧ t = MeasureTheory.cylinder s S | null | false |
ULift.instOrderTop.eq_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α], ULift.instOrderTop = OrderTop.lift ULift.down ⋯ ⋯ | null | true |
instDecidableEqLists'.decEq._f | Mathlib.SetTheory.Lists | {α : Type u_2} →
[DecidableEq α] →
{a : Bool} →
(x : Lists' α a) →
Lists'.below (motive := fun {a} x => (x_1 : Lists' α a) → Decidable (x = x_1)) x →
(x_1 : Lists' α a) → Decidable (x = x_1) | null | false |
Aesop.TraceOption.traceClass | Aesop.Tracing | Aesop.TraceOption → Lean.Name | null | true |
CategoryTheory.ConcreteCategory.ext_iff | Mathlib.CategoryTheory.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {X Y : C}
{f g : X ⟶ Y}, f = g ↔ CategoryTheory.ConcreteCategory.hom f = CategoryTheory.ConcreteCategory.hom g | null | true |
CategoryTheory.CommSq.LiftStruct.opEquiv._proof_3 | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y}
{g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g),
Function.LeftInverse CategoryTheory.CommSq.LiftStruct.unop CategoryTheory.CommSq.LiftStruct.op | null | false |
OrderIso.finTwoArrowIso | Mathlib.Order.Fin.Tuple | (α : Type u_2) → [inst : Preorder α] → (Fin 2 → α) ≃o α × α | The space of functions `Fin 2 → α` is order equivalent to `α × α`. See also
`OrderIso.piFinTwoIso`. | true |
List.drop | Init.Data.List.Basic | {α : Type u} → ℕ → List α → List α | Removes the first `n` elements of the list `xs`. Returns the empty list if `n` is greater than the
length of the list.
`O(min n |xs|)`.
Examples:
* `[0, 1, 2, 3, 4].drop 0 = [0, 1, 2, 3, 4]`
* `[0, 1, 2, 3, 4].drop 3 = [3, 4]`
* `[0, 1, 2, 3, 4].drop 6 = []`
| true |
Int.instCommutativeHMul | Init.Data.Int.Lemmas | Std.Commutative fun x1 x2 => x1 * x2 | null | true |
MeasureTheory.Measure.snd_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.IsProbabilityMeasure μ], (μ.prod ν).snd = ν | null | true |
Array.getElem_scanl_zero._proof_1 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {init : β} {as : Array α} {f : β → α → β}, 0 < (Array.scanl f init as).size | null | false |
Manifold.IsImmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_45 | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {E'' : Type u_1} {F : Type u_4}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'']
[inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_7 : Topo... | null | false |
instCommRingPadicInt._proof_26 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (a b c : ℤ_[p]), a * (b + c) = a * b + a * c | null | false |
List.compareLex._sunfold | Init.Data.Ord.Basic | {α : Type u_1} → (α → α → Ordering) → List α → List α → Ordering | null | false |
_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_notMem_and_isIntegral_forall_mem_of_ne_of_liesOver._simp_1_2 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Array.fromJson?._sparseCasesOn_1 | Lean.Data.Json.FromToJson.Basic | {motive_1 : Lean.Json → Sort u} →
(t : Lean.Json) →
((elems : Array Lean.Json) → motive_1 (Lean.Json.arr elems)) →
(Nat.hasNotBit 16 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
CategoryTheory.Functor.LocallyCoverDense.rec | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | {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} →
{K : CategoryTheory.GrothendieckTopology D} →
{motive : G.LocallyCoverDense K → Sort u} →
((funct... | null | false |
Std.DHashMap.Raw.size_insertIfNew_le | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, (m.insertIfNew k v).size ≤ m.size + 1 | null | true |
Matroid.closure_union_closure_right_eq | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} (M : Matroid α) (X Y : Set α), M.closure (X ∪ M.closure Y) = M.closure (X ∪ Y) | null | true |
AlgebraicGeometry.essImage_bialgSpec | Mathlib.AlgebraicGeometry.Group.Affine | ∀ {R : CommRingCat} {G : CategoryTheory.Mon (CategoryTheory.Over (AlgebraicGeometry.Spec R))},
(AlgebraicGeometry.bialgSpec R).essImage G ↔ AlgebraicGeometry.IsAffine G.X.left | The essential image of `R`-bialgebras under `Spec` is precisely affine monoid schemes over
`Spec R`. | true |
_private.Lean.Level.0.Lean.Level.substParams.go.match_3 | Lean.Level | (motive : Lean.Level → Sort u_1) →
(u : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((v : Lean.Level) → motive v.succ) →
((v₁ v₂ : Lean.Level) → motive (v₁.max v₂)) →
((v₁ v₂ : Lean.Level) → motive (v₁.imax v₂)) →
((n : Lean.Name) → motive (Lean.Level.param n)) → ((u : Lean... | null | false |
Finsupp.zipWith_neLocus_eq_right | Mathlib.Data.Finsupp.NeLocus | ∀ {α : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : DecidableEq α] [inst_1 : DecidableEq M]
[inst_2 : Zero M] [inst_3 : DecidableEq P] [inst_4 : Zero P] [inst_5 : Zero N] {F : M → N → P} (F0 : F 0 0 = 0)
(f₁ f₂ : α →₀ M) (g : α →₀ N),
(∀ (g : N), Function.Injective fun f => F f g) →
(Finsupp... | null | true |
_private.Mathlib.Algebra.QuadraticAlgebra.Basic.0.QuadraticAlgebra.lift._simp_6 | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R),
r • 1 = (algebraMap R A) r | null | false |
LieAlgebra.IsKilling.coroot._proof_1 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_1} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L],
AddSubmonoidClass (LieSubalgebra K L) L | null | false |
TopCat.hasForgetToMeasCat._proof_2 | Mathlib.MeasureTheory.Category.MeasCat | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z),
⟨⇑(CategoryTheory.CategoryStruct.comp f g).hom', ⋯⟩ = CategoryTheory.CategoryStruct.comp ⟨⇑f.hom', ⋯⟩ ⟨⇑g.hom', ⋯⟩ | null | false |
Turing.TM2to1.Λ'.normal.noConfusion | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{P : Sort u} → {a a' : Λ} → Turing.TM2to1.Λ'.normal a = Turing.TM2to1.Λ'.normal a' → (a ≍ a' → P) → P | null | false |
cfcL._proof_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : MetricSpace R] [IsTopologicalSemiring R], ContinuousConstSMul R R | null | false |
AlgebraicGeometry.Scheme.Cover.instCategoryI₀Pullback₁._proof_8 | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
[inst : P.IsStableUnderBaseChange] (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst_1 : CategoryTheory.Category.{u_3, u_1} 𝒰.I₀] {Y : AlgebraicGeometry.Scheme} (f : Y ⟶ X),
autoPa... | null | false |
Function.ExtendByOne.hom._proof_2 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {ι : Type u_3} {η : Type u_1} (R : Type u_2) (s : ι → η) [inst : MulOneClass R], Function.extend s 1 1 = 1 | null | false |
OpenPartialHomeomorph.Simps.symm_apply | Mathlib.Topology.OpenPartialHomeomorph.Defs | {X : Type u_1} →
{Y : Type u_3} → [inst : TopologicalSpace X] → [inst_1 : TopologicalSpace Y] → OpenPartialHomeomorph X Y → Y → X | See Note [custom simps projection] | true |
_private.Mathlib.Analysis.Calculus.UniformLimitsDeriv.0.uniformCauchySeqOn_ball_of_fderiv._simp_1_4 | Mathlib.Analysis.Calculus.UniformLimitsDeriv | ∀ (α : Sort u), (∀ (a : α), True) = True | null | false |
_private.Std.Time.Date.Basic.0.Std.Time.Second.Offset.ofWeeks._proof_1 | Std.Time.Date.Basic | 86400 * 7 / ↑604800 = 1 | null | false |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.monic_X_add_C._simp_1_1 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b < a) = ¬a ≤ b | null | false |
FiniteGaloisIntermediateField.instIsSeparableSubtypeMemIntermediateFieldMin | Mathlib.FieldTheory.Galois.GaloisClosure | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(L₁ L₂ : IntermediateField k K) [Algebra.IsSeparable k ↥L₁], Algebra.IsSeparable k ↥(L₁ ⊓ L₂) | null | true |
AlgebraicGeometry.germ_injective_of_isIntegral | Mathlib.AlgebraicGeometry.FunctionField | ∀ (X : AlgebraicGeometry.Scheme) [AlgebraicGeometry.IsIntegral X] {U : X.Opens} (x : ↥X) (hx : x ∈ U),
Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom (X.presheaf.germ U x hx)) | null | true |
Set.prod_eq_biUnion_left | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, s ×ˢ t = ⋃ a ∈ s, (fun b => (a, b)) '' t | null | true |
LowerSet.instPartialOrder._proof_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], Function.Injective SetLike.coe | null | false |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.succ_ascFactorial.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x | null | false |
SimpleGraph.deleteEdges_sup | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} (G H : SimpleGraph V) (s : Set (Sym2 V)), (G ⊔ H).deleteEdges s = G.deleteEdges s ⊔ H.deleteEdges s | null | true |
LinearMap.BilinForm.isCompl_span_singleton_orthogonal | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {V : Type u_5} {K : Type u_6} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{B : LinearMap.BilinForm K V} {x : V}, (B x) x ≠ 0 → IsCompl (K ∙ x) (B.orthogonal (K ∙ x)) | Given a bilinear form `B` and some `x` such that `B x x ≠ 0`, the span of the singleton of `x`
is complement to its orthogonal complement. | true |
Nat.Internal.Linear.Expr.toNormPoly.eq_1 | Init.Data.Nat.Internal.Linear | ∀ (e : Nat.Internal.Linear.Expr), e.toNormPoly = e.toPoly.norm | null | true |
MonCat.FilteredColimits.colimitCocone.eq_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J],
MonCat.FilteredColimits.colimitCocone F =
{ pt := MonCat.FilteredColimits.colimit F,
ι := { app := MonCat.FilteredColimits.coconeMorphism F, naturality := ⋯ } } | null | true |
_private.Init.Data.Nat.Lemmas.0.Nat.anyLTTR_loop_eq_true | Init.Data.Nat.Lemmas | ∀ {n : ℕ} {f : (i : ℕ) → i < n → Bool} (j : ℕ) (hj : j ≤ n),
Nat.anyLTTR.loop✝ n f j hj = true ↔ ∃ i, ∃ (h : i < n), n - j ≤ i ∧ f i h = true | null | true |
Std.Do.PredTrans.pure | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → α → Std.Do.PredTrans ps α | The identity predicate transformer that transforms the postcondition's assertion about the return
value into an assertion about `a`.
| true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs.0.EisensteinSeries.D2_mul._simp_1_3 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [LeftDistribClass R] (a b c : R), a * b + a * c = a * (b + c) | null | false |
CategoryTheory.CountableCategory.instCountableHomAsType | Mathlib.CategoryTheory.Countable | ∀ (α : Type u) [inst : CategoryTheory.Category.{v, u} α] [inst_1 : CategoryTheory.CountableCategory α],
Countable (CategoryTheory.CountableCategory.HomAsType α) | null | true |
Std.Async.System.CPUTimes.recOn | Std.Async.System | {motive : Std.Async.System.CPUTimes → Sort u} →
(t : Std.Async.System.CPUTimes) →
((userTime niceTime systemTime idleTime interruptTime : Std.Time.Millisecond.Offset) →
motive
{ userTime := userTime, niceTime := niceTime, systemTime := systemTime, idleTime := idleTime,
interruptTime ... | null | false |
Mathlib.Tactic.TFAE.Parser.tfaeHaveDecl.formatter | Mathlib.Tactic.TFAE | Lean.PrettyPrinter.Formatter | null | true |
ContMDiffWithinAt.comp_of_eq | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : 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] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSp... | See note [comp_of_eq lemmas] | true |
Order.aleph0_le_cof_iff._simp_1 | Mathlib.SetTheory.Cardinal.Cofinality.Basic | ∀ {α : Type u} [inst : LinearOrder α], (Cardinal.aleph0 ≤ Order.cof α) = (1 < Order.cof α) | null | false |
WittVector.IsPoly.comp | Mathlib.RingTheory.WittVector.IsPoly | ∀ {p : ℕ} {g f : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R} [hg : WittVector.IsPoly p g]
[hf : WittVector.IsPoly p f], WittVector.IsPoly p fun R _Rcr => g ∘ f | The composition of polynomial functions is polynomial. | true |
_private.Mathlib.GroupTheory.GroupAction.ConjAct.0.ConjAct.fixedPoints_eq_center._simp_1_1 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ {G : Type u_1} [inst : Group G] {z : G}, (z ∈ Subgroup.center G) = ∀ (g : G), g * z = z * g | null | false |
ENNReal.lintegral_Lp_add_le_of_le_one | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {p : ℝ} {f g : α → ENNReal},
AEMeasurable f μ →
0 ≤ p →
p ≤ 1 →
(∫⁻ (a : α), (f + g) a ^ p ∂μ) ^ (1 / p) ≤
2 ^ (1 / p - 1) * ((∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) + (∫⁻ (a : α), g a ^ p ∂μ) ^ (1 / p)) | Variant of Minkowski's inequality for functions `α → ℝ≥0∞` in `ℒp` with `p ≤ 1`: the `ℒp`
seminorm of the sum of two functions is bounded by a constant multiple of the sum
of their `ℒp` seminorms. | true |
IsStarProjection.le_of_mul_eq_left | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalRing R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R] {p q : R},
IsStarProjection p → IsStarProjection q → p * q = p → p ≤ q | A star projection `p` is less than or equal to a star projection `q` when `p * q = p`. | true |
contMDiffAt_subtype_iff | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : 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] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSp... | null | true |
LeanSearchClient.SearchServer.searchTermSuggestions | LeanSearchClient.Syntax | LeanSearchClient.SearchServer → Lean.Syntax → Lean.TSyntax `str → Lean.Elab.TermElabM Unit | null | true |
Std.DTreeMap.Internal.Impl.Balanced.below.leaf | Std.Data.DTreeMap.Internal.Balanced | ∀ {α : Type u} {β : α → Type v} {motive : (a : Std.DTreeMap.Internal.Impl α β) → a.Balanced → Prop},
Std.DTreeMap.Internal.Impl.Balanced.below ⋯ | null | true |
BitVec.extractLsb_not_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {hi lo : ℕ}, lo ≤ hi → hi < w → BitVec.extractLsb hi lo (~~~x) = ~~~BitVec.extractLsb hi lo x | Negating `x` and then extracting [lo:hi] is the same as extracting and then negating.
For the extraction to be well-behaved,
we need the range [lo:hi] to be a valid closed interval inside the bitvector:
1. `lo ≤ hi` for the interval to be a well-formed closed interval.
2. `hi < w`, for the interval to be contained insi... | true |
AbstractMeasure.congr_simp | Mathlib.NumberTheory.Padics.Measure.Basic | ∀ (X : Type u_1) (R : Type u_3) (E : Type u_4) [inst : TopologicalSpace X] [inst_1 : AddCommGroup E]
[inst_2 : TopologicalSpace E] [inst_3 : CommRing R] [inst_4 : TopologicalSpace R] [inst_5 : IsTopologicalRing R]
[inst_6 : Module R E], AbstractMeasure X R E = AbstractMeasure X R E | null | true |
Lean.Elab.Tactic.Ext.applyExtTheoremAt | Lean.Elab.Tactic.Ext | Lean.MVarId → Lean.MetaM (List Lean.MVarId) | Apply a single extensionality theorem to `goal`. | true |
FinTrdeg | Mathlib.FieldTheory.FinTrdeg | (K : Type u_1) → (L : Type u_2) → [inst : Field K] → [inst_1 : Field L] → [Algebra K L] → Prop | A field extension L/K is said to have finite transcendence degree if there is some
intermediate extension L/E/K with E/K finitely generated and L/E algebraic. | true |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_26 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax | null | false |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.Clause.erase.go._unary._proof_5 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} (c : Std.Sat.CNF.Clause α), ∀ i < c.size, i < c.atoms.size | null | false |
ProbabilityTheory.gammaMeasure.eq_1 | Mathlib.Probability.Distributions.Gamma | ∀ (a r : ℝ), ProbabilityTheory.gammaMeasure a r = MeasureTheory.volume.withDensity (ProbabilityTheory.gammaPDF a r) | null | true |
_private.Mathlib.FieldTheory.KrullTopology.0.krullTopology_mem_nhds_one_iff_of_normal.match_1_3 | Mathlib.FieldTheory.KrullTopology | ∀ (K : Type u_2) (L : Type u_1) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (s : Set Gal(L/K))
(motive : (∃ E, FiniteDimensional K ↥E ∧ Normal K ↥E ∧ ↑E.fixingSubgroup ⊆ s) → Prop)
(x : ∃ E, FiniteDimensional K ↥E ∧ Normal K ↥E ∧ ↑E.fixingSubgroup ⊆ s),
(∀ (E : IntermediateField K L) (hE : FiniteDi... | null | false |
StarAlgEquiv.toStarAlgHom._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A₁ : Type u_2} {A₂ : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] [inst_5 : Star A₁] [inst_6 : Star A₂] (e : A₁ ≃⋆ₐ[R] A₂),
(↑↑(↑e.toAlgEquiv).toRingHom).toFun 1 = 1 | null | false |
MeasureTheory.ProgMeasurable.finset_sum | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] [inst_2 : MeasurableSpace ι] {γ : Type u_4} [inst_3 : AddCommMonoid β]
[ContinuousAdd β] {U : γ → ι → Ω → β} {s : Finset γ},
(∀ c ∈ s, MeasureTheory.IsStrongl... | **Alias** of `MeasureTheory.IsStronglyProgressive.finsetSum`. | true |
Submodule.prodEquivOfIsTopCompl._proof_1 | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
Diffeology.DSmooth.continuous' | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : DiffeologicalSpace X]
[Diffeology.IsDTopologyCompatible X] [inst_3 : TopologicalSpace Y] [inst_4 : DiffeologicalSpace Y]
[Diffeology.IsDTopologyCompatible Y] {f : X → Y}, Diffeology.DSmooth f → Continuous f | A smooth function between spaces that are equipped with the D-topology is continuous. | true |
RingEquiv.toNatAlgEquiv_apply | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R ≃+* S) (a : R), f.toNatAlgEquiv a = f a | null | true |
CategoryTheory.Limits.ImageMap.map_uniq_aux | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C}
[inst_1 : CategoryTheory.Limits.HasImage f.hom] [inst_2 : CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g}
(map : CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom),
autoParam
(CategoryTheory.Catego... | null | true |
SSet.spine.eq_1 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ (X : SSet) (n : ℕ), X.spine n = ((SSet.truncation (n + 1)).obj X).spine n ⋯ | null | true |
Aesop.ForwardRule.instToString | Aesop.Rule.Forward | ToString Aesop.ForwardRule | null | true |
AddGrpCat.addGroupObj._aux_3 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J AddGrpCat) → (j : J) → Add ((F.comp (CategoryTheory.forget AddGrpCat)).obj j) | null | false |
lt_abs | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] {a b : α}, a < |b| ↔ a < b ∨ a < -b | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.eq_of_one_to_one.match_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (motive : Fin ({ len := 1 }.len + 1) → Prop) (i : Fin ({ len := 1 }.len + 1)),
(∀ (_ : Unit), motive 0) → (∀ (_ : Unit), motive 1) → motive i | null | false |
Finset.Colex.isInitSeg_empty | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : LinearOrder α] {r : ℕ}, Finset.Colex.IsInitSeg ∅ r | null | true |
CategoryTheory.PreZeroHypercover.restrictIndex_I₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {T : C} (E : CategoryTheory.PreZeroHypercover T) {ι : Type w'}
(f : ι → E.I₀), (E.restrictIndex f).I₀ = ι | null | true |
Lean.Meta.Grind.EMatchDiagNode.origin | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatchDiagNode → Lean.Meta.Grind.Origin | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.