name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_640 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
CategoryTheory.SplitEpiCategory | Mathlib.CategoryTheory.EpiMono | (C : Type u₁) → [CategoryTheory.Category.{v₁, u₁} C] → Prop | A split epi category is a category in which every epimorphism is split. | true |
Subalgebra.LinearDisjoint.basisOfBasisRight.congr_simp | Mathlib.RingTheory.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
{A B : Subalgebra R S} (H : A.LinearDisjoint B) (H' : A ⊔ B = ⊤) {ι : Type u_1} (b b_1 : Module.Basis ι R ↥B),
b = b_1 → H.basisOfBasisRight H' b = H.basisOfBasisRight H' b_1 | null | true |
Lean.Meta.Grind.Arith.Linear.Struct.lowers | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.Struct → Lean.PArray (Lean.PArray Lean.Meta.Grind.Arith.Linear.IneqCnstr) | Mapping from variables to their "lower" bounds. We say a relational constraint `c` is a lower bound for a variable `x`
if `x` is the maximal variable in `c`, and `x` coefficient in `c` is negative.
| true |
Finset.Ioi_disjUnion_Iio | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : Fintype α] [inst_2 : LocallyFiniteOrderTop α]
[inst_3 : LocallyFiniteOrderBot α] (a : α), (Finset.Ioi a).disjUnion (Finset.Iio a) ⋯ = {a}ᶜ | null | true |
CategoryTheory.Functor.final_of_exists_of_isFiltered_of_fullyFaithful | Mathlib.CategoryTheory.Filtered.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.IsFilteredOrEmpty D] [F.Full] [F.Faithful],
(∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) → F.Final | In this situation, `C` is also filtered, see
`IsFilteredOrEmpty.of_exists_of_isFiltered_of_fullyFaithful`. | true |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.tendsto_densityProcess_fst_atTop_univ_of_monotone._simp_1_6 | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [T1Space X] {l : Filter Y} [l.NeBot] {c d : X},
Filter.Tendsto (fun x => c) l (nhds d) = (c = d) | null | false |
Order.coheight | Mathlib.Order.KrullDimension | {α : Type u_1} → [Preorder α] → α → ℕ∞ | The **coheight** of an element `a` in a preorder `α` is the supremum of the rightmost index of all
relation series of `α` ordered by `<` and beginning with `a`. In other words, it is
the largest `n` such that there's a series `a = a₀ < a₁ < ... < aₙ` (or `∞` if there is
no largest `n`).
The definition of `coheight` is... | true |
Std.TreeMap.maxKey!_modify_eq_maxKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
[inst : Inhabited α] {k : α} {f : β → β}, (t.modify k f).maxKey! = t.maxKey! | null | true |
WithBot.sumHomeomorph.match_1 | Mathlib.Topology.Order.WithTop | (ι : Type u_1) →
(motive : ι ⊕ Unit → Sort u_2) →
(x : ι ⊕ Unit) → ((i : ι) → motive (Sum.inl i)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x | null | false |
SimpleGraph.EdgeLabeling.labelGraph | Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling | {V : Type u_1} → {G : SimpleGraph V} → {K : Type u_3} → G.EdgeLabeling K → K → SimpleGraph V | Given an edge labeling and a choice of label `k`, construct the graph corresponding to the edges
labeled `k`.
| true |
Array.mk._flat_ctor | Init.Prelude | {α : Type u} → List α → Array α | null | false |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId_left_H | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j : ι} (f : i ⟶ j) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObjec... | null | true |
Pi.nonAssocRing._proof_2 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonAssocRing (f i)] (a : (i : I) → f i), a * 1 = a | null | false |
ContinuousWithinAt.sub | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u_1} {X : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace G] [inst_2 : Sub G]
[ContinuousSub G] {f g : X → G} {s : Set X} {x : X},
ContinuousWithinAt f s x → ContinuousWithinAt g s x → ContinuousWithinAt (f - g) s x | null | true |
_private.Mathlib.Tactic.NormNum.GCD.0.Mathlib.Meta.NormNum.isNat_gcd.match_1_1 | Mathlib.Tactic.NormNum.GCD | ∀
(motive :
(x x_1 x_2 x_3 x_4 : ℕ) →
Mathlib.Meta.NormNum.IsNat x x_2 → Mathlib.Meta.NormNum.IsNat x_1 x_3 → x_2.gcd x_3 = x_4 → Prop)
(x x_1 x_2 x_3 x_4 : ℕ) (x_5 : Mathlib.Meta.NormNum.IsNat x x_2) (x_6 : Mathlib.Meta.NormNum.IsNat x_1 x_3)
(x_7 : x_2.gcd x_3 = x_4),
(∀ (n n_1 : ℕ), motive (↑n) (↑n... | null | false |
MeasureTheory.Measure.sub_self | Mathlib.MeasureTheory.Measure.Sub | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ - μ = 0 | null | true |
LieModule.chainBotCoeff | Mathlib.Algebra.Lie.Weights.Chain | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
{M : Type u_3} →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L... | This is the largest `n : ℕ` such that `-i • α + β` is a weight for all `0 ≤ i ≤ n`. | true |
AddCommGrpCat.image.lift._proof_2 | Mathlib.Algebra.Category.Grp.Images | ∀ {G H : AddCommGrpCat} {f : G ⟶ H} (F' : CategoryTheory.Limits.MonoFactorisation f)
(x y : ↥(AddCommGrpCat.Hom.hom f).range),
(CategoryTheory.ConcreteCategory.hom F'.e)
↑(Classical.indefiniteDescription (fun x_1 => (AddCommGrpCat.Hom.hom f) x_1 = ↑(x + y)) ⋯) =
(CategoryTheory.ConcreteCategory.hom F'.e)
... | null | false |
AddMonoidAlgebra.instAddMonoid._proof_3 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] (a : AddMonoidAlgebra R M), a + 0 = a | null | false |
forall_isClosed_iff | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {p : Set X → Prop},
(∀ (t : Set X), IsClosed t → p t) ↔ ∀ (t : Set X), p (closure t) | null | true |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valued.integer.compactSpace_iff_completeSpace_and_isDiscreteValuationRing_and_finite_residueField.match_1_1 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {K : Type u_1} {Γ₀ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [inst_2 : Valued K Γ₀]
(motive :
CompleteSpace ↥(Valued.integer K) ∧ IsDiscreteValuationRing ↥(Valued.integer K) ∧ Finite (Valued.ResidueField K) →
Prop)
(x :
CompleteSpace ↥(Valued.integer K) ∧ IsDiscreteVa... | null | false |
_private.Std.Time.DateTime.PlainDateTime.0.Std.Time.PlainDateTime.ofWallTime._proof_2 | Std.Time.DateTime.PlainDateTime | ∀ (stamp : Std.Time.WallTime),
↑(Std.Time.Internal.Bounded.LE.byMod stamp.toNanoseconds.val 1000000000 Std.Time.PlainDateTime.ofWallTime._proof_1✝) <
0 →
↑(Std.Time.Internal.Bounded.LE.byMod stamp.toNanoseconds.val 1000000000
Std.Time.PlainDateTime.ofWallTime._proof_1✝) ≤
0 - 1 | null | false |
spectralAlgNorm_extends | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ {K : Type u_2} [inst : NormedField K] {L : Type u_3} [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : IsUltrametricDist K] [h_alg : Algebra.IsAlgebraic K L] (k : K),
(spectralAlgNorm K L) ((algebraMap K L) k) = ‖k‖ | null | true |
FundamentalGroupoid.eqToHom_eq | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ : X} (h : x₀ = x₁),
CategoryTheory.eqToHom ⋯ = (Path.Homotopic.Quotient.refl x₁).cast h ⋯ | null | true |
Semiquot.blur'._proof_1 | Mathlib.Data.Semiquot | ∀ {α : Type u_1} (q : Semiquot α) {s : Set α}, q.s ⊆ s → ∀ (a : ↑q.s), ↑a ∈ s | null | false |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.EqInfo.noConfusion | Lean.Meta.CongrTheorems | {P : Sort u} → {t t' : Lean.Meta.EqInfo✝} → t = t' → Lean.Meta.EqInfo.noConfusionType✝ P t t' | null | false |
List.max?_toArray | Init.Data.Array.MinMax | ∀ {α : Type u_1} [inst : Max α] {l : List α}, l.toArray.max? = l.max? | null | true |
MinTropical.tropOrderIso | Mathlib.Algebra.Tropical.Basic | {R : Type u} → [inst : Preorder R] → R ≃o MinTropical R | Reinterpret `x : R` as an element of `MinTropical R`, preserving the order. | true |
_private.Mathlib.Data.Fintype.Pi.0.Set.iUnion_snoc._simp_1_2 | Mathlib.Data.Fintype.Pi | ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) | null | false |
Std.ExtDTreeMap.diff.congr_simp | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (m₁ m₁_1 : Std.ExtDTreeMap α β cmp),
m₁ = m₁_1 → ∀ (m₂ m₂_1 : Std.ExtDTreeMap α β cmp), m₂ = m₂_1 → m₁.diff m₂ = m₁_1.diff m₂_1 | null | true |
Concept.instSupSet | Mathlib.Order.Concept | {α : Type u_2} → {β : Type u_3} → {r : α → β → Prop} → SupSet (Concept α β r) | null | true |
CategoryTheory.ConcreteCategory.homEquiv | 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} → (X ⟶ Y) ≃ CategoryTheory.ToHom X Y | `ConcreteCategory.hom` bundled as an `Equiv`.
| true |
CategoryTheory.Limits.image.map | 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) →
[CategoryTheory.Limits.HasImageMap sq] →
CategoryTheory.L... | The map on images induced by a commutative square. | true |
groupCohomology.coboundaries₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → (A : Rep.{max u u_1, u, u} k G) → Submodule k (G → ↑A) | The 1-coboundaries `B¹(G, A)` of `A : Rep k G`, defined as the image of the map
`A → Fun(G, A)` sending `(a, g) ↦ ρ_A(g)(a) - a.` | true |
hasFDerivAt_pi_polarCoord_symm | Mathlib.Analysis.SpecialFunctions.PolarCoord | ∀ {ι : Type u_1} [Finite ι] (p : ι → ℝ × ℝ),
HasFDerivAt (fun x i => ↑polarCoord.symm (x i)) (fderivPiPolarCoordSymm p) p | null | true |
Std.DTreeMap.size_emptyc | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}, ∅.size = 0 | null | true |
WithZero.coe_mul | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Mul α] (a b : α), ↑(a * b) = ↑a * ↑b | null | true |
Lean.Elab.Tactic.Conv.evalNestedTacticCore | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.Tactic | null | true |
IsDiscrete.recOn | Mathlib.Topology.Constructions | {X : Type u_2} →
[inst : TopologicalSpace X] →
{s : Set X} →
{motive : IsDiscrete s → Sort u} → (t : IsDiscrete s) → ((to_subtype : DiscreteTopology ↑s) → motive ⋯) → motive t | null | false |
MultilinearMap.ofSubsingleton_apply_apply | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ (R : Type uR) {ι : Type uι} (M₂ : Type v₂) (M₃ : Type v₃) [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] [inst_5 : Subsingleton ι] (i : ι)
(f : M₂ →ₗ[R] M₃) (x : ι → M₂), ((MultilinearMap.ofSubsingleton R M₂ M₃ i) f) x = f (x i) | null | true |
Multiset.prod_hom_rel | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommMonoid M] [inst_1 : CommMonoid N] (s : Multiset ι)
{r : M → N → Prop} {f : ι → M} {g : ι → N},
r 1 1 → (∀ ⦃a : ι⦄ ⦃b : M⦄ ⦃c : N⦄, r b c → r (f a * b) (g a * c)) → r (Multiset.map f s).prod (Multiset.map g s).prod | null | true |
RestrictedProduct.nhds_zero_eq_map_ofPre | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} (R : ι → Type u_2) {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)] {B : (i : ι) → S i}
{T : Set ι} [inst_1 : (i : ι) → TopologicalSpace (R i)] [inst_2 : (i : ι) → Zero (R i)]
[inst_3 : ∀ (i : ι), ZeroMemClass (S i) (R i)],
(∀ (i : ι), IsOpen ↑(B i)) →
∀ (hT : Filter.cofinite ≤ Filte... | null | true |
UInt64.add_eq_right | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a + b = b ↔ a = 0 | null | true |
FreeAbelianGroup.ofMulHom_coe | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u} [inst : Monoid α], ⇑FreeAbelianGroup.ofMulHom = FreeAbelianGroup.of | null | true |
NumberField.InfinitePlace.Completion.WithAbs.ratCast_equiv | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ (v : NumberField.InfinitePlace ℚ) (x : WithAbs ↑v),
↑((WithAbs.equiv ↑v) x) = NumberField.InfinitePlace.Completion.ofCompletion ↑x | The coercion from the rationals to its completion along an infinite place is `Rat.cast`. | true |
ShiftLeft.recOn | Init.Prelude | {α : Type u} →
{motive : ShiftLeft α → Sort u_1} →
(t : ShiftLeft α) → ((shiftLeft : α → α → α) → motive { shiftLeft := shiftLeft }) → motive t | null | false |
ENat.sSup_mul | Mathlib.Data.ENat.Lattice | ∀ {s : Set ℕ∞} {a : ℕ∞}, sSup s * a = ⨆ b ∈ s, b * a | null | true |
List.dropLast_prefix | Init.Data.List.Sublist | ∀ {α : Type u_1} (l : List α), l.dropLast <+: l | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter.0.CategoryTheory.SimplicialObject.σ₀Iter_δ₀Iter._simp_1_3 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {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 |
BoxIntegral.Prepartition.distortion_le_of_mem | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) [inst : Fintype ι],
J ∈ π → J.distortion ≤ π.distortion | null | true |
BitVec.toInt_eq_toNat_of_lt | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x : BitVec n}, 2 * x.toNat < 2 ^ n → x.toInt = ↑x.toNat | null | true |
preimage_map_fst_pullbackDiagonal | Mathlib.Data.Set.Prod | ∀ {X : Type u_2} {Y : Sort u_3} {Z : Type u_1} {f : X → Y} {g : Z → Y},
Function.PullbackSelf.map_fst ⁻¹' Function.pullbackDiagonal f = Function.pullbackDiagonal Function.Pullback.snd | null | true |
HomotopicalAlgebra.CofibrantObject.HoCat.adjUnit._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x : HomotopicalAlgebra.CofibrantObject C), HomotopicalAlgebra.cofibrantObjects C x.bifibrantResolutionObj.obj | null | false |
DomMulAct.mk_pow | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : Monoid M] (a : M) (n : ℕ), DomMulAct.mk (a ^ n) = DomMulAct.mk a ^ n | null | true |
Lean.Lsp.CodeAction.title | Lean.Data.Lsp.CodeActions | Lean.Lsp.CodeAction → String | A short, human-readable, title for this code action. | true |
Matroid.RankFinite | Mathlib.Combinatorics.Matroid.Basic | {α : Type u_1} → Matroid α → Prop | A `RankFinite` matroid is one whose bases are finite | true |
CategoryTheory.Limits.FormalCoproduct.evalOpCompInlIsoId_hom_app_app | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (A : Type u₁) [inst_1 : CategoryTheory.Category.{v₁, u₁} A]
[inst_2 : CategoryTheory.Limits.HasProducts A] (X : CategoryTheory.Functor Cᵒᵖ A) (X_1 : Cᵒᵖ),
((CategoryTheory.Limits.FormalCoproduct.evalOpCompInlIsoId C A).hom.app X).app X_1 =
CategoryTheory.... | null | true |
_private.Batteries.Recycling.MonadSatisfying.Basic.0.SatisfiesM_ExceptT_eq.match_1_5 | Batteries.Recycling.MonadSatisfying.Basic | ∀ {α ρ : Type u_1} (a : α) (motive : (x : α) → Except.ok a = Except.ok x → Prop) (x : α)
(x_1 : Except.ok a = Except.ok x), (∀ (_ : Unit), motive a ⋯) → motive x x_1 | null | false |
Set.monoid._proof_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_1} [inst : Monoid α] (x : Set α), x ^ 0 = 1 | null | false |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.EqInfo._sizeOf_inst | Lean.Meta.CongrTheorems | SizeOf Lean.Meta.EqInfo✝ | null | false |
DifferentiableWithinAt.continuousMultilinear_apply_const | Mathlib.Analysis.Calculus.FDeriv.CompCLM | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {ι : Type u_5} {M : ι → Type u_6}
[inst_3 : (i : ι) → NormedAddCommGroup (M i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (M i)] {H : Type u_7}
[inst_5 : NormedAddCommGroup... | null | true |
Std.DTreeMap.wf | Std.Data.DTreeMap.Basic | ∀ {α : Type u} {β : α → Type v} {cmp : autoParam (α → α → Ordering) Std.DTreeMap._auto_1} (self : Std.DTreeMap α β cmp),
self.inner.WF | Internal implementation detail of the tree map. | true |
_private.Mathlib.Logic.Equiv.Set.0.Equiv.preimage_piEquivPiSubtypeProd_symm_pi._simp_1_3 | Mathlib.Logic.Equiv.Set | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
LinearEquiv.prodProdProdComm_apply | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) (M₃ : Type y) (M₄ : Type z) [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : AddCommMonoid M₄] [inst_5 : Module R M]
[inst_6 : Module R M₂] [inst_7 : Module R M₃] [inst_8 : Module R M₄] (mnmn : (M × M₂) × M₃ × ... | null | true |
Lean.Parser.registerBuiltinDynamicParserAttribute | Lean.Parser.Extension | Lean.Name → Lean.Name → autoParam Lean.Name Lean.Parser.registerBuiltinDynamicParserAttribute._auto_1 → IO Unit | A builtin parser attribute that can be extended by users. | true |
RCLike.natCast._inherited_default | Mathlib.Analysis.RCLike.Basic | {K : semiOutParam (Type u_1)} → K → (K → K → K) → K → ℕ → K | null | false |
Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor._sizeOf_inst | Mathlib.Tactic.Linarith.Datatypes | SizeOf Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor | null | false |
_private.Mathlib.AlgebraicGeometry.OrderOfVanishing.0.AlgebraicGeometry.Scheme.ord_of_isUnit._simp_1_2 | Mathlib.AlgebraicGeometry.OrderOfVanishing | ∀ {R : Type u_10} {S : Type u_11} {F : Type u_12} [inst : Zero R] [inst_1 : Zero S] [inst_2 : FunLike F R S]
[ZeroHomClass F R S] (f : F), Function.Injective ⇑f → ∀ {x : R}, (f x ≠ 0) = (x ≠ 0) | null | false |
_private.Lean.Compiler.Old.0.Lean.Compiler.checkIsDefinition.match_4 | Lean.Compiler.Old | (motive : Option Lean.AsyncConstantInfo → Sort u_1) →
(x : Option Lean.AsyncConstantInfo) →
((info : Lean.AsyncConstantInfo) → motive (some info)) → ((x : Option Lean.AsyncConstantInfo) → motive x) → motive x | null | false |
CategoryTheory.Limits.BinaryCofan.IsColimit.hom_ext | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryCofan X Y}
(h : CategoryTheory.Limits.IsColimit s) {f g : s.pt ⟶ W},
CategoryTheory.CategoryStruct.comp s.inl f = CategoryTheory.CategoryStruct.comp s.inl g →
CategoryTheory.CategoryStruct.comp s.inr f = Catego... | null | true |
CategoryTheory.Functor.mapMonCompIso._proof_6 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_4} [inst_4 : CategoryTheory.Category.{u_3, u_4} E] [inst_5 : CategoryTheory.MonoidalCate... | null | false |
VectorBundleCore.vectorBundle | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_5} (Z : VectorBundleCore R B F ι),
VectorBundle R F Z.Fiber | null | true |
CategoryTheory.CommaMorphism.instAddHomComma | Mathlib.CategoryTheory.Preadditive.Comma | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Preadditive A] →
{B : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_3 : CategoryTheory.Preadditive B] →
{T : Type u₃} →
[inst_4 : CategoryTheory.Category.{v₃,... | null | true |
IsLocalization.algEquivOfAlgEquiv | Mathlib.RingTheory.Localization.Basic | {A : Type u_4} →
[inst : CommSemiring A] →
{R : Type u_5} →
[inst_1 : CommSemiring R] →
[inst_2 : Algebra A R] →
{M : Submonoid R} →
(S : Type u_6) →
[inst_3 : CommSemiring S] →
[inst_4 : Algebra A S] →
[inst_5 : Algebra R S] →
... | If `S`, `Q` are localizations of `R` and `P` at submonoids `M`, `T` respectively,
an isomorphism `h : R ≃ₐ[A] P` such that `h(M) = T` induces an isomorphism of localizations
`S ≃ₐ[A] Q`. | true |
CategoryTheory.PreGaloisCategory.PreservesIsConnected | Mathlib.CategoryTheory.Galois.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{D : Type v₁} → [inst_1 : CategoryTheory.Category.{v₂, v₁} D] → CategoryTheory.Functor C D → Prop | A functor is said to preserve connectedness if whenever `X : C` is connected,
also `F.obj X` is connected. | true |
_private.Lean.Parser.Extension.0.Lean.Parser.resolveParserNameCore.isParser.match_1 | Lean.Parser.Extension | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((us : List Lean.Level) → motive (Lean.Expr.const `Lean.Parser.Parser us)) →
((us : List Lean.Level) → motive (Lean.Expr.const `Lean.Parser.TrailingParser us)) →
((us : List Lean.Level) → motive (Lean.Expr.const `Lean.ParserDescr us)) →
(... | null | false |
Monotone.partSeq | Mathlib.Order.Part | ∀ {α : Type u_1} [inst : Preorder α] {β γ : Type u_4} {f : α → Part (β → γ)} {g : α → Part β},
Monotone f → Monotone g → Monotone fun x => f x <*> g x | null | true |
instNonUnitalCommCStarAlgebraSubtypeMemNonUnitalStarSubalgebraComplexElementalOfIsStarNormal._proof_7 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] (x : A) (a b c : ↥(NonUnitalStarAlgebra.elemental ℂ x)),
a * (b + c) = a * b + a * c | null | false |
Set.Ioi_pred_eq_Ici | Mathlib.Order.Interval.Set.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] [NoMinOrder α] (a : α),
Set.Ioi (Order.pred a) = Set.Ici a | null | true |
CategoryTheory.PreGaloisCategory.instGroupAutGalois._aux_16 | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
(F : CategoryTheory.Functor C FintypeCat) →
ℤ → CategoryTheory.PreGaloisCategory.AutGalois F → CategoryTheory.PreGaloisCategory.AutGalois F | null | false |
CategoryTheory.Functor.flipping | Mathlib.CategoryTheory.Functor.Currying | {C : Type u₂} →
[inst : CategoryTheory.Category.{v₂, u₂} C] →
{D : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} D] →
{E : Type u₄} →
[inst_2 : CategoryTheory.Category.{v₄, u₄} E] →
CategoryTheory.Functor C (CategoryTheory.Functor D E) ≌
CategoryTheory.Fun... | The equivalence of functor categories given by flipping. | true |
CategoryTheory.GradedObject.mapTrifunctorMapObj | Mathlib.CategoryTheory.GradedObject.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] →
[inst_3 : CategoryTheory.Category.{v_4, u... | Given a trifunctor `F : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₃`, graded objects `X₁ : GradedObject I₁ C₁`,
`X₂ : GradedObject I₂ C₂`, `X₃ : GradedObject I₃ C₃`, and a map `p : I₁ × I₂ × I₃ → J`,
this is the `J`-graded object sending `j` to the coproduct of
`((F.obj (X₁ i₁)).obj (X₂ i₂)).obj (X₃ i₃)` for `p ⟨i₁, i₂, i₃⟩ = k`. | true |
Lean.ConstantInfo.recInfo.sizeOf_spec | Lean.Declaration | ∀ (val : Lean.RecursorVal), sizeOf (Lean.ConstantInfo.recInfo val) = 1 + sizeOf val | null | true |
continuous_if_const | Mathlib.Topology.Piecewise | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → β} (p : Prop)
[inst_2 : Decidable p], (p → Continuous f) → (¬p → Continuous g) → Continuous fun a => if p then f a else g a | null | true |
Finmap.liftOn₂_toFinmap | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} {γ : Type u_1} (s₁ s₂ : AList β) (f : AList β → AList β → γ)
(H : ∀ (a₁ b₁ a₂ b₂ : AList β), a₁.entries.Perm a₂.entries → b₁.entries.Perm b₂.entries → f a₁ b₁ = f a₂ b₂),
s₁.toFinmap.liftOn₂ s₂.toFinmap f H = f s₁ s₂ | null | true |
Std.TreeMap.getElem_insertMany_list_of_contains_eq_false | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : BEq α] [inst_2 : Std.LawfulBEqCmp cmp] {l : List (α × β)} {k : α}
(contains : (List.map Prod.fst l).contains k = false) {h' : k ∈ t.insertMany l}, (t.insertMany l)[k] = t[k] | null | true |
_private.Mathlib.MeasureTheory.Function.UniformIntegrable.0.MeasureTheory.unifIntegrable_finite._simp_1_1 | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {f : Filter α} {u : α → ENNReal}, Filter.Tendsto u f (nhds 0) = ∀ ε > 0, ∀ᶠ (x : α) in f, u x ≤ ε | null | false |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm.0.MeasureTheory.lpNorm_eq_zero._simp_1_2 | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ (x : ENNReal), (x.toReal = 0) = (x = 0 ∨ x = ⊤) | null | false |
Localization.AtPrime.mapPiEvalRingHom | Mathlib.RingTheory.Localization.AtPrime.Basic | {ι : Type u_4} →
{R : ι → Type u_5} →
[inst : (i : ι) → CommSemiring (R i)] →
{i : ι} →
(I : Ideal (R i)) →
[inst_1 : I.IsPrime] → Localization.AtPrime (Ideal.comap (Pi.evalRingHom R i) I) →+* Localization.AtPrime I | `Localization.localRingHom` specialized to a projection homomorphism from a product ring. | true |
_private.Mathlib.Data.Set.Pairwise.Lattice.0.Set.pairwise_iUnion₂._simp_1_3 | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Graph.IsSpanningSubgraph.mono_left | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G H K : Graph α β}, H ≤ K → K ≤ G → H ≤s G → K ≤s G | null | true |
Convex.smul_vadd_mem_of_mem_nhds_of_mem_asymptoticCone | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [IsStrictOrderedRing k]
[inst_3 : TopologicalSpace k] [OrderTopology k] [inst_5 : AddCommGroup V] [inst_6 : Module k V]
[inst_7 : TopologicalSpace V] [IsTopologicalAddGroup V] [ContinuousSMul k V] {s : Set V} {c : k} {v p : V},
Convex k s →... | If `v` is in the asymptotic cone of a convex set `s`, then for every interior point `p`, the ray
of direction `v` starting from `p` is contained in `s`. | true |
Std.Do.SPred.forall_cons | Std.Do.SPred.SPred | ∀ {σs : List (Type u)} {σ : Type u} {s : σ} {α : Sort u_1} {P : α → Std.Do.SPred (σ :: σs)},
Std.Do.SPred.forall P s = spred(∀ a, P a s) | null | true |
Algebra.TensorProduct.piScalarRight | Mathlib.RingTheory.TensorProduct.Pi | (R : Type u_1) →
(S : Type u_2) →
(A : Type u_3) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] →
[inst_3 : Semiring A] →
[inst_4 : Algebra R A] →
[inst_5 : Algebra S A] →
[inst_6 : IsScalarTower R ... | Variant of `Algebra.TensorProduct.piRight` with constant factors. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_diff!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Set.IsSelfInv.compl | Mathlib.Algebra.Group.Pointwise.Set.SelfInv | ∀ {α : Type u_1} [inst : Inv α] {s : Set α}, IsSelfInv s → IsSelfInv sᶜ | **Alias** of the reverse direction of `Set.isSelfInv_compl_iff`. | true |
CategoryTheory.MorphismProperty.Over.mapPullbackAdj._proof_10 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} [inst_2 : P.IsStableUnderComposition] [inst_3 : Q.IsStableUnderBaseChange]
(f : X ⟶ Y) [inst_4 : P.HasPullbacksAlong f] [inst_5 : P.IsStableUnderBaseChangeAlong f]
[inst... | null | false |
IncidenceAlgebra.sum_Icc_mu_left | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_4} [inst : Ring 𝕜] [inst_1 : PartialOrder α] [inst_2 : LocallyFiniteOrder α]
[inst_3 : DecidableEq α] (a b : α), ∑ x ∈ Finset.Icc a b, (IncidenceAlgebra.mu 𝕜) x b = if a = b then 1 else 0 | null | true |
div_le_inv_mul_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LinearOrder α] [MulLeftMono α] {a b : α} [MulRightMono α],
a / b ≤ a⁻¹ * b ↔ a ≤ b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.