name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Bicategory.conjugateEquiv_whiskerRight | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {l₁ : a ⟶ b} {r₁ : b ⟶ a}
(adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁) {l₁' : a ⟶ b} {r₁' : b ⟶ a}
(adj₁' : CategoryTheory.Bicategory.Adjunction l₁' r₁') {l₂ : b ⟶ c} {r₂ : c ⟶ b}
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (φ : l₁' ⟶ ... | null | true |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.ins.match_3.eq_2 | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} (motive : RBTree.RBNode α → Sort u_2) (a : RBTree.RBNode α) (y : α) (b : RBTree.RBNode α)
(h_1 : Unit → motive RBTree.RBNode.nil)
(h_2 : (a : RBTree.RBNode α) → (y : α) → (b : RBTree.RBNode α) → motive (RBTree.RBNode.node RBTree.RBColor.red a y b))
(h_3 :
(a : RBTree.RBNode α) → (y : α) → (b ... | null | true |
LinearMap.BilinMap.tensorDistrib._proof_27 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (R : Type u_1) (A : Type u_2) {M₁ : Type u_3} {N₁ : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid N₁] [inst_4 : Algebra R A] [inst_5 : Module A M₁]
[inst_6 : Module R N₁] [inst_7 : Module A N₁] [inst_8 : IsScalarTower R A N₁],
IsScalarTower R A (... | null | false |
Finset.insert_Ico_right_eq_Ico_succ | Mathlib.Order.Interval.Finset.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : SuccOrder α] {a b : α} [NoMaxOrder α],
a ≤ b → insert b (Finset.Ico a b) = Finset.Ico a (Order.succ b) | null | true |
CategoryTheory.Over.grpObjMkPullbackSnd_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X R S : C} {f : R ⟶ X} {g : S ⟶ X} [inst_2 : CategoryTheory.GrpObj (CategoryTheory.Over.mk f)],
CategoryTheory.MonObj.one =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε (Ca... | null | true |
CategoryTheory.Limits.pullback.lift_fst_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y)
(w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g) {Z_1 : C} (h_1 : X ⟶ Z_1),
CategoryTheory.CategoryStruct.com... | null | true |
_private.Mathlib.Order.Monotone.MonovaryOrder.0.monovary_iff_exists_monotone._simp_1_1 | Mathlib.Order.Monotone.MonovaryOrder | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
Monovary f g = MonovaryOn f g Set.univ | null | false |
instFullCondensedTypeCondensedSetUlift | Mathlib.Condensed.Functors | Condensed.ulift.Full | null | true |
ULift.seminormedCommRing._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (a b : ULift.{u_1, u_2} α), a - b = a + -b | null | false |
Matrix.IsHermitian.splits_charpoly | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n],
A.IsHermitian → A.charpoly.Splits | null | true |
Ordinal.instPosMulStrictMono | Mathlib.SetTheory.Ordinal.Arithmetic | PosMulStrictMono Ordinal.{u_4} | null | true |
CategoryTheory.Lax.LaxTrans.isoMk_inv_as_app | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} (app : (a : B) → η.app a ≅ θ.app a)
(naturality :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bic... | null | true |
CategoryTheory.Functor.IsLocallyFull | Mathlib.CategoryTheory.Sites.LocallyFullyFaithful | {C : Type uC} →
[inst : CategoryTheory.Category.{vC, uC} C] →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{vD, uD} D] →
CategoryTheory.Functor C D → CategoryTheory.GrothendieckTopology D → Prop | A functor `G : C ⥤ D` is locally full w.r.t. a topology on `D` if for every `f : G.obj U ⟶ G.obj V`,
the set of `G.map fᵢ : G.obj Wᵢ ⟶ G.obj U` such that `G.map fᵢ ≫ f` is
in the image of `G` is a coverage of the topology on `D`.
| true |
List.toString | Init.Data.ToString.Extra | {α : Type u_1} → [ToString α] → List α → String | Converts a list into a string, using `ToString.toString` to convert its elements.
The resulting string resembles list literal syntax, with the elements separated by `", "` and
enclosed in square brackets.
The resulting string may not be valid Lean syntax, because there's no such expectation for
`ToString` instances.
... | true |
SSet.Subcomplex.PairingCore.mk.inj | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} {ι : Type v} {dim : ι → ℕ}
{simplex : (s : ι) → X.obj (Opposite.op { len := dim s + 1 })} {index : (s : ι) → Fin (dim s + 2)}
{nonDegenerate₁ : ∀ (s : ι), simplex s ∈ X.nonDegenerate (dim s + 1)}
{nonDegenerate₂ :
∀ (s : ι),
(CategoryTheory.ConcreteCategory.hom (CategoryT... | null | true |
symmDiff_sdiff | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b c : α), symmDiff a b \ c = a \ (b ⊔ c) ⊔ b \ (a ⊔ c) | null | true |
ZMod.LFunction | Mathlib.NumberTheory.LSeries.ZMod | {N : ℕ} → [NeZero N] → (ZMod N → ℂ) → ℂ → ℂ | The unique meromorphic function `ℂ → ℂ` which agrees with `∑' n : ℕ, Φ n / n ^ s` wherever the
latter is convergent. This is constructed as a linear combination of Hurwitz zeta functions.
Note that this is not the same as `LSeries Φ`: they agree in the convergence range, but
`LSeries Φ s` is defined to be `0` if `re s... | true |
_private.Lean.Data.Lsp.Ipc.0.Lean.Lsp.Ipc.expandOutgoingCallHierarchy.go | Lean.Data.Lsp.Ipc | ℕ →
Lean.Lsp.CallHierarchyItem →
Array Lean.Lsp.Range → Std.TreeSet String compare → Lean.Lsp.Ipc.IpcM (Lean.Lsp.Ipc.CallHierarchy × ℕ) | null | true |
Std.DHashMap.Raw.Const.getD_empty | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {a : α} {fallback : β},
Std.DHashMap.Raw.Const.getD ∅ a fallback = fallback | null | true |
exists_and_self | Init.PropLemmas | ∀ (P : Prop) (Q : P → Prop), (∃ (p : P), Q p) ∧ P ↔ ∃ (p : P), Q p | null | true |
MvQPF.Pi.repr | Mathlib.Data.QPF.Multivariate.Constructions.Sigma | {n : ℕ} →
{A : Type u} →
(F : A → TypeVec.{u} n → Type u) →
[inst : (α : A) → MvQPF (F α)] → ⦃α : TypeVec.{u} n⦄ → MvQPF.Pi F α → ↑(MvQPF.Pi.P F) α | representation function for dependent products | true |
Std.TreeSet.get!_erase_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).get! k = default | null | true |
Polynomial.Splits.eq_X_sub_C_of_single_root | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R],
f.Splits → ∀ {x : R}, f.roots = {x} → f = Polynomial.C f.leadingCoeff * (Polynomial.X - Polynomial.C x) | null | true |
Sum.Lex.noMaxOrder | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [NoMaxOrder α] [NoMaxOrder β], NoMaxOrder (α ⊕ₗ β) | null | true |
Lean.Elab.Do.Context.doBlockResultType | Lean.Elab.Do.Basic | Lean.Elab.Do.Context → Lean.Expr | The expected type of the current `do` block.
This can be different from `ReturnCont.resultType` in `for` loop `do` blocks, for example.
| true |
CategoryTheory.FilteredObject._sizeOf_inst | Mathlib.CategoryTheory.Filtration.Basic | (C : Type u) →
{inst : CategoryTheory.Category.{v, u} C} →
(I : Type u_1) →
{inst_1 : CategoryTheory.Category.{u_2, u_1} I} →
[SizeOf C] → [SizeOf I] → SizeOf (CategoryTheory.FilteredObject C I) | null | false |
Interval.completeLattice._proof_4 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] (S : Set (Interval α)),
(⊥ ∉ S ∧ ∀ ⦃s : NonemptyInterval α⦄, ↑s ∈ S → ∀ ⦃t : NonemptyInterval α⦄, ↑t ∈ S → s.toProd.1 ≤ t.toProd.2) →
⨆ i, ⨆ (_ : ↑i ∈ S), i.toProd.1 ≤ (⨆ s, ⨆ (_ : ↑s ∈ S), s.toProd.1, ⨅ s, ⨅ (_ : ↑s ∈ S), s.toProd.2).2 | null | false |
PowerSeries.constantCoeff_iterate_derivative | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommSemiring R] (f : PowerSeries R) (n : ℕ),
PowerSeries.constantCoeff ((⇑PowerSeries.derivative)^[n] f) = ↑n.factorial * (PowerSeries.coeff n) f | Specialisation of `coeff_iterate_derivative` at `k = 0`: the constant term of the `n`-th formal
derivative recovers `n !` times the `n`-th coefficient, `constantCoeff (Dⁿ f) = n ! * coeff n f`. | true |
IsSemitopologicalRing.casesOn | Mathlib.Topology.Algebra.Ring.Basic | {R : Type u_2} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalNonAssocRing R] →
{motive : IsSemitopologicalRing R → Sort u} →
(t : IsSemitopologicalRing R) →
([toIsSemitopologicalSemiring : IsSemitopologicalSemiring R] →
[toContinuousNeg : ContinuousNeg R] → motive ⋯) →
... | null | false |
Std.ExtTreeMap.compare_minKey!_modify_eq | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {f : β → β}, cmp (t.modify k f).minKey! t.minKey! = Ordering.eq | null | true |
MeasureTheory.measurable_mlconvolution | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : Mul G] [inst_1 : Inv G] [MeasurableMul₂ G] [MeasurableInv G]
{f g : G → ENNReal} (μ : MeasureTheory.Measure G) [MeasureTheory.SFinite μ],
Measurable f → Measurable g → Measurable (MeasureTheory.mlconvolution f g μ) | The convolution of measurable functions is measurable. | true |
Lean.Meta.Canonicalizer.ExprVisited.noConfusion | Lean.Meta.Canonicalizer | {P : Sort u} →
{t t' : Lean.Meta.Canonicalizer.ExprVisited} → t = t' → Lean.Meta.Canonicalizer.ExprVisited.noConfusionType P t t' | null | false |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_union_eq._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), a ∈ s → s.erase a ∪ {a} = s | null | false |
metricSpaceOfNormedAddCommGroupOfAddTorsor._proof_4 | Mathlib.Analysis.Normed.Group.AddTorsor | ∀ (V : Type u_1) (P : Type u_2) [inst : NormedAddCommGroup V] [inst_1 : AddTorsor V P] (x y : P),
↑(NNReal.mk ((fun x y => ‖x -ᵥ y‖) x y) ⋯) = ENNReal.ofReal ‖x -ᵥ y‖ | null | false |
AffineIsometry.continuous | 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 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : PseudoMe... | null | true |
Lean.Lsp.CreateFile.Options.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.CreateFile.Options → Sort u} →
(t : Lean.Lsp.CreateFile.Options) →
((overwrite ignoreIfExists : Bool) → motive { overwrite := overwrite, ignoreIfExists := ignoreIfExists }) → motive t | null | false |
Subsemigroup.coe_equivMapOfInjective_apply | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup M) (f : M →ₙ* N)
(hf : Function.Injective ⇑f) (x : ↥S), ↑((S.equivMapOfInjective f hf) x) = f ↑x | null | true |
CategoryTheory.bicategoricalIsoComp | Mathlib.Tactic.CategoryTheory.BicategoricalComp | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} → {f g h i : a ⟶ b} → [CategoryTheory.BicategoricalCoherence g h] → (f ≅ g) → (h ≅ i) → (f ≅ i) | Compose two isomorphisms in a bicategorical category,
inserting unitors and associators between as necessary. | true |
SchwartzMap.bilinLeftCLM._proof_13 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G], ContinuousConstSMul ℝ G | null | false |
Std.TreeMap.Equiv.keyAtIdx_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {i : ℕ}
{h' : i < t₁.size} (h : t₁.Equiv t₂), t₁.keyAtIdx i h' = t₂.keyAtIdx i ⋯ | null | true |
Matrix.instCharP | Mathlib.LinearAlgebra.Matrix.CharP | ∀ {n : Type u_1} {R : Type u_2} [inst : DecidableEq n] [Nonempty n] [inst_2 : AddMonoidWithOne R] (p : ℕ) [CharP R p],
CharP (Matrix n n R) p | null | true |
_private.Mathlib.LinearAlgebra.SpecialLinearGroup.0.SpecialLinearGroup.centerEquivRootsOfUnity_invFun._simp_4 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] [Module.Free R V]
[Module.Finite R V] {g : SpecialLinearGroup R V},
(g ∈ Subgroup.center (SpecialLinearGroup R V)) = ∃ r, r ^ Module.finrank R V = 1 ∧ ↑↑g = r • LinearMap.id | null | false |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.testBit.match_1.eq_2 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive PosNum.one 0) (h_2 : (x : ℕ) → motive PosNum.one x)
(h_3 : (a : PosNum) → motive a.bit0 0) (h_4 : (p : PosNum) → (n : ℕ) → motive p.bit0 n.succ)
(h_5 : (a : PosNum) → motive a.bit1 0) (h_6 : (p : PosNum) → (n : ℕ) → motive p.bit1 n.succ),
(x = 0 → Fa... | null | true |
Set.powersetCard.sign._proof_3 | Mathlib.Order.Hom.PowersetCard | ∀ {n : ℕ} {I : Type u_1} [inst : Fintype I] (this : ∃ m, n + m = Fintype.card I), n + this.choose = Fintype.card I | null | false |
Real.casesOn | Mathlib.Basic.Real.Basic | {motive : ℝ → Sort u} → (t : ℝ) → ((cauchy : CauSeq.Completion.Cauchy abs) → motive { cauchy := cauchy }) → motive t | null | false |
CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_app_hom_assoc | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (j : J) (k : K) {Z : C}... | null | true |
CategoryTheory.MonoidalCategory.tensorRightTensor._proof_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
{Z Z' : C} (f : Z ⟶ Z'),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.tensorRight (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).map f)
(CategoryTheory.Mo... | null | false |
MeasureTheory.Measure.withDensityᵥ._proof_2 | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_2} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
(μ : MeasureTheory.Measure α) (f : α → E),
MeasureTheory.Integrable f μ →
∀ (s : ℕ → Set α),
(∀ (i : ℕ), MeasurableSet (s i)) →
Pairwise (Function.onFun Disjoint s) →
HasSum (... | null | false |
Finsupp.mapDomain_support_of_injective | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] [inst_1 : DecidableEq β] {f : α → β},
Function.Injective f → ∀ (s : α →₀ M), (Finsupp.mapDomain f s).support = Finset.image f s.support | null | true |
Fin.dfoldlM_zero | Batteries.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {α : Fin (0 + 1) → Type u_1} [inst : Monad m]
(f : (i : Fin 0) → α i.castSucc → m (α i.succ)) (x : α 0), Fin.dfoldlM 0 α f x = pure x | null | true |
HasProdLocallyUniformlyOn.mono | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β] {t : Set β},
HasProdLocallyUniformlyOn f g t → s ⊆ t → HasProdLocallyUniformlyOn f g s | null | true |
AlgEquiv.uniqueProd_apply | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Unique B] (self : B × A), AlgEquiv.uniqueProd self = self.2 | null | true |
Finset.card_le_card_of_forall_subsingleton | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) {s : Finset α} {t : Finset β},
(∀ a ∈ s, ∃ b ∈ t, r a b) → (∀ b ∈ t, {a | a ∈ s ∧ r a b}.Subsingleton) → s.card ≤ t.card | null | true |
Affine.Triangle.prod_div_one_sub_eq_one_of_mem_line_point_lineMap | Mathlib.LinearAlgebra.AffineSpace.Ceva | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {t : Affine.Triangle k P} {r : Fin 3 → k},
(∀ (i : Fin 3), r i ≠ 0) →
∀ {p' : P},
(∀ (i : Fin 3), p' ∈ line[k, t.points i, (AffineMap.lineMap (t.points (i + 1)) (t.point... | **Ceva's theorem** for a triangle, expressed using division. | true |
Lean.FromJson.ctorIdx | Lean.Data.Json.FromToJson.Basic | {α : Type u} → Lean.FromJson α → ℕ | null | false |
Finsupp.instAddCommGroup._proof_1 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {G : Type u_2} [inst : AddCommGroup G] (a b : ι →₀ G), a + b = b + a | null | false |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.ofExistsUnique._simp_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} {ι : Type u_3} [inst : DistribLattice α] [inst_1 : OrderBot α] {s : Finset ι} {f : ι → α},
s.SupIndep f = (↑s).PairwiseDisjoint f | null | false |
UniformEquiv.coe_prodCongr | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} [inst : UniformSpace α] [inst_1 : UniformSpace β]
[inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ), ⇑(h₁.prodCongr h₂) = Prod.map ⇑h₁ ⇑h₂ | null | true |
AddMonoidHom.toAddEquiv.congr_simp | Mathlib.Algebra.Colimit.Module | ∀ {M : Type u_4} {N : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f f_1 : M →+ N) (e_f : f = f_1)
(g g_1 : N →+ M) (e_g : g = g_1) (h₁ : g.comp f = AddMonoidHom.id M) (h₂ : f.comp g = AddMonoidHom.id N),
f.toAddEquiv g h₁ h₂ = f_1.toAddEquiv g_1 ⋯ ⋯ | null | true |
Std.Time.Nanosecond.instLEOffset._aux_1 | Std.Time.Time.Unit.Nanosecond | Std.Time.Nanosecond.Offset → Std.Time.Nanosecond.Offset → Prop | null | false |
Finsupp.equivFunOnFinite_single | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] [inst_1 : DecidableEq α] [inst_2 : Finite α] (x : α) (m : M),
(Finsupp.equivFunOnFinite fun₀ | x => m) = Pi.single x m | null | true |
Lean.LLVM.AttributeIndex.noConfusionType | Lean.Compiler.IR.LLVMBindings | Sort u → Lean.LLVM.AttributeIndex → Lean.LLVM.AttributeIndex → Sort u | null | false |
CategoryTheory.Functor.ranCounit._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{u_2, u_3} H]
[inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasRightKanExtension F] {F₁ F₂ : CategoryThe... | null | false |
IsLocalizedModule.Away.isUnit_algebraMap | Mathlib.Algebra.Module.LocalizedModule.Away | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} {N : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (f : M →ₗ[R] N) (r : R)
[IsLocalizedModule.Away r f], IsUnit ((algebraMap R (Module.End R N)) r) | null | true |
CategoryTheory.ShortComplex.SnakeInput.L₀'._proof_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp S.L₁.f S.L₁.g = CategoryTheory.CategoryStruct.comp 0 S.v₀₁.τ₃ | null | false |
AddSubgroup.instMeasurableVAdd | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G : Type u_2} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : MeasurableSpace α] [inst_2 : AddGroup G]
[inst_3 : AddAction G α] [MeasurableVAdd G α] (s : AddSubgroup G), MeasurableVAdd (↥s) α | null | true |
Complex.ofReal_exp._simp_1 | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℝ), Complex.exp ↑x = ↑(Real.exp x) | null | false |
ContravariantClass.mk._flat_ctor | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} {r : N → N → Prop}, Contravariant M N μ r → ContravariantClass M N μ r | null | false |
RBTree.RBMap.size | Batteries.Recycling.RBTree.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → RBTree.RBMap α β cmp → ℕ | `O(n)`. The number of items in the RBMap. | true |
SubmonoidClass.coe_multiset_prod | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {B : Type u_2} {S : B} {M : Type u_3} [inst : CommMonoid M] [inst_1 : SetLike B M] [inst_2 : SubmonoidClass B M]
(m : Multiset ↥S), ↑m.prod = (Multiset.map Subtype.val m).prod | null | true |
MeasureTheory.measure_biUnion_le | Mathlib.MeasureTheory.OuterMeasure.Basic | ∀ {α : Type u_1} {ι : Type u_2} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α]
{I : Set ι} (μ : F), I.Countable → ∀ (s : ι → Set α), μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i) | null | true |
instBooleanAlgebraSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_15 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (x x_1 : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }), x_1 ⊔ xᶜ = x_1 ⊔ xᶜ | null | false |
Bool.eq_true_of_true_le | Init.Data.Bool | ∀ {x : Bool}, true ≤ x → x = true | null | true |
Std.Async.MaybeTask.get | Std.Async.Basic | {α : Type} → Std.Async.MaybeTask α → α | Gets the value of the `MaybeTask` by blocking.
| true |
Float.Model.mk | Init.Data.Float.Model.Float | (toBits : UInt64) → Float.Model.Format.binary64.Valid toBits.toBitVec → Float.Model | null | true |
_private.Lean.Meta.Sym.Canon.0.Lean.Meta.Sym.Canon.canon.postReduce.match_1 | Lean.Meta.Sym.Canon | (motive : Option (Lean.Expr × ℕ) → Sort u_1) →
(__do_lift : Option (Lean.Expr × ℕ)) →
((e : Lean.Expr) → (k : ℕ) → motive (some (e, k))) → ((x : Option (Lean.Expr × ℕ)) → motive x) → motive __do_lift | null | false |
Lean.Grind.AC.Seq.isVar | Lean.Meta.Tactic.Grind.AC.Seq | Lean.Grind.AC.Seq → Bool | Returns `true` if `s` is a variable. | true |
CochainComplex.HomComplex.Cochain.toSingleMk_v_eq_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {p q : ℤ} (f : K.X p ⟶ X) {n : ℤ}
(h : p + n = q) (p' q' : ℤ) (hpq' : p' + n = q'),
p' ≠ p → (CochainComplex.HomComplex.Cochain.toSingl... | null | true |
List.extract_eq_drop_take | Init.Data.List.Basic | ∀ {α : Type u} {l : List α} {start stop : ℕ}, l.extract start stop = List.take (stop - start) (List.drop start l) | null | true |
Matrix.Hessenberg.Similarity.casesOn | Mathlib.LinearAlgebra.Matrix.Hessenberg.Similarity | {m : Type u_1} →
{R : Type u_2} →
[inst : CommRing R] →
[inst_1 : Fintype m] →
[inst_2 : LinearOrder m] →
[inst_3 : SuccOrder m] →
{A : Matrix m m R} →
{motive : Matrix.Hessenberg.Similarity A → Sort u} →
(t : Matrix.Hessenberg.Similarity A) →
... | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Basic.0.Std.Tactic.BVDecide.BVExpr.toString.match_1.eq_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (motive : (w : ℕ) → Std.Tactic.BVDecide.BVExpr w → Sort u_1) (w idx : ℕ)
(h_1 : (w idx : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var idx))
(h_2 : (w : ℕ) → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val))
(h_3 :
(len w start : ℕ) →
(expr : Std.Tactic.BVDecide.BVExpr w) → motive le... | null | true |
FirstOrder.Language.Embedding.substructureEquivMap.match_3 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Embedding M N) (s : L.Substructure M) (motive : ↥(FirstOrder.Language.Substructure.map f.toHom s) → Prop)
(x : ↥(FirstOrder.Language.Substructure.map f.toHom s)),
(∀ (val : N) (hn : val ∈ FirstOrder.La... | null | false |
Std.ExtHashMap.getKey_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → ∀ {h : k' ∈ m.insertManyIfNewUnit l}, (m.insertManyIfNewUnit l).getK... | null | true |
Polynomial.Separable.of_mul_right | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] {f g : Polynomial R}, (f * g).Separable → g.Separable | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterMapM.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | {β β' : Type u_1} →
{n : Type u_1 → Type u_2} →
{f : β → n (Option β')} →
[inst : MonadAttach n] →
(out : β) →
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) →
(__do_lift : Subtype (MonadAttach.CanReturn (f out))) →
((hf : MonadAttach.CanReturn (f o... | null | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.laxBraidedToCommMon._proof_2 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C]
{X Y Z : CategoryTheory.LaxBraidedFunctor (CategoryTheory.Discrete PUnit.{u_1 + 1}) C} (f : X ⟶ Y) (g : Y ⟶ Z),
((CategoryTheory.Functor.mapCommMonFunctor (Catego... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
ContinuousMap.measurable_iff_eval | Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousMap | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [SecondCountableTopology X]
[SecondCountableTopology Y] [LocallyCompactSpace X] [RegularSpace Y] [mY : MeasurableSpace Y] [BorelSpace Y]
{Z : Type u_3} [inst_7 : MeasurableSpace Z] {g : Z → C(X, Y)}, Measurable g ↔ ∀ (x : X), ... | A function `g : Z → C(X, Y)` is measurable if and only if,
for all `x : X`, `z ↦ g z x` is measurable. | true |
SemidirectProduct.card | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N},
Nat.card (N ⋊[φ] G) = Nat.card N * Nat.card G | null | true |
_private.Mathlib.Analysis.Normed.Module.RCLike.Real.0.closure_ball._simp_1_1 | Mathlib.Analysis.Normed.Module.RCLike.Real | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | null | false |
Invertible.algebraMapOfInvertibleAlgebraMap._proof_2 | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₗ[R] B),
f 1 = 1 → ∀ {r : R} (h : Invertible ((algebraMap R A) r)), (algebraMap R B) r * f ⅟((algebraMap R A) r) = 1 | null | false |
LinearEquiv.symm_ofLinearMap | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂}
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (f : ... | null | true |
NNReal.coe_add._simp_1 | Mathlib.Basic.NNReal.Defs | ∀ (r₁ r₂ : NNReal), ↑r₁ + ↑r₂ = ↑(r₁ + r₂) | null | false |
_private.Batteries.Data.Array.Scan.0.Array.scanrM.loop_toList._proof_1_2 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} {as : Array α} {stop start : ℕ}, start - stop = 0 → stop < start → False | null | false |
HomotopyCategory.spectralObjectMappingCone._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.SpectralObject | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C]
(D₁ D₂ : CategoryTheory.ComposableArrows (CochainComplex C ℤ) 2) (φ : D₁ ⟶ D₂),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.ComposableArrows.... | null | false |
MeasureTheory.VectorMeasure.instAddCommGroup._proof_3 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_2} [inst : AddCommGroup M] [inst_1 : TopologicalSpace M]
[inst_2 : IsTopologicalAddGroup M],
autoParam (∀ (n : ℕ) (a : MeasureTheory.VectorMeasure α M), ↑n.succ • a = ↑n • a + a)
SubNegMonoid.zsmul_succ'._autoParam | null | false |
AlgebraicGeometry.Scheme.GlueData.instPreservesColimitWalkingMultispanProdJMultispanDiagramForget | Mathlib.AlgebraicGeometry.Gluing | ∀ (D : AlgebraicGeometry.Scheme.GlueData),
CategoryTheory.Limits.PreservesColimit D.diagram.multispan AlgebraicGeometry.Scheme.forget | null | true |
CategoryTheory.IsDiscrete.instIsLocallyPresentableOfSubsingletonOfNonempty | Mathlib.CategoryTheory.Presentable.IsDiscrete | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.IsDiscrete C] [Subsingleton C]
[Nonempty C], CategoryTheory.IsLocallyPresentable.{w, v_1, u_1} C | null | true |
Lean.MonadNameGenerator.setNGen | Init.Meta.Defs | {m : Type → Type} → [self : Lean.MonadNameGenerator m] → Lean.NameGenerator → m Unit | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.partialMatch_add_one_add_one_iff._proof_1_9 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat : ByteArray} {s : ByteArray} {stackPos : ℕ} {needlePos : ℕ}, stackPos + 1 ≤ s.size → ¬stackPos < s.size → False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.