name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.List.Lex.0.List.Lex.trichotomous.aux._f | Mathlib.Data.List.Lex | ∀ {α : Type u} (r : α → α → Prop) [Std.Trichotomous r] (x : List α)
(f : List.below (motive := fun x => ∀ (x_1 : List α), ¬List.Lex r x x_1 → ¬List.Lex r x_1 x → x = x_1) x)
(x_1 : List α), ¬List.Lex r x x_1 → ¬List.Lex r x_1 x → x = x_1 | null | false |
HurwitzZeta.completedHurwitzZetaOdd | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | UnitAddCircle → ℂ → ℂ | The entire function of `s` which agrees with
`1 / 2 * Gamma ((s + 1) / 2) * π ^ (-(s + 1) / 2) * ∑' (n : ℤ), sgn (n + a) / |n + a| ^ s`
for `1 < re s`.
| true |
Field.finSepDegree_eq | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsAlgebraic F E],
Field.finSepDegree F E = Cardinal.toNat (Field.sepDegree F E) | If `E / F` is algebraic, then the `Field.finSepDegree F E` is equal to `Field.sepDegree F E`
as a natural number. This means that the cardinality of `Field.Emb F E` and the degree of
`(separableClosure F E) / F` are both finite or infinite, and when they are finite, they
coincide. | true |
Std.DTreeMap.mem_union_of_right | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t₂ → k ∈ t₁ ∪ t₂ | null | true |
GradeMinOrder.mk.noConfusion | Mathlib.Order.Grade | {𝕆 : Type u_5} →
{α : Type u_6} →
{inst : Preorder 𝕆} →
{inst_1 : Preorder α} →
{P : Sort u} →
{toGradeOrder : GradeOrder 𝕆 α} →
{isMin_grade : ∀ ⦃a : α⦄, IsMin a → IsMin (GradeOrder.grade a)} →
{toGradeOrder' : GradeOrder 𝕆 α} →
{isMin_grade' ... | null | false |
Mathlib.Tactic.Erw?.logDiffs | Mathlib.Tactic.ErwQuestion | Lean.Syntax → Lean.Expr → Lean.Expr → StateT (Array (Unit → Lean.MessageData)) Lean.MetaM Bool | Check if two expressions are different at reducible transparency.
Attempt to log an info message for the first subexpressions which are different
(but agree at default transparency).
Also returns an array of messages for the `verbose` report.
| true |
PrincipalSeg.pemptyToPUnit | Mathlib.Order.InitialSeg | PrincipalSeg emptyRelation emptyRelation | Principal segment from the empty relation on `PEmpty` to the empty relation on `PUnit`. | true |
CategoryTheory.Abelian.LeftResolution.chainComplexMap._proof_2 | Mathlib.Algebra.Homology.LeftResolution.Basic | ∀ {A : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) {X Y : A} [inst_2 : ι.Full] [inst_3 : ι.Faithful]
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_5... | null | false |
CategoryTheory.Abelian.LeftResolution.karoubi_F | Mathlib.Algebra.Homology.LeftResolution.Reduced | ∀ {A : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C]
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive A] [inst_4 : ι.Additive],
Λ.ka... | null | true |
SSet.Truncated.Path.map._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {n : ℕ} {X Y : SSet.Truncated (n + 1)} {m : ℕ} (f : X.Path m) (σ : X ⟶ Y) (i : Fin m),
(CategoryTheory.ConcreteCategory.hom
(((SSet.Truncated.trunc (n + 1) 1 ⋯).obj Y).map
(SimplexCategory.Truncated.Hom.tr (SimplexCategory.δ 1) SSet.Truncated.Path₁._proof_1
SSet.Truncated.Path₁._proo... | null | false |
Std.Http.Body.instNonemptyStream | Std.Http.Data.Body.Stream | Nonempty Std.Http.Body.Stream | null | true |
ProbabilityTheory.IsMeasurableRatCDF.measure_stieltjesFunction_Iic | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : ProbabilityTheory.IsMeasurableRatCDF f) (a : α)
(x : ℝ), (hf.stieltjesFunction a).measure (Set.Iic x) = ENNReal.ofReal (↑(hf.stieltjesFunction a) x) | null | true |
UInt16.toBitVec_nsmul | Mathlib.Data.UInt | ∀ (n : ℕ) (a : UInt16), (n • a).toBitVec = n • a.toBitVec | null | true |
MeasureTheory.Filtration.rightCont_eq_self | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : LinearOrder ι] [SuccOrder ι]
(𝓕 : MeasureTheory.Filtration ι m), 𝓕.rightCont = 𝓕 | If the index type is a `SuccOrder`, then `𝓕₊ = 𝓕`. | true |
GradedTensorProduct.liftEquiv._proof_2 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_4} {ι : Type u_5} {A : Type u_1} {B : Type u_2} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
instLinearOrderedAddCommMonoidWithTopOrderDualAdditive._proof_2 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] ⦃x : (Additive α)ᵒᵈ⦄, x ≠ ⊤ → IsAddLeftRegular x | null | false |
AlgebraicGeometry.PresheafedSpace.GlueData.vPullbackConeIsLimit | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(D : AlgebraicGeometry.PresheafedSpace.GlueData C) →
[inst_1 : CategoryTheory.Limits.HasLimits C] → (i j : D.J) → CategoryTheory.Limits.IsLimit (D.vPullbackCone i j) | The following diagram is a pullback, i.e. `Vᵢⱼ` is the intersection of `Uᵢ` and `Uⱼ` in `X`.
```
Vᵢⱼ ⟶ Uᵢ
| |
↓ ↓
Uⱼ ⟶ X
```
| true |
CategoryTheory.StructuredArrow.commaMapEquivalenceFunctor._proof_3 | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | ∀ {C : Type u_10} [inst : CategoryTheory.Category.{u_9, u_10} C] {D : Type u_12}
[inst_1 : CategoryTheory.Category.{u_11, u_12} D] {T : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} T]
{L : CategoryTheory.Functor C T} {R : CategoryTheory.Functor D T} {C' : Type u_6}
[inst_3 : CategoryTheory.Category.{u_5... | null | false |
IsWellOrder.toHasWellFounded._proof_1 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} [inst : LT α] [hwo : IsWellOrder α fun x1 x2 => x1 < x2], WellFounded fun x1 x2 => x1 < x2 | null | false |
CategoryTheory.ShortComplex.Splitting.ofExactOfSection | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[CategoryTheory.Balanced C] →
(S : CategoryTheory.ShortComplex C) →
S.Exact →
(s : S.X₃ ⟶ S.X₂) →
CategoryTheory.CategoryStruct.comp s S.g = CategoryTheory.C... | This is the splitting of a short complex `S` in a balanced category induced by
a section of the morphism `S.g : S.X₂ ⟶ S.X₃` | true |
Set.unbounded_of_isEmpty | Mathlib.Order.RelClasses | ∀ {α : Type u} [IsEmpty α] {r : α → α → Prop} (s : Set α), Set.Unbounded r s | null | true |
Lean.Meta.Canonicalizer.ExprVisited.rec | Lean.Meta.Canonicalizer | {motive : Lean.Meta.Canonicalizer.ExprVisited → Sort u} →
((e : Lean.Expr) → motive { e := e }) → (t : Lean.Meta.Canonicalizer.ExprVisited) → motive t | null | false |
NonemptyInterval.instDecidableEq | Mathlib.Order.Interval.Basic | {α : Type u_1} → [inst : LE α] → [DecidableEq α] → DecidableEq (NonemptyInterval α) | null | true |
Std.TreeSet.isEmpty_diff_left | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp],
t₁.isEmpty = true → (t₁ \ t₂).isEmpty = true | null | true |
Mathlib.Tactic.LibraryRewrite.RewriteLemma.noConfusion | Mathlib.Tactic.Widget.LibraryRewrite | {P : Sort u} →
{t t' : Mathlib.Tactic.LibraryRewrite.RewriteLemma} →
t = t' → Mathlib.Tactic.LibraryRewrite.RewriteLemma.noConfusionType P t t' | null | false |
FiniteField.instFieldExtension._proof_40 | Mathlib.FieldTheory.Finite.Extension | ∀ (k : Type u_1) [inst : Field k] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP k p] (n : ℕ),
autoParam (∀ (n_1 : ℕ) (a : FiniteField.Extension k p n), ↑n_1.succ • a = ↑n_1 • a + a)
SubNegMonoid.zsmul_succ'._autoParam | null | false |
_private.Mathlib.CategoryTheory.Monoidal.DayConvolution.0.CategoryTheory.MonoidalCategory.DayConvolution.pentagon._simp_1_5 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {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),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
Manifold.IsSubmersionAtOfComplement.instNormedAddCommGroupSmallComplement._proof_42 | 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 |
TopPair.diag._proof_3 | Mathlib.Topology.Category.TopPair | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z),
TopPair.ofHom (CategoryTheory.CategoryStruct.comp f g) (CategoryTheory.CategoryStruct.comp f g) ⋯ =
CategoryTheory.CategoryStruct.comp (TopPair.ofHom f f ⋯) (TopPair.ofHom g g ⋯) | null | false |
List.pmap_eq_nil_iff._simp_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {f : (a : α) → p a → β} {l : List α} {H : ∀ a ∈ l, p a},
(List.pmap f l H = []) = (l = []) | null | false |
Std.DTreeMap.Internal.Impl.getKey?_insertMany!_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {l : List ((a : α) × β a)} {k k' : α},
compare k k' = Ordering.eq →
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l → (↑(t.insertMany... | null | true |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.isReduced_of_noZeroDivisors.match_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] (a : M₀) (motive : IsNilpotent a → Prop) (x : IsNilpotent a),
(∀ (n : ℕ) (ha : a ^ n = 0), motive ⋯) → motive x | null | false |
Ultrafilter.ofComplNotMemIff._proof_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_1} (f : Filter α), (∀ (s : Set α), sᶜ ∉ f ↔ s ∈ f) → f = ⊥ → False | null | false |
PresheafOfModulesOfCommRing.braiding_inv_app | Mathlib.Algebra.Category.ModuleCat.Presheaf.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ CommRingCat}
(M₁ M₂ : PresheafOfModulesOfCommRing R) (X : Cᵒᵖ),
PresheafOfModules.Hom.app' (β_ M₁ M₂).inv X = (β_ (M₁.obj X) (M₂.obj X)).inv | null | true |
Module.support_quotSMulTop | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M]
(x : R), Module.support R (QuotSMulTop x M) = Module.support R M ∩ PrimeSpectrum.zeroLocus {x} | null | true |
Cardinal.beth_mono | Mathlib.SetTheory.Cardinal.Aleph | Monotone Cardinal.beth | null | true |
NNReal.coe_natCast | Mathlib.Basic.NNReal.Defs | ∀ (n : ℕ), ↑↑n = ↑n | null | true |
CategoryTheory.OverPresheafAux.map_mkPrecomp_eqToHom._proof_2 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A : CategoryTheory.Functor Cᵒᵖ (Type u_2)} {X Y : C}
{f : X ⟶ Y} {g g' : CategoryTheory.yoneda.obj Y ⟶ A},
g = g' →
Opposite.op
(CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) g')) =
... | null | false |
CategoryTheory.sheafHom._proof_1 | Mathlib.CategoryTheory.Sites.SheafHom | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{A : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} A] (F G : CategoryTheory.Sheaf J A),
CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.sheafHom' F G) | null | false |
Filter.sdiff_limsup | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteBooleanAlgebra α] (f : Filter β) (u : β → α) [f.NeBot] (a : α),
a \ Filter.limsup u f = Filter.liminf (fun b => a \ u b) f | null | true |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.find_mem_find?_decide._proof_1_2 | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} {p : Fin n → Prop} [inst : DecidablePred p] (h : ∃ i, p i),
Fin.find p h ∈ Fin.findSome? (Option.guard fun b => decide (p b)) | null | false |
Valued.completable | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {K : Type u_1} [inst : Field K] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀],
CompletableTopField K | A valued field is completable. | true |
Nat.dvd_add | Init.Data.Nat.Dvd | ∀ {a b c : ℕ}, a ∣ b → a ∣ c → a ∣ b + c | null | true |
Std.DHashMap.getD_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{fallback : β k} {f : β k → β k}, (m.modify k f).getD k fallback = (Option.map f (m.get? k)).getD fallback | null | true |
Polynomial.smeval_monomial | Mathlib.Algebra.Polynomial.Smeval | ∀ {R : Type u_1} [inst : Semiring R] (r : R) {S : Type u_2} [inst_1 : AddCommMonoid S] [inst_2 : Pow S ℕ]
[inst_3 : MulActionWithZero R S] (x : S) (n : ℕ), ((Polynomial.monomial n) r).smeval x = r • x ^ n | null | true |
imageToKernel_comp_hom_inv_comp | Mathlib.Algebra.Homology.ImageToKernel | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {A B C : V}
(f : A ⟶ B) (g : B ⟶ C) [inst_2 : CategoryTheory.Limits.HasEqualizers V] [inst_3 : CategoryTheory.Limits.HasImages V]
{Z : V} {i : B ≅ Z}
(w :
CategoryTheory.CategoryStruct.comp (CategoryTh... | null | true |
IsLocalRing.instCommRingResidueField._proof_45 | Mathlib.RingTheory.LocalRing.ResidueField.Defs | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsLocalRing R],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
CategoryTheory.Adjunction.extLinearEquiv._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.MapAdjunction | ∀ {C : Type u_5} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_5} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] [inst_4 : CategoryTheory.HasExt C] [inst_5 : CategoryTheory.HasExt D]
{F : CategoryTheory.Functor C D} {G : Category... | null | false |
_private.Batteries.Data.Vector.Basic.0.Vector.scanrMFast.loop._proof_3 | Batteries.Data.Vector.Basic | ∀ {n : ℕ} (i n_usize : USize),
n_usize.toNat = n → i.toNat ≤ n → 0 < i.toNat → (i - 1).toNat = i.toNat - 1 → (i - 1).toNat ≤ n | null | false |
_private.Mathlib.AlgebraicTopology.ExtraDegeneracy.0.CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.homotopy._proof_27 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {n : ℕ} (j k : Fin (n + 1)), j.rev = k → ↑k = ↑j.rev | null | false |
_private.Lean.Language.Basic.0.Lean.Language.Snapshot.Diagnostics.mk._flat_ctor | Lean.Language.Basic | Lean.MessageLog → Option (IO.Ref (Option Dynamic)) → Lean.Language.Snapshot.Diagnostics | null | false |
Lean.Meta.Grind.Arith.Linear.UnsatProof.lt.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {c c_1 : Lean.Meta.Grind.Arith.Linear.IneqCnstr},
Lean.Meta.Grind.Arith.Linear.UnsatProof.lt c = Lean.Meta.Grind.Arith.Linear.UnsatProof.lt c_1 → c = c_1 | null | true |
ManyOneDegree | Mathlib.Computability.Reduce | Type | A many-one degree is an equivalence class of sets up to many-one equivalence. | true |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.insertManyIfNewUnit._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} (m : Std.DHashMap α fun x => Unit), 0 < m.inner.buckets.size | null | false |
Ioc_mem_nhdsGE_of_mem | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α] {a b c : α},
b ∈ Set.Ioo c a → Set.Ioc c a ∈ nhdsWithin b (Set.Ici b) | null | true |
_private.Mathlib.CategoryTheory.Functor.OfSequence.0.CategoryTheory.Functor.OfSequence.map_id._proof_1 | Mathlib.CategoryTheory.Functor.OfSequence | ∀ (i : ℕ), i ≤ i | null | false |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic.0.MeasureTheory.simpleFuncAux.match_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
_private.Mathlib.Algebra.Order.SuccPred.0.Order.Iio_two._simp_1_1 | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} {x : α} [inst : LinearOrder α] [inst_1 : AddMonoidWithOne α] [SuccAddOrder α] [IsBotZeroClass α]
[NeZero 1], (x ≤ 1) = (x = 0 ∨ x = 1) | null | false |
Aesop.Frontend.BuilderOption.ctorIdx | Aesop.Frontend.RuleExpr | Aesop.Frontend.BuilderOption → ℕ | null | false |
Lean.Elab.Term.PatternElabException.mk.injEq | Lean.Elab.Match | ∀ (ex : Lean.Exception) (patternIdx : ℕ) (pathToIndex : List ℕ) (ex_1 : Lean.Exception) (patternIdx_1 : ℕ)
(pathToIndex_1 : List ℕ),
({ ex := ex, patternIdx := patternIdx, pathToIndex := pathToIndex } =
{ ex := ex_1, patternIdx := patternIdx_1, pathToIndex := pathToIndex_1 }) =
(ex = ex_1 ∧ patternIdx = p... | null | true |
AugmentedSimplexCategory.instFaithfulSimplexCategoryInclusion | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | AugmentedSimplexCategory.inclusion.Faithful | null | true |
Lean.Meta.Try.Collector.Result.recOn | Lean.Meta.Tactic.Try.Collect | {motive : Lean.Meta.Try.Collector.Result → Sort u} →
(t : Lean.Meta.Try.Collector.Result) →
((allConsts unfoldCandidates eqnCandidates : Lean.Meta.Try.Collector.OrdSet Lean.Name) →
(funIndCandidates : Lean.Meta.FunInd.SeenCalls) →
(indCandidates : Array Lean.Meta.Try.Collector.InductionCandidate... | null | false |
BoxIntegral.Prepartition | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} → BoxIntegral.Box ι → Type u_1 | A prepartition of `I : BoxIntegral.Box ι` is a finite set of pairwise disjoint subboxes of
`I`. | true |
Lean.Syntax.Range.mk.sizeOf_spec | Lean.Syntax | ∀ (start stop : String.Pos.Raw), sizeOf { start := start, stop := stop } = 1 + sizeOf start + sizeOf stop | null | true |
Lean.Widget.UserWidgetDefinition.casesOn | Lean.Widget.UserWidget | {motive : Lean.Widget.UserWidgetDefinition → Sort u} →
(t : Lean.Widget.UserWidgetDefinition) →
((name javascript : String) → motive { name := name, javascript := javascript }) → motive t | null | false |
CategoryTheory.ConcreteCategory.instFunLike._proof_1 | Mathlib.CategoryTheory.ConcreteCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {FC : C → C → Type u_4} {CC : C → Type u_3}
[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),
(fun f => ⇑(CategoryTheory.ConcreteCategory.hom f)) f = (fun f => ⇑(CategoryTheo... | null | false |
Std.DTreeMap.Internal.Impl.getKey_alter | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
[inst_1 : Std.LawfulEqOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)}
{hc : k' ∈ (Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl},
(Std.DTreeMap.Internal.Impl.alter k f t ⋯).... | null | true |
Array.sum_singleton | Init.Data.Array.Lemmas | ∀ {α : Type u_1} [inst : Add α] [inst_1 : Zero α] [Std.LawfulRightIdentity (fun x1 x2 => x1 + x2) 0] {x : α},
#[x].sum = x | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjComp_inv_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u₄} {Y : Type u₅} {Z : Type u₆}
[inst_3 : CategoryTheory.C... | null | true |
FGModuleRepr.S | Mathlib.Algebra.Category.FGModuleCat.EssentiallySmall | {R : Type u} → [inst : Ring R] → (self : FGModuleRepr R) → Submodule R (Fin self.n → R) | The kernel of the surjective map from `Fin n → R` (i.e. `R^n`) to the module represented. | true |
PolynomialLaw.add_def_apply | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (f g : M →ₚₗ[R] N) (S : Type u) [inst_5 : CommSemiring S]
[inst_6 : Algebra R S] (m : TensorProduct R S M), (f + g).toFun' S m = f.toFun' S m + g.toF... | null | true |
Set.powersetCard.mulActionHom_singleton.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : Group G] (α : Type u_2) [inst_1 : MulAction G α] [inst_2 : DecidableEq α],
Set.powersetCard.mulActionHom_singleton G α = { toFun := ⇑Set.powersetCard.ofSingleton, map_smul' := ⋯ } | null | true |
Subalgebra.normedCommRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {𝕜 : Type u_2} [inst : CommRing 𝕜] {E : Type u_1} [inst_1 : NormedCommRing E] [inst_2 : Algebra 𝕜 E]
(s : Subalgebra 𝕜 E) (x y : ↥s), dist x y = ‖-x + y‖ | null | false |
FreeAlgebra.Rel.zero_mul | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] {a : FreeAlgebra.Pre R X}, FreeAlgebra.Rel R X (0 * a) 0 | null | true |
Finset.union_sdiff_self_eq_union | Mathlib.Data.Finset.SDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s ∪ t \ s = s ∪ t | null | true |
RBTree.RBNode.balance1_toList | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {l : RBTree.RBNode α} {v : α} {r : RBTree.RBNode α},
(l.balance1 v r).toList = l.toList ++ v :: r.toList | null | true |
Mathlib.Tactic.ClickSuggestions.RwKey.replacement | Mathlib.Tactic.ClickSuggestions.Rewrite | Mathlib.Tactic.ClickSuggestions.RwKey → Lean.Meta.AbstractMVarsResult | The new subexpression. | true |
Order.Iic_subset_Iio_succ_of_not_isMax | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α}, ¬IsMax a → Set.Iic a ⊆ Set.Iio (Order.succ a) | null | true |
AbstractCompletion.mapEquiv._proof_6 | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type u_4} [inst : UniformSpace α] (pkg : AbstractCompletion.{u_2, u_4} α) {β : Type u_3}
[inst_1 : UniformSpace β] (pkg' : AbstractCompletion.{u_1, u_3} β) (e : α ≃ᵤ β),
UniformContinuous (pkg'.map pkg ⇑e.symm) | null | false |
LieAlgebra.IsKilling.coroot_neg | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_3} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra]
[inst_5 : LieAlgebra.IsKilling K L] [inst_6 : LieModule.IsTriangularizable K (↥H) L] (α : LieModule.Weight K (↥H) L),
LieAlgebra.... | null | true |
Std.DTreeMap.Internal.Impl.get!_empty | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} [Std.TransOrd α] [inst : Std.LawfulEqOrd α] {a : α}
[inst_1 : Inhabited (β a)], Std.DTreeMap.Internal.Impl.empty.get! a = default | null | true |
Ring.KrullDimLE | Mathlib.RingTheory.KrullDimension.Basic | ℕ → (R : Type u_1) → [CommSemiring R] → Prop | Type class for rings with krull dimension at most `n`. | true |
_private.Mathlib.Analysis.SpecialFunctions.FrullaniIntegral.0.Frullani.tendsto_integral_inv_smul_atTop._simp_1_4 | Mathlib.Analysis.SpecialFunctions.FrullaniIntegral | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
IsRelPrime.mul_add_right_left | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → ∀ (z : R), IsRelPrime (z * y + x) y | null | true |
CategoryTheory.Factorisation.instCategory._proof_2 | Mathlib.CategoryTheory.Category.Factorisation | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
(d : CategoryTheory.Factorisation f),
CategoryTheory.CategoryStruct.comp d.ι (CategoryTheory.CategoryStruct.id d.mid) = d.ι | null | false |
FirstOrder.Language.Substructure.mem_sInf | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {S : Set (L.Substructure M)} {x : M},
x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p | null | true |
Ideal.toCharacterSpace._proof_6 | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {A : Type u_1} [inst : NormedCommRing A] (I : Ideal A), I.IsTwoSided | null | false |
SeminormedRing.induced._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_3} (R : Type u_1) (S : Type u_2) [inst : FunLike F R S] [inst_1 : SeminormedRing S] (f : F),
Filter.comap (⇑f) (Bornology.cobounded S) ≤ Filter.cofinite | null | false |
Std.ExtTreeMap.getElem!_inter_of_mem_right | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
[inst_1 : Inhabited β], k ∈ t₂ → (t₁ ∩ t₂)[k]! = t₁[k]! | null | true |
Ordinal.type_pEmpty | Mathlib.SetTheory.Ordinal.Basic | Ordinal.type emptyRelation = 0 | null | true |
MeasureTheory.NullMeasurableSet.addFundamentalInterior | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] (s : Set α) [Countable G]
[inst_3 : MeasurableSpace α] [MeasurableConstVAdd G α] {μ : MeasureTheory.Measure α}
[MeasureTheory.VAddInvariantMeasure G α μ],
MeasureTheory.NullMeasurableSet s μ → MeasureTheory.NullMeasurableSet (MeasureTheo... | null | true |
Lean.Doc.Inline.match_on_same_ctor._@.Lean.DocString.Types.3732691326._hygCtx._hyg.126 | Lean.DocString.Types | {i : Type u} →
{motive : (t t_1 : Lean.Doc.Inline i) → t.ctorIdx = t_1.ctorIdx → Sort u_1} →
(t t_1 : Lean.Doc.Inline i) →
(h : t.ctorIdx = t_1.ctorIdx) →
((string string' : String) → motive (Lean.Doc.Inline.text string) (Lean.Doc.Inline.text string') ⋯) →
((content content' : Array (Lean.... | null | false |
_private.Mathlib.Combinatorics.Graph.Delete.0.Graph.induce_vertexSet.match_1_1 | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_2} {β : Type u_1} (G : Graph α β) (e : β) (motive : e ∈ (G.induce G.vertexSet).edgeSet → Prop)
(x : e ∈ (G.induce G.vertexSet).edgeSet),
(∀ (w w_1 : α) (h : G.IsLink e w w_1 ∧ w ∈ G.vertexSet ∧ w_1 ∈ G.vertexSet), motive ⋯) → motive x | null | false |
Plausible.Random.random | Plausible.Random | {m : Type u → Type u_1} →
{α : Type u} → [self : Plausible.Random m α] → {g : Type} → [RandomGen g] → Plausible.RandGT g m α | Generate a value of type `α` randomly using generator `g`.
| true |
_private.Init.Data.AC.0.Lean.Data.AC.evalList.match_1.splitter | Init.Data.AC | (motive : List ℕ → Sort u_1) →
(x : List ℕ) →
(Unit → motive []) →
((x : ℕ) → motive [x]) → ((x : ℕ) → (xs : List ℕ) → (xs = [] → False) → motive (x :: xs)) → motive x | null | true |
Submodule.isAssociatedPrime_iff | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M} {I : Ideal R} [IsNoetherianRing R], N.IsAssociatedPrime I ↔ I.IsPrime ∧ ∃ x, I = N.colon {x} | null | true |
CategoryTheory.Span.SpanBicat.id_r | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} 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 | true |
List.sortedLT_range | Mathlib.Data.List.Sort | ∀ (n : ℕ), (List.range n).SortedLT | null | true |
iff_eq_eq | Mathlib.Basic.Logic.Basic | ∀ {a b : Prop}, (a ↔ b) = (a = b) | null | true |
CategoryTheory.ObjectProperty.instIsTriangulatedFullSubcategory | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.