name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FreeGroup.instOne | Mathlib.GroupTheory.FreeGroup.Basic | {α : Type u} → One (FreeGroup α) | null | true |
AddGroupNorm.toAddGroupSeminorm | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} → [inst : AddGroup G] → AddGroupNorm G → AddGroupSeminorm G | null | true |
QuadraticMap.toBilinHom._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.Basis | ∀ {R : Type u_1} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N] (S : Type u_2)
[inst_3 : CommSemiring S] [inst_4 : Algebra S R] [inst_5 : Module S N] [IsScalarTower S R N], SMulCommClass R S N | null | false |
_private.Mathlib.Combinatorics.Nullstellensatz.0.MvPolynomial.Alon.of_mem_P_support._simp_1_2 | Mathlib.Combinatorics.Nullstellensatz | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic.0.CategoryTheory.WithInitial.opEquiv.match_5.splitter | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | (C : Type u_2) →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{x y : (CategoryTheory.WithInitial C)ᵒᵖ} →
(motive : (x ⟶ y) → Sort u_3) →
(x_1 : x ⟶ y) → ((f : Opposite.unop y ⟶ Opposite.unop x) → motive (Opposite.op f)) → motive x_1 | null | true |
mfderivWithin_id | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {x : M},
UniqueMDiffAt[s]... | null | true |
Subgroup.isComplement_iff_existsUnique_mul_inv_mem | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {S T : Set G}, Subgroup.IsComplement S T ↔ ∀ (g : G), ∃! t, g * (↑t)⁻¹ ∈ S | null | true |
_private.Lean.Compiler.LCNF.Simp.Main.0.Lean.Compiler.LCNF.Simp.inlineApp?.match_1 | Lean.Compiler.LCNF.Simp.Main | (motive : Option Lean.Compiler.LCNF.Simp.InlineCandidateInfo → Sort u_1) →
(__x : Option Lean.Compiler.LCNF.Simp.InlineCandidateInfo) →
((info : Lean.Compiler.LCNF.Simp.InlineCandidateInfo) → motive (some info)) →
((x : Option Lean.Compiler.LCNF.Simp.InlineCandidateInfo) → motive x) → motive __x | null | false |
Lean.Grind.Linarith.instBEqPoly.beq | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Bool | null | true |
catalan_succ | Mathlib.Combinatorics.Enumerative.Catalan.Basic | ∀ (n : ℕ), catalan (n + 1) = ∑ i, catalan ↑i * catalan (n - ↑i) | null | true |
Convexity.ConvexSpace.AffineMap.instDistribMulActionOfSMulCommClass | Mathlib.Geometry.Convex.AffineMap.Module | {R : Type u_1} →
{S : Type u_2} →
{X : Type u_3} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : PartialOrder R] →
[inst_2 : IsStrictOrderedRing R] →
[inst_3 : Convexity.ConvexSpace R X] →
[inst_4 : AddCommMonoid M] →
[inst_5 :... | null | true |
Lean.Lsp.InlayHintTooltip.recOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintTooltip → Sort u} →
(t : Lean.Lsp.InlayHintTooltip) →
((text : String) → motive (Lean.Lsp.InlayHintTooltip.plaintext text)) →
((markup : Lean.Lsp.MarkupContent) → motive (Lean.Lsp.InlayHintTooltip.markdown markup)) → motive t | null | false |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.Z | Mathlib.CategoryTheory.MorphismProperty.Factorization | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W₁ W₂ : CategoryTheory.MorphismProperty C} →
W₁.FunctorialFactorizationData W₂ → CategoryTheory.Functor (CategoryTheory.Arrow C) C | the intermediate objects in the factorizations | true |
LinearMap.finite_iff_of_bijective | Mathlib.RingTheory.Finiteness.Basic | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : Type u_6}
{P : Type u_5} [inst_3 : Semiring S] [inst_4 : AddCommMonoid P] [inst_5 : Module S P] {σ : R →+* S}
[RingHomSurjective σ] (f : M →ₛₗ[σ] P), Function.Bijective ⇑f → (Module.Finite R M ↔ Module.Finite S... | null | true |
CategoryTheory.Over.lift._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (D : CategoryTheory.Functor J T) {X : T}
(s : D ⟶ (CategoryTheory.Functor.const J).obj X) {X_1 Y : J} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (D.map f) (CategoryTheory.Over.mk (s... | null | false |
ContinuousLinearEquiv.toContinuousAffineEquiv_toContinuousAffineMap | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} [inst : Ring k] {E : Type u_10} {F : Type u_11} [inst_1 : AddCommGroup E] [inst_2 : Module k E]
[inst_3 : TopologicalSpace E] [inst_4 : AddCommGroup F] [inst_5 : Module k F] [inst_6 : TopologicalSpace F]
(L : E ≃L[k] F), L.toContinuousAffineEquiv.toContinuousAffineMap = (↑L).toContinuousAffineMap | null | true |
_private.Lean.Util.HasConstCache.0.Lean.HasConstCache.containsUnsafe.match_1 | Lean.Util.HasConstCache | {declNames : Array Lean.Name} →
(motive : Lean.HasConstCache declNames → Sort u_1) →
(x : Lean.HasConstCache declNames) →
((cache : Std.HashMap.Raw Lean.Expr Bool) → motive { cache := cache }) → motive x | null | false |
_private.Lean.Meta.Eqns.0.Lean.Meta.shouldGenerateEqnThms.match_1 | Lean.Meta.Eqns | (motive : Option Lean.AsyncConstantInfo → Sort u_1) →
(x : Option Lean.AsyncConstantInfo) →
((name : Lean.Name) →
(sig : Task Lean.ConstantVal) →
(constInfo : Task Lean.ConstantInfo) →
motive (some { name := name, kind := Lean.ConstantKind.defn, sig := sig, constInfo := constInfo }))... | null | false |
CommSemiRingCat.limitCommSemiring._aux_8 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J CommSemiRingCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections] →
CommSemiring ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections →
ℕ →
... | null | false |
CategoryTheory.Limits.WidePushout.arrow_ι_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C}
(arrows : (j : J) → objs j ⟶ B) [inst_1 : CategoryTheory.Limits.HasWidePullback B objs arrows] (j : J) {Z : C}
(h : Z ⟶ CategoryTheory.Limits.widePullback B objs arrows),
CategoryTheory.CategoryStruct.comp
(Category... | null | false |
_private.Std.Sat.AIG.CachedGatesLemmas.0.Std.Sat.AIG.imp_as_aig | Std.Sat.AIG.CachedGatesLemmas | ∀ (a b : Bool), (!(a && !b)) = (!a || b) | Encoding of implication as boolean expression in AIG form.
| true |
LieIdeal.incl_injective | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
Function.Injective ⇑I.incl | null | true |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.advanceAfterHeaders.match_1 | Std.Http.Protocol.H1 | (motive :
(dir : Std.Http.Protocol.H1.Direction) →
Std.Http.Protocol.H1.Reader.State dir →
Std.Http.Protocol.H1.Machine dir → Std.Http.Protocol.H1.Machine dir → Sort u_1) →
(dir : Std.Http.Protocol.H1.Direction) →
(nextState : Std.Http.Protocol.H1.Reader.State dir) →
(machine machine_1 : S... | null | false |
CategoryTheory.Functor.Fiber.instIsHomLiftIdMapFiberInclusion | Mathlib.CategoryTheory.FiberedCategory.Fiber | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {a b : p.Fiber S} (φ : a ⟶ b),
p.IsHomLift (CategoryTheory.CategoryStruct.id S) (CategoryTheory.Functor.Fiber.fiberInclusion.map φ) | null | true |
Lean.Macro.Context.recOn | Init.Prelude | {motive : Lean.Macro.Context → Sort u} →
(t : Lean.Macro.Context) →
((methods : Lean.Macro.MethodsRef) →
(quotContext : Lean.Name) →
(currMacroScope : Lean.MacroScope) →
(currRecDepth maxRecDepth : ℕ) →
(ref : Lean.Syntax) →
motive
{ me... | null | false |
NumberField.instIsLocalizedModuleIntSubtypeMemSubmoduleRingOfIntegersCoeToSubmoduleValFractionalIdealNonZeroDivisorsRestrictScalarsSubtype | Mathlib.NumberTheory.NumberField.FractionalIdeal | ∀ (K : Type u_1) [inst : Field K] [NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
IsLocalizedModule (nonZeroDivisors ℤ) (↑ℤ (↑↑I).subtype) | null | true |
CauchySeq.add_const | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3}
[inst_3 : Preorder ι] {u : ι → α} {x : α}, CauchySeq u → CauchySeq fun n => u n + x | null | true |
Plausible.Random | Plausible.Random | (Type u → Type u_1) → Type u → Type (max (max 1 u) u_1) | `Random m α` gives us machinery to generate values of type `α` in the monad `m`.
Note that `m` is a parameter as some types may only be sampleable with access to a certain monad. | true |
TensorProduct.mapOfCompatibleSMul._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ (R : Type u_3) [inst : CommSemiring R] (A : Type u_4) (M : Type u_1) (N : Type u_2) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [inst_5 : CommSemiring A] [inst_6 : Module A M]
[inst_7 : Module A N] [inst_8 : SMulCommClass R A M] [inst_9 : TensorProduct.Compati... | null | false |
AnalyticAt.analyticWithinAt | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {s : Set E} {x : E},
AnalyticAt 𝕜 f x → AnalyticWithinAt 𝕜 f s x | null | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.sup | Mathlib.CategoryTheory.Presentable.Directed | {J : Type w} →
[inst : CategoryTheory.SmallCategory J] →
{κ : Cardinal.{w}} →
[Fact κ.IsRegular] →
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ →
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ →
CategoryTheory.IsCardinalFiltered... | The union of two `κ`-bounded diagrams. | true |
Submodule.orderIsoOfAlgebraMapSurjective._proof_5 | Mathlib.Algebra.Algebra.Tower | ∀ {R : Type u_3} {S : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : AddCommGroup M]
[inst_3 : Algebra R S] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M]
(h : Function.Surjective ⇑(algebraMap R S)) {a b : Submodule S M},
{ toFun := fun N => Submodule.restrict... | null | false |
Ordnode.eraseMax.valid | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α}, t.Valid → t.eraseMax.Valid | null | true |
Module.End.hasEigenvalue_of_isRoot | Mathlib.LinearAlgebra.Eigenspace.Minpoly | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} [IsDomain R] [Module.Finite R M], (minpoly R f).IsRoot μ → f.HasEigenvalue μ | null | true |
continuousOn_cfcₙ_nnreal_setProd | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {A : Type u_2} [inst : NonUnitalNormedRing A] [inst_1 : StarRing A] [inst_2 : NormedSpace ℝ A]
[inst_3 : IsScalarTower ℝ A A] [inst_4 : SMulCommClass ℝ A A] [ContinuousStar A]
[inst_6 : NonUnitalIsometricContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_7 : PartialOrder A]
[inst_8 : StarOrderedRing A] [inst... | Let `s : Set ℝ≥0` be a compact set and consider pairs `(f, a) : (ℝ≥0 → ℝ≥0) × A` where `f` is
continuous on `s`, maps zero to itself, `spectrum ℝ≥0 a ⊆ s` and `0 ≤ a`.
Then `cfcₙ` is jointly continuous in both variables (i.e., continuous in its uncurried form) on this
set of pairs when the function space is equipped w... | true |
CategoryTheory.Pseudofunctor.map₂_left_unitor_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b) {Z : self.obj a ⟶ self.obj b} (h : self.map f ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom) h ... | null | true |
FractionalIdeal.right_inverse_eq | Mathlib.RingTheory.FractionalIdeal.Inverse | ∀ (K : Type u_1) [inst : Field K] {R₁ : Type u_2} [inst_1 : CommRing R₁] [inst_2 : IsDomain R₁] [inst_3 : Algebra R₁ K]
[inst_4 : IsFractionRing R₁ K] (I J : FractionalIdeal (nonZeroDivisors R₁) K), I * J = 1 → J = I⁻¹ | `I⁻¹` is the inverse of `I` if `I` has an inverse. | true |
Lean.Elab.Term.elabNamedPattern | Lean.Elab.App | Lean.Elab.Term.TermElab | null | true |
CategoryTheory.Limits.IsInitial.ofBinaryCoproductDisjointOfIsColimitOfIsLimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : C}
[CategoryTheory.Limits.BinaryCoproductDisjoint X Y] {c : CategoryTheory.Limits.BinaryCofan X Y}
(hc : CategoryTheory.Limits.IsColimit c) {s : CategoryTheory.Limits.PullbackCone c.inl c.inr}
(hs : CategoryTheory.Limits.IsLimit s), Nonempty (C... | null | false |
CategoryTheory.heq_eqToHom_comp_iff._simp_1 | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z Z' : C} (f : Y ⟶ X) (g : Z ⟶ Z') (h : W = Y),
(g ≍ CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h) f) = (g ≍ f) | null | false |
CategoryTheory.Limits.IsColimit.pushoutCoconeEquivBinaryCofanInverse._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
{c : CategoryTheory.Limits.BinaryCofan (CategoryTheory.Under.mk f) (CategoryTheory.Under.mk g)}
(hc : CategoryTheory.Limits.IsColimit c)
(s : CategoryTheory.Limits.PushoutCocone (CategoryTheory.Under.mk f).hom (Cate... | null | false |
DFinsupp.isScalarTower | Mathlib.Data.DFinsupp.Module | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} {δ : Type u_1} [inst : (i : ι) → Zero (β i)]
[inst_1 : (i : ι) → SMulZeroClass γ (β i)] [inst_2 : (i : ι) → SMulZeroClass δ (β i)] [inst_3 : SMul γ δ]
[∀ (i : ι), IsScalarTower γ δ (β i)], IsScalarTower γ δ (Π₀ (i : ι), β i) | null | true |
OrderAddMonoidIso.toMultiplicativeRight._proof_1 | Mathlib.Algebra.Order.Hom.TypeTags | ∀ {G : Type u_2} {H : Type u_1} [inst : CommMonoid G] [inst_1 : PartialOrder G] [inst_2 : AddCommMonoid H]
[inst_3 : PartialOrder H] (e : Additive G ≃+o H) {a b : G},
(AddEquiv.toMultiplicativeRight e.toAddEquiv).toFun a ≤ (AddEquiv.toMultiplicativeRight e.toAddEquiv).toFun b ↔ a ≤ b | null | false |
DFinsupp.single_smul | Mathlib.Data.DFinsupp.Module | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → SMulZeroClass γ (β i)] {i : ι} (c : γ) (x : β i), (fun₀ | i => c • x) = c • fun₀ | i => x | null | true |
CategoryTheory.SimplicialObject.IsCoskeletal.isUniversalOfIsRightKanExtension | Mathlib.AlgebraicTopology.SimplicialObject.Coskeletal | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(X : CategoryTheory.SimplicialObject C) →
(n : ℕ) →
[X.IsCoskeletal n] →
CategoryTheory.CostructuredArrow.IsUniversal
(CategoryTheory.SimplicialObject.Truncated.rightExtensionInclusion X n) | If `X` is `n`-coskeletal, then `Truncated.rightExtensionInclusion X n` is a terminal object in
the category `RightExtension (Truncated.inclusion n).op (Truncated.inclusion.op ⋙ X)`. | true |
CategoryTheory.GrothendieckTopology.plusFunctorWhiskerLeftIso_inv_app | Mathlib.CategoryTheory.Sites.CompatiblePlus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} E]
[inst_3 :
∀ (J : CategoryTheory.Limits.MulticospanShape),
CategoryTheory.Limits... | null | true |
Lagrange.funEquivDegreeLT._proof_4 | Mathlib.LinearAlgebra.Lagrange | ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : DecidableEq ι] {s : Finset ι} {v : ι → F}
(hvs : Set.InjOn v ↑s),
Function.RightInverse (fun r => ⟨(Lagrange.interpolate s v) fun x => if hx : x ∈ s then r ⟨x, hx⟩ else 0, ⋯⟩)
fun f i => Polynomial.eval (v ↑i) ↑f | null | false |
IsPrimitiveRoot.one_left_iff | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ}, IsPrimitiveRoot 1 k ↔ k = 1 | null | true |
ProbabilityTheory.bernoulliMeasure_apply | Mathlib.Probability.Distributions.Bernoulli | ∀ {X : Type u_1} [inst : MeasurableSpace X] {x y : X} (p : ↑unitInterval) {s : Set X},
MeasurableSet s →
∀ [inst_1 : DecidablePred fun x => x ∈ s],
(ProbabilityTheory.bernoulliMeasure x y p) s =
if x ∈ s then if y ∈ s then 1 else ↑(unitInterval.toNNReal p)
else if y ∈ s then ↑(unitInterval.t... | null | true |
Set.Nonempty.nsmul | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddMonoid α] {s : Set α}, s.Nonempty → ∀ {n : ℕ}, (n • s).Nonempty | null | true |
Submonoid.topologicalClosure._proof_2 | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Monoid M] (s : Submonoid M), 1 ∈ closure ↑s | null | false |
IsValuativeTopology.continuousAt_valuation_of_ne_zero | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {R : Type u_1} {Γ₀ : Type u_3} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
[inst_2 : ValuativeRel R] [inst_3 : TopologicalSpace R] [IsValuativeTopology R] [v.Compatible]
[inst_6 : TopologicalSpace Γ₀] {x : R}, v x ≠ 0 → ContinuousAt (⇑v) x | A compatible valuation is continuous, at every point where it does
not vanish, for any topology on `Γ₀`. | true |
Lean.Meta.Match.Problem.mk.noConfusion | Lean.Meta.Match.Basic | {P : Sort u} →
{mvarId : Lean.MVarId} →
{vars : List Lean.Expr} →
{alts : List Lean.Meta.Match.Alt} →
{examples : List Lean.Meta.Match.Example} →
{mvarId' : Lean.MVarId} →
{vars' : List Lean.Expr} →
{alts' : List Lean.Meta.Match.Alt} →
{examples' :... | null | false |
RingCon.matrix | Mathlib.LinearAlgebra.Matrix.Ideal | {R : Type u_1} →
(n : Type u_2) → [inst : NonUnitalNonAssocSemiring R] → [inst_1 : Fintype n] → RingCon R → RingCon (Matrix n n R) | The ring congruence of matrices with entries related by `c`. | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.ofBitVec_toBitVec.match_1_1 | Init.Data.UInt.Lemmas | ∀ (motive : UInt16 → Prop) (x : UInt16),
(∀ (val : ℕ) (isLt : val < 2 ^ 16), motive { toBitVec := { toFin := ⟨val, isLt⟩ } }) → motive x | null | false |
IsLinearMap.mk'.congr_simp | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M] [inst_4 : Module R M₂] (f f_1 : M → M₂) (e_f : f = f_1)
(lin : IsLinearMap R f), IsLinearMap.mk' f lin = IsLinearMap.mk' f_1 ⋯ | null | true |
Std.TreeMap.getD_alter_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {fallback : β}
{f : Option β → Option β}, (t.alter k f).getD k fallback = (f t[k]?).getD fallback | null | true |
AddSubgroup.neg_subset_closure._simp_1 | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (S : Set G), (-S ⊆ ↑(AddSubgroup.closure S)) = True | null | false |
CategoryTheory.Functor.HomObj.mk.congr_simp | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F G : CategoryTheory.Functor C D} {A : CategoryTheory.Functor C (Type w)}
(app app_1 : (c : C) → A.obj c → (F.obj c ⟶ G.obj c)) (e_app : app = app_1)
(naturality :
∀ {c d : C} (f : c ⟶ d) (a :... | null | true |
Std.ExtTreeMap.size_insertIfNew_le | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, (t.insertIfNew k v).size ≤ t.size + 1 | null | true |
CategoryTheory.Mon.instHasLimitsOfShape | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type w} [inst : CategoryTheory.Category.{v_1, w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Mon C) | null | true |
AddMonoidHom.inl._proof_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_1) (N : Type u_2) [inst : AddZeroClass M] [inst_1 : AddZeroClass N], (0, 0) = (0, 0) | null | false |
CategoryTheory.Span.instCategory._proof_4 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C} {c c' : C}
(S : CategoryTheory.Span Wₗ Wᵣ c c'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id S.apex) S.r = S.r | null | false |
Stream'.map_eq | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Stream' α),
Stream'.map f s = Stream'.cons (f s.head) (Stream'.map f s.tail) | null | true |
_private.Mathlib.RingTheory.WittVector.Truncated.0._aux_Mathlib_RingTheory_WittVector_Truncated___macroRules__private_Mathlib_RingTheory_WittVector_Truncated_0_term𝕎_1 | Mathlib.RingTheory.WittVector.Truncated | Lean.Macro | null | false |
Lean.Language.ToSnapshotTree.mk | Lean.Language.Basic | {α : Type} → (α → Lean.Language.ToSnapshotTreeM Lean.Language.SnapshotTree) → Lean.Language.ToSnapshotTree α | null | true |
IsAddQuotientCoveringMap.monodromy_ext | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X} {G : Type u_4}
[inst_2 : AddGroup G] [inst_3 : AddAction G E] (hp : IsAddQuotientCoveringMap p G) {x y : X}
{γ γ' : Path.Homotopic.Quotient x y} (e : ↑(p ⁻¹' {x})),
⋯.monodromy γ e = ⋯.monodromy γ' e → ⋯.monodrom... | **Alias** of the forward direction of `IsAddQuotientCoveringMap.monodromy_ext_iff`. | true |
SSet.Subcomplex.PairingCore.IsInner.mk | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} {h : A.PairingCore},
(∀ (s : h.ι), h.index s ≠ 0) → (∀ (s : h.ι), h.index s ≠ Fin.last (h.dim s + 1)) → h.IsInner | null | true |
intervalIntegral.measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_le' | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {ι : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {c : E}
{l l' : Filter ℝ} {lt : Filter ι} {μ : MeasureTheory.Measure ℝ} {u v : ι → ℝ} [CompleteSpace E]
[l'.IsMeasurablyGenerated] [Filter.TendstoIxxClass Set.Ioc l l'],
StronglyMeasurableAtFilter f l' μ →
Fil... | **Fundamental theorem of calculus-1**, local version for any measure.
Let filters `l` and `l'` be related by `TendstoIxxClass Ioc`.
If `f` has a finite limit `c` at `l ⊓ ae μ`, where `μ` is a measure
finite at `l`, then `∫ x in u..v, f x ∂μ = μ (Ioc u v) • c + o(μ(Ioc u v))` as both
`u` and `v` tend to `l` so that `u ≤... | true |
NonUnitalSubsemiring.map._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(f : R →ₙ+* S) (s : NonUnitalSubsemiring R), 0 ∈ (AddSubmonoid.map (↑f) s.toAddSubmonoid).carrier | null | false |
CategoryTheory.Presieve.extend_agrees | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X Y : C}
{R : CategoryTheory.Presieve X} {x : CategoryTheory.Presieve.FamilyOfElements P R},
x.Compatible → ∀ {f : Y ⟶ X} (hf : R f), x.sieveExtend f ⋯ = x f hf | The extension of a family agrees with the original family. | true |
Lean.Parser.Command.opaque | Lean.Parser.Command | Lean.Parser.Parser | null | true |
Aesop.RuleResult.proved.noConfusion | Aesop.Search.Expansion | {P : Sort u} →
{newRapps newRapps' : Array Aesop.RappRef} →
Aesop.RuleResult.proved newRapps = Aesop.RuleResult.proved newRapps' → (newRapps = newRapps' → P) → P | null | false |
Lean.Meta.Ext.isExtTheorem | Lean.Meta.Tactic.Ext | Lean.Name → Lean.CoreM Bool | Returns `true` if `declName` is tagged with `[ext]` attribute. | true |
MeasureTheory.Measure.setIntegral_toReal_rnDeriv_eq_withDensity | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.SigmaFinite μ]
[MeasureTheory.SFinite ν] (s : Set α),
∫ (x : α) in s, (μ.rnDeriv ν x).toReal ∂ν = (ν.withDensity (μ.rnDeriv ν)).real s | null | true |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Alt.setBody.match_1 | Lean.Compiler.IR.Basic | (motive : Lean.IR.Alt → Lean.IR.FnBody → Sort u_1) →
(x : Lean.IR.Alt) →
(x_1 : Lean.IR.FnBody) →
((c : Lean.IR.CtorInfo) → (b b_1 : Lean.IR.FnBody) → motive (Lean.IR.Alt.ctor c b) b_1) →
((b b_1 : Lean.IR.FnBody) → motive (Lean.IR.Alt.default b) b_1) → motive x x_1 | null | false |
ZeroMemClass.coe_eq_zero._simp_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {A : Type u_3} {M₁ : Type u_4} [inst : SetLike A M₁] [inst_1 : Zero M₁] [hA : ZeroMemClass A M₁] {S' : A} {x : ↥S'},
(↑x = 0) = (x = 0) | null | false |
Lean.Try.Config.harder._default | Init.Try | Bool | null | false |
Subsemigroup.comap_comap | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Mul M] [inst_1 : Mul N] [inst_2 : Mul P] (S : Subsemigroup P)
(g : N →ₙ* P) (f : M →ₙ* N), Subsemigroup.comap f (Subsemigroup.comap g S) = Subsemigroup.comap (g.comp f) S | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.DistLEIntegral.0.norm_sub_le_integral_of_norm_deriv_le_of_le._simp_1_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.DistLEIntegral | ∀ {E : Type u_4} [inst : SeminormedAddCommGroup E] (a b : E), ‖a - b‖ = dist a b | null | false |
Std.TreeSet.ofList_singleton | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {k : α}, Std.TreeSet.ofList [k] cmp = ∅.insert k | null | true |
CategoryTheory.ActionCategory.stabilizerIsoEnd_symm_apply | Mathlib.CategoryTheory.Action | ∀ (M : Type u_1) [inst : Monoid M] {X : Type u} [inst_1 : MulAction M X] (x : X)
(f : CategoryTheory.End ((CategoryTheory.actionAsFunctor M X).elementsMk () x)),
(CategoryTheory.ActionCategory.stabilizerIsoEnd M x).symm f = ⟨f.asHom.hom, ⋯⟩ | null | true |
CategoryTheory.StructuredArrow.instFaithfulObjCompPost | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{B : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} B] (S : C) (F : CategoryTheory.Functor B C)
(G : CategoryTheory.Functor C D), (CategoryTheory.StructuredArrow.post S F G).Faithful | null | true |
Lean.Meta.Simp.Diagnostics.mk.noConfusion | Lean.Meta.Tactic.Simp.Types | {P : Sort u} →
{usedThmCounter triedThmCounter : Lean.PHashMap Lean.Meta.Origin ℕ} →
{congrThmCounter : Lean.PHashMap Lean.Name ℕ} →
{thmsWithBadKeys : Lean.PArray Lean.Meta.SimpTheorem} →
{usedThmCounter' triedThmCounter' : Lean.PHashMap Lean.Meta.Origin ℕ} →
{congrThmCounter' : Lean.PHas... | null | false |
PresheafOfModules.wellPowered | Mathlib.Algebra.Category.ModuleCat.Presheaf.Generator | ∀ {C₀ : Type u} [inst : CategoryTheory.SmallCategory C₀] (R₀ : CategoryTheory.Functor C₀ᵒᵖ RingCat),
CategoryTheory.WellPowered.{u, u, u + 1} (PresheafOfModules R₀) | null | true |
_private.Std.Http.Data.URI.Basic.0.Std.Http.URI.Query.get.match_1 | Std.Http.Data.URI.Basic | (motive : Option (Option Std.Http.URI.EncodedQueryParam) → Sort u_1) →
(x : Option (Option Std.Http.URI.EncodedQueryParam)) →
(Unit → motive none) →
(Unit → motive (some none)) →
((encoded : Std.Http.URI.EncodedQueryParam) → motive (some (some encoded))) → motive x | null | false |
QuaternionAlgebra.mk | Mathlib.Algebra.Quaternion | {R : Type u_1} → {a b c : R} → R → R → R → R → QuaternionAlgebra R a b c | null | true |
Lean.Lsp.CodeActionParams.mk.sizeOf_spec | Lean.Data.Lsp.CodeActions | ∀ (toWorkDoneProgressParams : Lean.Lsp.WorkDoneProgressParams) (toPartialResultParams : Lean.Lsp.PartialResultParams)
(textDocument : Lean.Lsp.TextDocumentIdentifier) (range : Lean.Lsp.Range) (context : Lean.Lsp.CodeActionContext),
sizeOf
{ toWorkDoneProgressParams := toWorkDoneProgressParams, toPartialResult... | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances.0.cfc_complex_eq_real._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {K : Type u_1} [inst : RCLike K] {z : K}, ((starRingEnd K) z = z) = (↑(RCLike.re z) = z) | null | false |
_private.Lean.Elab.ConfigEval.DeriveEvalConfigItem.0.Lean.Elab.ConfigEval.HandlerTrie.insert.match_1 | Lean.Elab.ConfigEval.DeriveEvalConfigItem | (motive : Option ℕ → Sort u_1) →
(x : Option ℕ) → ((idx : ℕ) → motive (some idx)) → ((x : Option ℕ) → motive x) → motive x | null | false |
HurwitzZeta.hurwitzEvenFEPair._proof_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | (1 + 1).AtLeastTwo | null | false |
CategoryTheory.Functor.descOfIsLeftKanExtension.congr_simp | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_5, u_5} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α α_1 : F ⟶ L.comp F') (... | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Nonsingular.0.SSet.N.existsUnique_of_le.match_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.Nonsingular | ∀ {X : SSet} {x y : X.N} (f₂ : { len := x.dim } ⟶ { len := y.dim })
(motive : CategoryTheory.Mono f₂ ∧ (CategoryTheory.ConcreteCategory.hom (X.map f₂.op)) y.simplex = x.simplex → Prop)
(x_1 : CategoryTheory.Mono f₂ ∧ (CategoryTheory.ConcreteCategory.hom (X.map f₂.op)) y.simplex = x.simplex),
(∀ (left : CategoryTh... | null | false |
_private.Mathlib.RingTheory.RingHom.QuasiFinite.0.RingHom.QuasiFinite.ofLocalizationSpanTarget._simp_1_1 | Mathlib.RingTheory.RingHom.QuasiFinite | ∀ {M : Type u_1} [inst : Monoid M] {n : M} {P : Submonoid M}, (Submonoid.powers n ≤ P) = (n ∈ P) | null | false |
Primrec.nat_bodd | Mathlib.Computability.Primrec.Basic | Primrec Nat.bodd | null | true |
_private.Mathlib.Analysis.Analytic.Basic.0.AnalyticWithinAt.congr_set._simp_1_1 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, (s ∈ nhdsWithin a s) = True | null | false |
NonUnitalSubsemiring.mem_iInf | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {ι : Sort u_1} {S : ι → NonUnitalSubsemiring R} {x : R},
x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i | null | true |
DoubleCentralizer.instModule._proof_1 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] {S : Type u_3}
[inst_5 : Semiring S] [inst_6 : Module S A] [inst_7 : SMulCommClass 𝕜 S A] [inst_8 : ContinuousConstSMul S... | null | false |
GeneralSchauderBasis.rec | Mathlib.Analysis.Normed.Module.Bases | {β : Type u_3} →
{𝕜 : Type u_4} →
{X : Type u_5} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup X] →
[inst_2 : NormedSpace 𝕜 X] →
{L : SummationFilter β} →
{motive : GeneralSchauderBasis β 𝕜 X L → Sort u} →
((basis : β → X)... | null | false |
PowerBasis.ofAdjoinEqTop_gen | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {K : Type u_1} {S : Type u_2} [inst : Field K] [inst_1 : CommRing S] [inst_2 : Algebra K S] {x : S}
(hx : IsIntegral K x) (hx' : K[x] = ⊤), (PowerBasis.ofAdjoinEqTop hx hx').gen = x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.