name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.withBRecOnArgs.go.go2._unsafe_rec | Lean.Meta.IndPredBelow | Lean.Meta.IndPredBelow.Context✝ →
Array Lean.Expr → Lean.Name → Array Lean.Expr → ℕ → Array Lean.Expr → Array Lean.Expr → Lean.MetaM Lean.Expr | null | false |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_eq_pullHom | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{obj obj' : (i : ι) → ↑(F.obj { as := Opp... | null | true |
ProbabilityTheory.Kernel.instIsDeterministicProdSwap | Mathlib.Probability.Kernel.Deterministic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β},
ProbabilityTheory.IsDeterministic (ProbabilityTheory.Kernel.swap α β) | null | true |
LinearIndependent.of_isLocalizedModule | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} (Rₛ : Type u_2) [inst : CommSemiring R] (S : Submonoid R) [inst_1 : CommSemiring Rₛ]
[inst_2 : Algebra R Rₛ] [IsLocalization S Rₛ] {M : Type u_3} {Mₛ : Type u_4} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid Mₛ] [inst_7 : Module R Mₛ] [inst_8 : Module Rₛ Mₛ]
[IsScalarTo... | null | true |
_private.Mathlib.Topology.Algebra.Module.LocallyConvex.0.LinearOrderedSemiring.toLocallyConvexSpace._simp_5 | Mathlib.Topology.Algebra.Module.LocallyConvex | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderClosedTopology α] {a b x : α},
a < x → x < b → (Set.Ioo a b ∈ nhds x) = True | null | false |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.mapZ_comp | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {X Y X' Y' : C} {f : X ⟶ Y} {g : X' ⟶ Y'}
(φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) {X'' Y'' : C} {h : X'' ⟶ Y''}
(ψ : CategoryTheory.Arrow.mk g ⟶... | null | true |
Polynomial.Monic.natDegree_pow | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → ∀ (n : ℕ), (p ^ n).natDegree = n * p.natDegree | null | true |
Encodable.encodek₂ | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} [inst : Encodable α] (a : α), Encodable.decode₂ α (Encodable.encode a) = some a | null | true |
_private.Lean.Elab.ConfigEval.DeriveEvalExpr.0.Lean.Elab.ConfigEval.deriveEvalExprUsingMetaEval._sparseCasesOn_2 | Lean.Elab.ConfigEval.DeriveEvalExpr | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.NumberTheory.NumberField.Completion.FinitePlace.0.instIsDiscreteValuationRingSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers._simp_2 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ (K : Type u) [inst : Field K] {Γ : Type u_1} [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation K Γ)
{a : ↥v.valuationSubring}, (a ∈ IsLocalRing.maximalIdeal ↥v.valuationSubring) = (v ↑a < 1) | null | false |
_private.Lean.Meta.Tactic.LibrarySearch.0.Lean.Meta.LibrarySearch.isVar | Lean.Meta.Tactic.LibrarySearch | Lean.Expr → Bool | null | true |
CategoryTheory.ShortComplex.rightHomologyιNatTrans | Mathlib.Algebra.Homology.ShortComplex.RightHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasKernels C] →
[inst_3 : CategoryTheory.Limits.HasCokernels C] →
CategoryTheory.ShortComplex.rightHomologyFunctor C ⟶ CategoryTheory.Short... | The natural transformation `S.rightHomology ⟶ S.opcycles` for all short complexes `S`. | true |
CategoryTheory.Quiv.hom_map_inv_map_of_iso | Mathlib.CategoryTheory.Category.Quiv | ∀ {V W : CategoryTheory.Quiv} (e : V ≅ W) {X Y : ↑W} (f : X ⟶ Y), e.hom.map (e.inv.map f) = Quiver.homOfEq f ⋯ ⋯ | null | true |
SSet.Truncated.Edge.tgt_eq | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | ∀ {X : SSet.Truncated 2} {x₀ x₁ : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge._proof_1 })}
(self : SSet.Truncated.Edge x₀ x₁),
(CategoryTheory.ConcreteCategory.hom
(X.map (SimplexCategory.Truncated.δ₂ 0 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op))
self.... | The target of the edge is `x₁`. | true |
Aesop.IndexMatchResult.instOrd | Aesop.Index.Basic | {α : Type} → [Ord α] → Ord (Aesop.IndexMatchResult α) | null | true |
Finset.local_lubell_yamamoto_meshalkin_inequality_mul | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {𝒜 : Finset (Finset α)} {r : ℕ},
Set.Sized r ↑𝒜 → 𝒜.card * r ≤ 𝒜.shadow.card * (Fintype.card α - r + 1) | The downward **local LYM inequality**, with cancelled denominators. `𝒜` takes up less of `α^(r)`
(the finsets of card `r`) than `∂𝒜` takes up of `α^(r - 1)`. | true |
CategoryTheory.Sieve.sieveOfSubfunctor._proof_1 | Mathlib.CategoryTheory.Sites.Sieves.Presheaf | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {R : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
(f : R ⟶ CategoryTheory.yoneda.obj X) {Y Z : C} {f_1 : Y ⟶ X},
(∃ t, (CategoryTheory.ConcreteCategory.hom (f.app (Opposite.op Y))) t = f_1) →
∀ (g : Z ⟶ Y),
∃ t, (CategoryTheory.ConcreteCateg... | null | false |
BoxIntegral.Box.nonempty_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), (↑I).Nonempty | null | true |
Matrix.instLieRingToLieAlgebra._proof_28 | Mathlib.Algebra.Lie.SerreConstruction | ∀ (R : Type u_1) {B : Type u_2} [inst : CommRing R] (CM : Matrix B B ℤ) [inst_1 : DecidableEq B]
(x : Matrix.ToLieAlgebra R CM), ⁅x, x⁆ = 0 | null | false |
MLList.append | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α : Type u_1} → [Monad m] → MLList m α → (Unit → MLList m α) → MLList m α | Concatenate two monadic lazy lists. | true |
ArithmeticFunction.prod_eq_iff_prod_pow_moebius_eq_on_of_nonzero | Mathlib.NumberTheory.ArithmeticFunction.Moebius | ∀ {R : Type u_1} [inst : CommGroupWithZero R] (s : Set ℕ),
(∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s) →
∀ {f g : ℕ → R},
(∀ n > 0, f n ≠ 0) →
(∀ n > 0, g n ≠ 0) →
((∀ n > 0, n ∈ s → ∏ i ∈ n.divisors, f i = g n) ↔
∀ n > 0, n ∈ s → ∏ x ∈ n.divisorsAntidiagonal, g x.2 ^ ArithmeticFuncti... | Möbius inversion for functions to a `CommGroupWithZero`, where the equalities only hold on
a well-behaved set. | true |
FreeMonoid.map.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → β),
FreeMonoid.map f =
{ toFun := fun l => FreeMonoid.ofList (List.map f (FreeMonoid.toList l)), map_one' := ⋯, map_mul' := ⋯ } | null | true |
AlgebraicGeometry.Scheme.BirationalOver | Mathlib.AlgebraicGeometry.Birational.Birational | {S X Y : AlgebraicGeometry.Scheme} → (X ⟶ S) → (Y ⟶ S) → Prop | `X` and `Y` are birational over `S` if there exists a partial isomorphism between them
that is compatible with the structure maps to `S`. | true |
String.Slice.Pattern.Model.IsLongestRevMatch.rec | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.Model.PatternModel pat] →
{s : String.Slice} →
{pos : s.Pos} →
{motive : String.Slice.Pattern.Model.IsLongestRevMatch pat pos → Sort u} →
((isRevMatch : String.Slice.Pattern.Model.IsRevMatch pat pos) →
(not_i... | null | false |
Nat.dvd_left_iff_eq | Mathlib.Data.Nat.Init | ∀ {m n : ℕ}, (∀ (a : ℕ), a ∣ m ↔ a ∣ n) ↔ m = n | Two natural numbers are equal if and only if they have the same divisors. | true |
Array.foldrM_empty | Init.Data.Array.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] {f : α → β → m β} {init : β}
{start stop : ℕ}, Array.foldrM f init #[] start stop = pure init | null | true |
_private.Mathlib.MeasureTheory.Constructions.Cylinders.0.MeasureTheory.generateFrom_measurableCylinders._simp_1_5 | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
WithLp.prodContinuousLinearEquiv_apply | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : Semiring 𝕜] [inst_3 : AddCommGroup α] [inst_4 : AddCommGroup β] [inst_5 : Module 𝕜 α] [inst_6 : Module 𝕜 β]
(a : WithLp p (α × β)), (WithLp.prodContinuousLinearEquiv p 𝕜 α β) a = a.o... | null | true |
IsSemisimpleModule.exists_end_ringEquiv_pi_matrix_end | Mathlib.RingTheory.SimpleModule.WedderburnArtin | ∀ (R : Type u) [inst : Ring R] (M : Type v) [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSemisimpleModule R M]
[Module.Finite R M],
∃ n S d,
(∀ (i : Fin n), IsSimpleModule R ↥(S i)) ∧
(∀ (i : Fin n), NeZero (d i)) ∧
Nonempty (Module.End R M ≃+* ((i : Fin n) → Matrix (Fin (d i)) (Fin (d i)) (... | null | true |
Std.DTreeMap.Internal.Impl.Const.get_alter!_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} {f : Option β → Option β} {hc : k ∈ Std.DTreeMap.Internal.Impl.Const.alter! k f t},
Std.DTreeMap.Internal.Impl.Const.get (Std.DTreeMap.Internal.Impl.Const.alter! k f t) k hc =
(... | null | true |
ZFSet.pair.eq_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x y : ZFSet.{u}), x.pair y = {{x}, {x, y}} | null | true |
Pi.vsub_def | Mathlib.Algebra.Torsor.Basic | ∀ {I : Type u} {fg : I → Type v} [inst : (i : I) → AddGroup (fg i)] {fp : I → Type w}
[inst_1 : (i : I) → AddTorsor (fg i) (fp i)] (p q : (i : I) → fp i), p -ᵥ q = fun i => p i -ᵥ q i | null | true |
_private.Mathlib.LinearAlgebra.FreeProduct.Basic.0.LinearAlgebra.FreeProduct.rel.match_1.eq_1 | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ (motive : Fin 2 → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()) =
h_1 () | null | true |
Lean.MessageData.instCoeLevel | Lean.Message | Coe Lean.Level Lean.MessageData | null | true |
NoMaxOrder.infinite | Mathlib.Order.Interval.Set.Infinite | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α] [NoMaxOrder α], Infinite α | A nonempty preorder with no maximal element is infinite. | true |
Stream'.Seq.corec_eq | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {β : Type v} (f : β → Option (α × β)) (b : β),
(Stream'.Seq.corec f b).destruct = Stream'.Seq.omap (Stream'.Seq.corec f) (f b) | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_slope_of_ne | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} [inst_1 : DecidableEq F] {P Q : Fin 3 → F},
P 2 ≠ 0 →
Q 2 ≠ 0 →
P 0 * Q 2 ≠ Q 0 * P 2 →
W.toAffine.slope (P 0 / P 2) (Q 0 / Q 2) (P 1 / P 2) (Q 1 / Q 2) =
(P 1 * Q 2 - Q 1 * P 2) / (P 0 * Q 2 - Q 0 * P 2) | null | true |
Float.Model.UnpackedFloat.packedZero.eq_1 | Init.Data.Float.Model.Unpacked.Pack.Lemmas | ∀ (spec : Float.Model.Format) (sign : Float.Model.UnpackedFloat.Sign),
Float.Model.UnpackedFloat.packedZero spec sign = Float.Model.UnpackedFloat.packComponents spec sign 0 0 | null | true |
_private.Mathlib.Topology.OpenPartialHomeomorph.Continuity.0.OpenPartialHomeomorph.preimage_eventuallyEqSet_target_inter_preimage_inter._simp_1_3 | Mathlib.Topology.OpenPartialHomeomorph.Continuity | ∀ {p q : Prop}, (p ↔ p ∧ q) = (p → q) | null | false |
Lean.Parser.Term.forInMacro'.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
Lean.Elab.Info.ofTacticInfo.inj | Lean.Elab.InfoTree.Types | ∀ {i i_1 : Lean.Elab.TacticInfo}, Lean.Elab.Info.ofTacticInfo i = Lean.Elab.Info.ofTacticInfo i_1 → i = i_1 | null | true |
Encodable.decodeList._proof_1 | Mathlib.Logic.Equiv.List | ∀ (v v₂ : ℕ), v₂ < v.succ → InvImage (fun x1 x2 => x1 < x2) (fun x => x) v₂ v.succ | null | false |
CategoryTheory.Limits.HasPullback.comp_left_left_iff_of_isIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} {X' : C} (i : X' ⟶ X)
[CategoryTheory.IsIso i],
CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp i f) g ↔ CategoryTheory.Limits.HasPullback f g | null | true |
TopHom._sizeOf_1 | Mathlib.Order.Hom.Bounded | {α : Type u_6} → {β : Type u_7} → {inst : Top α} → {inst_1 : Top β} → [SizeOf α] → [SizeOf β] → TopHom α β → ℕ | null | false |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.erase_getElem._proof_1_3 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} (l : List α), 1 ≤ l.length → 0 < l.length | null | false |
Lean.Elab.Tactic.Omega.Justification.tidy? | Lean.Elab.Tactic.Omega.Core | {s : Lean.Omega.Constraint} →
{c : Lean.Omega.Coeffs} →
Lean.Elab.Tactic.Omega.Justification s c →
Option ((s' : Lean.Omega.Constraint) × (c' : Lean.Omega.Coeffs) × Lean.Elab.Tactic.Omega.Justification s' c') | Wrapping for `Justification.tidy` when `tidy?` is nonempty. | true |
Lean.Meta.Tactic.TryThis.TryThisInfo.mk.inj | Lean.Meta.TryThis | ∀ {edit : Lean.Lsp.TextEdit} {codeActionTitle : String} {suggestion : Lean.Meta.Tactic.TryThis.Suggestion}
{edit_1 : Lean.Lsp.TextEdit} {codeActionTitle_1 : String} {suggestion_1 : Lean.Meta.Tactic.TryThis.Suggestion},
{ edit := edit, codeActionTitle := codeActionTitle, suggestion := suggestion } =
{ edit := ... | null | true |
Function.support_subset_iff | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {s : Set ι},
Function.support f ⊆ s ↔ ∀ (x : ι), f x ≠ 0 → x ∈ s | null | true |
Subgroup.normalClosure_eq_bot_iff._simp_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {s : Set G}, (Subgroup.normalClosure s = ⊥) = (s ⊆ {1}) | null | false |
_private.Lean.Util.Recognizers.0.Lean.Expr.name?.match_1 | Lean.Util.Recognizers | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((us : List Lean.Level) → motive (Lean.Expr.const `Lean.Name.anonymous us)) →
((us : List Lean.Level) →
(n : Lean.Expr) →
(s : String) →
motive (((Lean.Expr.const `Lean.Name.str us).app n).app (Lean.Expr.lit (Lean.Litera... | null | false |
CategoryTheory.PresheafOfGroups.OneCochain.instGroup._proof_10 | Mathlib.CategoryTheory.Sites.NonabelianCohomology.H1 | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {G : CategoryTheory.Functor Cᵒᵖ GrpCat} {I : Type u_4}
{U : I → C} (x : CategoryTheory.PresheafOfGroups.OneCochain G U), x⁻¹ * x = 1 | null | false |
List.kextract_eq_dlookup_kerase | Mathlib.Data.List.Sigma | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (l : List (Sigma β)),
List.kextract a l = (List.dlookup a l, List.kerase a l) | null | true |
Vector.eraseIdx_set_eq | Init.Data.Vector.Erase | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {a : α} {h : i < n}, (xs.set i a h).eraseIdx i h = xs.eraseIdx i h | null | true |
SimpleGraph.TripartiteFromTriangles.Graph.in₁₂_iff | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)} {b : β} {c : γ},
(SimpleGraph.TripartiteFromTriangles.graph t).Adj (Sum3.in₁ b) (Sum3.in₂ c) ↔ ∃ a, (a, b, c) ∈ t | null | true |
MeasureTheory.SimpleFunc.measurable | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
(f : MeasureTheory.SimpleFunc α β), Measurable ⇑f | A simple function is measurable | true |
ProbabilityTheory.memLp_id_gaussianReal' | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (p : ENNReal), p ≠ ⊤ → MeasureTheory.MemLp id p (ProbabilityTheory.gaussianReal μ v) | All the moments of a real Gaussian distribution are finite. That is, the identity is in Lp for
all finite `p`. | true |
IsBoundedBilinearMap.smul_right | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : Semiring 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 F] [inst_5 : SeminormedAddCommGroup G]
[inst_6 : Module 𝕜 G] {f : E × F → G},
IsBoundedBilinearMap 𝕜 f → ∀ (c : �... | null | true |
Multiset.find?_add._proof_2 | Mathlib.Data.Multiset.Find | ∀ {α : Type u_1} (p : α → Prop) (s t : Multiset α), {x | x ∈ s ∧ p x} ⊆ {x | x ∈ s + t ∧ p x} | null | false |
Lean.Elab.Term.Do.Code.brecOn_4.eq | Lean.Elab.Do.Legacy | ∀ {motive_1 : Lean.Elab.Term.Do.Code → Sort u}
{motive_2 : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u}
{motive_3 : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Sort u}
{motive_4 : List (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u}
{motive_5 : List (Lean.Elab.Term.Do.A... | null | true |
Algebra.Extension.Hom.noConfusionType | Mathlib.RingTheory.Extension.Basic | Sort u_4 →
{R : Type u} →
{S : Type v} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{P : Algebra.Extension R S} →
{R' : Type u_1} →
{S' : Type u_2} →
[inst_3 : CommRing R'] →
[inst_4... | null | false |
_private.Mathlib.Probability.Distributions.Fernique.0.ProbabilityTheory.Fernique.lintegral_closedBall_sdiff_exp_logRatio_mul_sq_le._simp_1_4 | Mathlib.Probability.Distributions.Fernique | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
CategoryTheory.Limits.MonoCoprod.mono_map'_of_injective | Mathlib.CategoryTheory.Limits.MonoCoprod | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Limits.MonoCoprod C] {I : Type u_2}
{J : Type u_3} (X : I → C) (ι : J → I),
Function.Injective ι →
∀ [inst_2 : CategoryTheory.Limits.HasCoproduct (X ∘ ι)] [inst_3 : CategoryTheory.Limits.HasCoproduct X]
[CategoryTheory.Limits.H... | null | true |
instPowInt32Nat | Init.Data.SInt.Basic | Pow Int32 ℕ | null | true |
FunLike.coeAddMonoidHom | Mathlib.Algebra.Group.FunLike | (F : Type u_1) →
(α : Type u_2) →
(β : Type u_3) →
[inst : FunLike F α β] →
[inst_1 : AddZero F] → [inst_2 : AddZeroClass β] → [IsZeroApply F α β] → [IsAddApply F α β] → F →+ α → β | Coercion as an additive monoid homomorphism. | true |
Finset.image_eq_iff_eq_preimage | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β}
(hf : Function.Bijective f), Finset.image f s = t ↔ s = t.preimage f ⋯ | null | true |
continuous_ofDual | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X], Continuous ⇑OrderDual.ofDual | null | true |
Std.Http.Status.tooManyRequests.elim | Std.Http.Data.Status | {motive : Std.Http.Status → Sort u} →
(t : Std.Http.Status) → t.ctorIdx = 49 → motive Std.Http.Status.tooManyRequests → motive t | null | false |
Lean.Lsp.LeanFileProgressProcessingInfo.ctorIdx | Lean.Data.Lsp.Extra | Lean.Lsp.LeanFileProgressProcessingInfo → ℕ | null | false |
CategoryTheory.Regular.hasCoequalizer_of_isKernelPair | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Regular C] {X Y Z : C} {f : X ⟶ Y}
{g₁ g₂ : Z ⟶ X}, CategoryTheory.IsKernelPair f g₁ g₂ → CategoryTheory.Limits.HasCoequalizer g₁ g₂ | null | true |
NumberField.InfinitePlace.mkReal._proof_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] (φ : { φ // NumberField.ComplexEmbedding.IsReal φ }),
∃ φ_1, NumberField.ComplexEmbedding.IsReal φ_1 ∧ NumberField.InfinitePlace.mk φ_1 = NumberField.InfinitePlace.mk ↑φ | null | false |
Poly.instAddCommGroup._proof_4 | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} (x : Poly α), x + 0 = x | null | false |
Lean.Doc.Parser.instInhabitedInlineCtxt.default | Lean.DocString.Parser | Lean.Doc.Parser.InlineCtxt | null | true |
Lean.Meta.Sym.AlphaShareCommon.State.mk.injEq | Lean.Meta.Sym.AlphaShareCommon | ∀ (set set_1 : Lean.PHashSet Lean.Meta.Sym.AlphaKey), ({ set := set } = { set := set_1 }) = (set = set_1) | null | true |
List.decidableBEx._proof_2 | Init.Data.List.Basic | ∀ {α : Type u_1} (p : α → Prop) (x : α) (xs : List α), p x → ∃ x_1 ∈ x :: xs, p x_1 | null | false |
MeasureTheory.Filtration.HasLimitProcess.smul | Mathlib.Probability.Process.LimitProcess | ∀ {ι : Type u_1} {Ω : Type u_2} {E : Type u_3} [inst : Preorder ι] {mΩ : MeasurableSpace Ω}
[inst_1 : TopologicalSpace E] {P : MeasureTheory.Measure Ω} {𝓕 : MeasureTheory.Filtration ι mΩ} {X : ι → Ω → E}
{G : Type u_6} [inst_2 : SMul G E] [ContinuousConstSMul G E] (c : G),
MeasureTheory.Filtration.HasLimitProces... | null | true |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.JoinPoints.3948291228._hygCtx._hyg.2 | Lean.Compiler.LCNF.JoinPoints | IO Unit | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.namedPattern._regBuiltin.Lean.Parser.Term.namedPattern.declRange_5 | Lean.Parser.Term | IO Unit | null | false |
Std.Http.Internal.Mock.Client._sizeOf_inst | Std.Http.Transport | SizeOf Std.Http.Internal.Mock.Client | null | false |
CategoryTheory.Limits.hasCokernel_comp_iso | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.IsIso g],
CategoryTheory.Limits.HasCokernel (CategoryTheory.CategoryStruct.comp f g) | null | true |
MulOpposite.instWeakPseudoEMetricSpace._proof_1 | Mathlib.Topology.EMetricSpace.MulOpposite | ∀ {α : Type u_1} [inst : TopologicalSpace α], Topology.IsInducing ⇑MulOpposite.opHomeomorph.symm | null | false |
Polynomial.toFinsupp_mul | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a b : Polynomial R), (a * b).toFinsupp = a.toFinsupp * b.toFinsupp | null | true |
codisjoint_top_right._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, Codisjoint a ⊤ = True | null | false |
Std.DTreeMap.Internal.Impl.entryAtIdxD.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (x : ℕ) (x_1 : (a : α) × β a) (size : ℕ) (k : α) (v : β k)
(l r : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k v l r).entryAtIdxD x x_1 =
match compare x l.size with
| Ordering.lt => l.entryAtIdxD x x_1
| Ordering.eq => ⟨k, v⟩
| Ordering.g... | null | true |
Subgroup.instMulDistribMulActionSubtypeMemNormalizerCoe._proof_4 | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (r : ↥(Subgroup.normalizer ↑H)) (x y : ↥H),
r • (x * y) = r • x * r • y | null | false |
TotallyDisconnectedSpace.continuousMapEquivOfConnectedSpace._proof_3 | Mathlib.Topology.Connected.TotallyDisconnected | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [TotallyDisconnectedSpace Y]
[inst_3 : ConnectedSpace X] (f : C(X, Y)), { toFun := fun x => f (Classical.arbitrary X), continuous_toFun := ⋯ } = f | null | false |
Std.HashMap.getKey?_eq_some_getKeyD | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α}, a ∈ m → m.getKey? a = some (m.getKeyD a fallback) | null | true |
_private.Lean.Parser.Module.0.Lean.Parser.Module.updateTokens.match_1 | Lean.Parser.Module | (motive : Except String Lean.Parser.TokenTable → Sort u_1) →
(x : Except String Lean.Parser.TokenTable) →
((tables : Lean.Parser.TokenTable) → motive (Except.ok tables)) →
((a : String) → motive (Except.error a)) → motive x | null | false |
Std.Irrefl.recOn | Init.Core | {α : Sort u} →
{r : α → α → Prop} →
{motive : Std.Irrefl r → Sort u_1} → (t : Std.Irrefl r) → ((irrefl : ∀ (a : α), ¬r a a) → motive ⋯) → motive t | null | false |
SemiNormedGrp.Hom.neg | Mathlib.Analysis.Normed.Group.SemiNormedGrp | {M N : SemiNormedGrp} → Neg (M ⟶ N) | null | true |
CategoryTheory.MorphismProperty.instFaithfulArrowArrowForget | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P Q W : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] [inst_2 : W.IsMultiplicative],
(CategoryTheory.MorphismProperty.Arrow.forget P Q W).Faithful | null | true |
CategoryTheory.Functor.coconeTypesEquiv._proof_3 | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J (Type u_1))
(c : CategoryTheory.Limits.Cocone F) {j j' : J} (f : j ⟶ j'),
⇑(CategoryTheory.ConcreteCategory.hom (c.ι.app j')) ∘ ⇑(CategoryTheory.ConcreteCategory.hom (F.map f)) =
⇑(CategoryTheory.ConcreteCategory.hom (c... | null | false |
CategoryTheory.Limits.isLimitConeOfCoconeUnop_lift | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) {c : CategoryTheory.Limits.Cocone F.unop}
(hc : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cone F),
(CategoryTheory.Limits.isLimitConeOfCo... | null | true |
Std.IO.Process.instReprResourceUsageStats | Std.Async.Process | Repr Std.IO.Process.ResourceUsageStats | null | true |
IsDedekindDomain.HeightOneSpectrum._sizeOf_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | {R : Type u_1} → {inst : CommRing R} → [SizeOf R] → IsDedekindDomain.HeightOneSpectrum R → ℕ | null | false |
Finsupp.instAddMonoid._proof_1 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_2} [inst : AddMonoid M] (a b c : ι →₀ M), a + b + c = a + (b + c) | null | false |
CategoryTheory.regularTopology.mapToEqualizer._proof_4 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (P : CategoryTheory.Functor Cᵒᵖ (Type u_1)) {W X B : C}
(f : X ⟶ B) (g₁ g₂ : W ⟶ X),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
∀ (t : P.obj (Opposite.op B)),
(CategoryTheory.ConcreteCategory.hom (P.map... | null | false |
CategoryTheory.evaluationAdjunctionLeft_unit_app_app | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (X : CategoryTheory.Functor C D)
(x : C),
((CategoryTheory.evaluationAdjunctionLeft D c).unit.app X).app x = Ca... | null | true |
Language.leftQuotient_append | Mathlib.Computability.MyhillNerode | ∀ {α : Type u} (L : Language α) (x y : List α), L.leftQuotient (x ++ y) = (L.leftQuotient x).leftQuotient y | null | true |
ContinuousMap.Homotopic.comp | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} {Z : Type w} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {g₀ g₁ : C(Y, Z)} {f₀ f₁ : C(X, Y)},
g₀.Homotopic g₁ → f₀.Homotopic f₁ → (g₀.comp f₀).Homotopic (g₁.comp f₁) | null | true |
exteriorPower.map_injective | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {n : ℕ} {M : Type u_1} {N : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f : M →ₗ[R] N} (g : N →ₗ[R] M),
g ∘ₗ f = LinearMap.id → Function.Injective ⇑(exteriorPower.map n f) | If a linear map has a retraction, then the map it induces on exterior powers is injective. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.