name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.ChosenPullback.hp₁._autoParam | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | Lean.Syntax | null | false |
PFun.fixInduction'._proof_1 | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {f : α →. β ⊕ α} {b : β} (a' : α) (h : b ∈ f.fix a') (b' : β),
(f a').get ⋯ = Sum.inl b' → ∃ (h : (f a').Dom), (f a').get h = Sum.inl b' | null | false |
Int.gcd_mul_right | Init.Data.Int.Gcd | ∀ (m n k : ℤ), (m * n).gcd (k * n) = m.gcd k * n.natAbs | null | true |
_private.Lean.Environment.0.Lean.importModules.match_4 | Lean.Environment | (motive : Lean.Plugin → Sort u_1) →
(x : Lean.Plugin) →
((path : System.FilePath) → (initFn? : Option String) → motive { path := path, initFn? := initFn? }) → motive x | null | false |
CoxeterSystem.isReflection_simple | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (i : B),
cs.IsReflection (cs.simple i) | null | true |
IsRealClosed.exists_eq_pow_of_nonneg | Mathlib.FieldTheory.IsRealClosed.Basic | ∀ {R : Type u} [inst : Field R] [IsRealClosed R] [inst_2 : LinearOrder R] [IsStrictOrderedRing R] {x : R},
0 ≤ x → ∀ {n : ℕ}, n ≠ 0 → ∃ r, x = r ^ n | null | true |
CategoryTheory.BasedNatIso.id_hom | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴),
(CategoryTheory.BasedNatIso.id F).hom = CategoryTheory.CategoryStruct.id F | null | true |
Primrec.of_eq | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {f g : α → σ},
Primrec f → (∀ (n : α), f n = g n) → Primrec g | null | true |
FirstOrder.Language.Symbols | Mathlib.ModelTheory.Basic | FirstOrder.Language → Type (max u v) | The type of symbols in a given language. | true |
ProbabilityTheory.Kernel.comap_map_comm | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5}
{mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel β γ) {f : α → β} {g : γ → δ}
(hf : Measurable f), Measurable g → (κ.map g).comap f hf = (κ.comap f hf).map g | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.iso_hom_naturality_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} (X : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] (S : Cat... | null | true |
SimpleGraph.IsUniversal.of_isIsolated_compl | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} {G : SimpleGraph V} {v : V}, Gᶜ.IsIsolated v → G.IsUniversal v | **Alias** of the forward direction of `SimpleGraph.isIsolated_compl_iff_isUniversal`. | true |
Convex.combo_interior_closure_subset_interior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E] {s : Set E},
Convex 𝕜 s → ∀ {a b : 𝕜}, 0 < a → 0 ≤ b → a + b = 1 → a • interior s + b • closure s ⊆ inte... | If `s` is a convex set, then `a • interior s + b • closure s ⊆ interior s` for all `0 < a`,
`0 ≤ b`, `a + b = 1`. See also `Convex.combo_interior_self_subset_interior` for a weaker version. | true |
Group.ofRightAxioms._proof_4 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Mul G] [inst_1 : Inv G] [inst_2 : One G],
(∀ (a b c : G), a * b * c = a * (b * c)) →
(∀ (a : G), a * 1 = a) → (∀ (a : G), a * a⁻¹ = 1) → (∀ (a : G), a⁻¹ * a = 1) → ∀ (a : G), 1 * a = a | null | false |
_private.Mathlib.Algebra.Group.Semiconj.Basic.0.SemiconjBy.inv_inv_symm_iff._simp_1_2 | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_3} [inst : InvolutiveInv G] {a b : G}, (a⁻¹ = b⁻¹) = (a = b) | null | false |
Lean.AssocList.brecOn.go | Lean.Data.AssocList | {α : Type u} →
{β : Type v} →
{motive : Lean.AssocList α β → Sort u_1} →
(t : Lean.AssocList α β) →
((t : Lean.AssocList α β) → Lean.AssocList.below t → motive t) → motive t ×' Lean.AssocList.below t | null | true |
RingPreordering.instHasIdealSupport | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {F : Type u_2} [inst : Field F] (P : RingPreordering F), P.HasIdealSupport | null | true |
CategoryTheory.FintypeCat.isoQuotientStabilizerOfIsConnected._proof_3 | Mathlib.CategoryTheory.Galois.Examples | ∀ {G : Type u_1} [inst : Group G] (X : Action FintypeCat G) (x : X.V.obj) [Fintype (G ⧸ MulAction.stabilizer G x)],
Finite (G ⧸ MulAction.stabilizer G x) | null | false |
Lean.CollectLevelMVars.State.visitedLevel | Lean.Util.CollectLevelMVars | Lean.CollectLevelMVars.State → Lean.LevelSet | null | true |
StarSubalgebra.range_le | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A),
Set.range ⇑(algebraMap R A) ⊆ ↑S | null | true |
CategoryTheory.ShortComplex.SnakeInput.h₃τ₁._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.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair S.v₁₂ 0) CategoryTheory.ShortComplex.π₁ | null | false |
BitVec.add_right_eq_self | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x + y = x ↔ y = 0#w | null | true |
Lean.Compiler.LCNF.ImpureType.object | Lean.Compiler.LCNF.Types | Lean.Expr | null | true |
_private.Mathlib.Order.TypeTags.0.WithTop.instRepr.match_1.splitter | Mathlib.Order.TypeTags | {α : Type u_1} →
(motive : WithTop α → Sort u_2) → (o : WithTop α) → (Unit → motive none) → ((a : α) → motive (some a)) → motive o | null | true |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.Const.insertMany.match_1 | Std.Data.DHashMap.Internal.Defs | {α : Type u_1} →
{β : Type u_2} → (motive : α × β → Sort u_3) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x | null | false |
_private.Lean.Meta.AbstractMVars.0.Lean.Meta.AbstractMVars.abstractLevelMVars.match_1 | Lean.Meta.AbstractMVars | (motive : Option Lean.Level → Sort u_1) →
(x : Option Lean.Level) → ((u : Lean.Level) → motive (some u)) → (Unit → motive none) → motive x | null | false |
Submonoid.map_comap_eq | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid N), Submonoid.map f (Submonoid.comap f S) = S ⊓ MonoidHom.mrange f | null | true |
AlgEquiv.piMulOpposite | Mathlib.Algebra.Algebra.Pi | (R : Type u_3) →
{ι : Type u_4} →
(A₁ : ι → Type u_5) →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → Semiring (A₁ i)] →
[inst_2 : (i : ι) → Algebra R (A₁ i)] → ((i : ι) → A₁ i)ᵐᵒᵖ ≃ₐ[R] (i : ι) → (A₁ i)ᵐᵒᵖ | The opposite of a direct product is isomorphic to the direct product of the opposites as
algebras. | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State.annotations | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State → Lean.PrettyPrinter.Delaborator.OptionsPerPos | null | true |
groupCohomology.mapShortComplexH2_id_comp_assoc | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A B C : Rep.{u_1, u, u} k G} (φ : A ⟶ B) (ψ : B ⟶ C)
{Z : CategoryTheory.ShortComplex (ModuleCat k)} (h : groupCohomology.shortComplexH2 C ⟶ Z),
CategoryTheory.CategoryStruct.comp
(groupCohomology.mapShortComplexH2 (MonoidHom.id G) (CategoryTheory.Categ... | null | true |
_private.Mathlib.Analysis.ODE.DiscreteGronwall.0.discrete_gronwall._proof_1_6 | Mathlib.Analysis.ODE.DiscreteGronwall | ∀ {b : ℕ → ℝ} {n₀ : ℕ}, (∀ n ≥ n₀, 0 ≤ b n) → ∀ ⦃n : ℕ⦄, ∀ i ∈ Finset.Ico n₀ n, 0 ≤ b i | null | false |
Finsupp.lcomapDomain._proof_1 | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] {β : Type u_3} (f : α → β) (hf : Function.Injective f)
(x y : β →₀ M), Finsupp.comapDomain f (x + y) ⋯ = Finsupp.comapDomain f x ⋯ + Finsupp.comapDomain f y ⋯ | null | false |
Polynomial.lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors' | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R} {t : R} {n : ℕ},
p ≠ 0 →
(∀ m ≤ n, ((⇑Polynomial.derivative)^[m] p).IsRoot t) →
(∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R) → n < Polynomial.rootMultiplicity t p | null | true |
Std.LawfulOrderLeftLeaningMin.of_eq | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Min α] [inst_2 : DecidableLE α],
(∀ (a b : α), a ⊓ b = if a ≤ b then a else b) → Std.LawfulOrderLeftLeaningMin α | null | true |
ByteSlice.contains | Std.Data.ByteSlice | ByteSlice → UInt8 → Bool | Checks if the byte slice contains a specific byte value.
Returns `true` if any byte in the slice equals the given value, `false` otherwise.
| true |
Stream'.Seq1.ret.eq_1 | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (a : α), Stream'.Seq1.ret a = (a, Stream'.Seq.nil) | null | true |
_private.Mathlib.Algebra.Tropical.Basic.0.MaxTropical.zero_ne_trop_coe.match_1_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} (x : R) (motive : 0 = MaxTropical.trop ↑x → Prop) (a : 0 = MaxTropical.trop ↑x), motive a | null | false |
SSet.Edge.edge | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | {X : SSet} → {x₀ x₁ : X.obj (Opposite.op { len := 0 })} → SSet.Edge x₀ x₁ → X.obj (Opposite.op { len := 1 }) | In a simplicial set, an edge from a vertex `x₀` to `x₁` is
a `1`-simplex with prescribed `0`-dimensional faces. | true |
CategoryTheory.Adjunction.fullyFaithfulROfCompIsoId | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{L : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor D C} → (L ⊣ R) → (R.comp L ≅ CategoryTheory.Functor.id D) → R.FullyFaithful | Given an adjunction `L ⊣ R`, if `R ⋙ L` is isomorphic to the identity functor, then `R` is
fully faithful.
| true |
finprod_le_finprod₀ | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_7} [inst : CommMonoidWithZero M] [inst_1 : PartialOrder M] [ZeroLEOneClass M]
[PosMulMono M] {f g : α → M},
Function.HasFiniteMulSupport f →
(∀ (a : α), 0 ≤ f a) → Function.HasFiniteMulSupport g → f ≤ g → ∏ᶠ (a : α), f a ≤ ∏ᶠ (a : α), g a | Monotonicity of `finprod`. See `finprod_le_finprod` for a variant where
`M` is an ordered `CommMonoid`. | true |
Lean.Meta.RefinedDiscrTree.Trie.pending | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {α : Type} → Lean.Meta.RefinedDiscrTree.Trie α → Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α) | Lazy entries that still have to be evaluated. | true |
AlgebraicGeometry.QuasiCompact.of_comp | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
[AlgebraicGeometry.QuasiCompact (CategoryTheory.CategoryStruct.comp f g)] [AlgebraicGeometry.QuasiSeparated g],
AlgebraicGeometry.QuasiCompact f | null | true |
CategoryTheory.Monad.beckAlgebraCoequalizer._proof_2 | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
(s :
CategoryTheory.Limits.Cofork (CategoryTheory.Monad.FreeCoequalizer.topMap X)
(CategoryTheory.Monad.FreeCoequalizer.bottomMap X)),
CategoryTheory.CategoryStruct.comp (T.map s.π.f) s.pt.a = Categ... | null | false |
CategoryTheory.Iso.isoCongr | Mathlib.CategoryTheory.HomCongr | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {X₁ Y₁ X₂ Y₂ : C} → (X₁ ≅ X₂) → (Y₁ ≅ Y₂) → (X₁ ≅ Y₁) ≃ (X₂ ≅ Y₂) | If `X` is isomorphic to `X₁` and `Y` is isomorphic to `Y₁`, then
there is a bijection between `X ≅ Y` and `X₁ ≅ Y₁`. | true |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Trivial.0.ValuativeRel.eq_trivialRel_of_compatible_one._simp_1_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] [inst_2 : Nontrivial R]
[inst_3 : NoZeroDivisors R] [inst_4 : DecidablePred fun x => x = 0] (x : R), (1 x ≤ 1) = True | null | false |
Lean.JsonNumber.mk.sizeOf_spec | Lean.Data.Json.Basic | ∀ (mantissa : ℤ) (exponent : ℕ),
sizeOf { mantissa := mantissa, exponent := exponent } = 1 + sizeOf mantissa + sizeOf exponent | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse._proof_7 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y Z : CategoryTheory.Functor C (CategoryTheory.Comon D)} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.IsComonHom
{ app := fun X_1 => ((Catego... | null | false |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZSpan.fundamentalDomain_measurableSet._simp_1_5 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
CategoryTheory.ObjectProperty.Nonempty.recOn | Mathlib.CategoryTheory.ObjectProperty.Basic | {C : Type u} →
[inst : CategoryTheory.CategoryStruct.{v, u} C] →
{P : CategoryTheory.ObjectProperty C} →
{motive : P.Nonempty → Sort u_1} → (t : P.Nonempty) → ((exists_prop : ∃ X, P X) → motive ⋯) → motive t | null | false |
MeasureTheory.Measure.conv_zero | Mathlib.MeasureTheory.Group.Convolution | ∀ {M : Type u_1} [inst : AddMonoid M] [inst_1 : MeasurableSpace M] (μ : MeasureTheory.Measure M), μ.conv 0 = 0 | Convolution of a measure μ with the zero measure returns the zero
measure. | true |
_private.Mathlib.Topology.Separation.Regular.0.RegularSpace.of_exists_mem_nhds_isClosed_subset._proof_1_1 | Mathlib.Topology.Separation.Regular | 1 ≠ 0 | null | false |
spectrum.subset_circle_of_unitary | Mathlib.Analysis.CStarAlgebra.Spectrum | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] {E : Type u_2} [inst_1 : NormedRing E] [inst_2 : StarRing E] [CStarRing E]
[inst_4 : NormedAlgebra 𝕜 E] [CompleteSpace E] {u : E}, u ∈ unitary E → spectrum 𝕜 u ⊆ Metric.sphere 0 1 | null | true |
IsGaloisGroup.of_mulEquiv | Mathlib.RingTheory.IsGaloisGroup.Defs | ∀ {G : Type u_1} {A : Type u_2} {B : Type u_4} [inst : Group G] [inst_1 : CommSemiring A] [inst_2 : Semiring B]
[inst_3 : Algebra A B] [inst_4 : MulSemiringAction G B] [hG : IsGaloisGroup G A B] {H : Type u_5} [inst_5 : Group H]
[inst_6 : MulSemiringAction H B] (e : H ≃* G), (∀ (h : H) (x : B), e h • x = h • x) → I... | null | true |
Lean.Server.RequestContext.rec | Lean.Server.Requests | {motive : Lean.Server.RequestContext → Sort u} →
((rpcSessions : Std.TreeMap UInt64 (IO.Ref Lean.Server.FileWorker.RpcSession) compare) →
(doc : Lean.Server.FileWorker.EditableDocument) →
(hLog : IO.FS.Stream) →
(initParams : Lean.Lsp.InitializeParams) →
(cancelTk : Lean.Server.Req... | null | false |
Classical.exists_or_forall_not | Init.Classical | ∀ {α : Sort u_1} (P : α → Prop), (∃ a, P a) ∨ ∀ (a : α), ¬P a | null | true |
Polynomial.UniversalFactorizationRing.factor₁_mul_factor₂ | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
↑(Polynomial.UniversalFactorizationRing.factor₁ m k hn p) *
↑(Polynomial.UniversalFactorizationRing.factor₂ m k hn p) =
↑(Polynomial.UniversalFactorizationRing.monicDegreeEq m k hn p) | null | true |
LinearMap.BilinForm.toMatrixAux_apply | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} (B : LinearMap.BilinForm R₁ M₁) (b : n → M₁) (i j : n),
(LinearMap.BilinForm.toMatrixAux b) B i j = (B (b i)) (b j) | null | true |
affineSpan_eq_top_of_nonempty_interior | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] {s : Set V},
(interior ((convexHull ℝ) s)).Nonempty → affineSpan ℝ s = ⊤ | null | true |
_private.Std.Data.HashMap.Lemmas.0.Std.HashMap.mem_toArray_iff_getKey?_eq_some_and_getElem?_eq_some._simp_1_1 | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β}, m.toArray = m.toList.toArray | null | false |
SimpleGraph.deleteEdges_of_subset_diagSet | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} {s : Set (Sym2 V)} (G : SimpleGraph V), s ⊆ Sym2.diagSet → G.deleteEdges s = G | null | true |
QuadraticAlgebra.Int.instFaithfulSMulIntRatCast | Mathlib.Algebra.QuadraticAlgebra.Int | ∀ {a b : ℤ}, FaithfulSMul (QuadraticAlgebra ℤ a b) (QuadraticAlgebra ℚ ↑a ↑b) | null | true |
ProbabilityTheory.stdGaussian_map | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [BorelSpace E] {F : Type u_3} [inst_5 : NormedAddCommGroup F]
[inst_6 : InnerProductSpace ℝ F] [inst_7 : MeasurableSpace F] [BorelSpace F] (f : E ≃ₗᵢ[ℝ] F),
MeasureTheory.M... | null | true |
hasDerivAt_tsum | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} {𝕜 : Type u_2} {F : Type u_4} [inst : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜]
[inst_2 : NormedAddCommGroup F] [CompleteSpace F] {u : α → ℝ} [inst_4 : NormedSpace 𝕜 F] {g g' : α → 𝕜 → F} {y₀ : 𝕜},
Summable u →
(∀ (n : α) (y : 𝕜), HasDerivAt (g n) (g' n y) y) →
(∀ (n : α) ... | Consider a series of functions `∑' n, f n x`. If the series converges at a
point, and all functions in the series are differentiable with a summable bound on the derivatives,
then the series is differentiable and its derivative is the sum of the derivatives. | true |
Lean.Grind.CommRing.Poly.mul_nc.go.eq_def | Init.Grind.Ring.CommSolver | ∀ (p₂ p₁ acc : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.mul_nc.go p₂ p₁ acc =
match p₁ with
| Lean.Grind.CommRing.Poly.num k => acc.combine (Lean.Grind.CommRing.Poly.mulConst k p₂)
| Lean.Grind.CommRing.Poly.add k m p₁ =>
Lean.Grind.CommRing.Poly.mul_nc.go p₂ p₁ (acc.combine (Lean.Grind.C... | null | true |
Finset.instGeneralizedBooleanAlgebra._proof_7 | Mathlib.Data.Finset.SDiff | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : Finset α), a ⊓ b ⊓ a \ b = ⊥ | null | false |
CategoryTheory.Limits.createsLimitsOfShapeOfCreatesEqualizersAndProducts._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{D : Type u_5} [inst_2 : CategoryTheory.Category.{u_4, u_5} D]
[CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) D]
(G : CategoryTheory.Functor C D)
... | null | false |
Submonoid.LocalizationMap.mulEquivOfLocalizations_left_inv_apply | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {k : N ≃* P} (x : N),
(f.mulEquivOfLocalizations (f.ofMulEquivOfLocalizations k)) x = k x | null | true |
Module.FaithfullyFlat.tensorProduct_mk_injective | Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Module.FaithfullyFlat A B] (M : Type u_3) [inst_4 : AddCommGroup M] [inst_5 : Module A M],
Function.Injective ⇑((TensorProduct.mk A B M) 1) | If `B` is a faithfully flat `A`-module and `M` is any `A`-module, the canonical
map `M →ₗ[A] B ⊗[A] M` is injective.
See also `Module.Flat.tensorProduct_mk_injective`. | true |
CategoryTheory.Limits.WalkingPair.right.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | sizeOf CategoryTheory.Limits.WalkingPair.right = 1 | null | true |
CategoryTheory.Functor.map_inv_hom' | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (f : X ≅ Y),
CategoryTheory.CategoryStruct.comp (F.map f.inv) (F.map f.hom) = CategoryTheory.CategoryStruct.id (F.obj Y) | null | true |
Lean.Grind.CommRing.Expr.denoteS._f | Init.Grind.Ring.CommSemiringAdapter | {α : Type u_1} →
[Lean.Grind.Semiring α] →
Lean.Grind.CommRing.Context α → (x : Lean.Grind.CommRing.Expr) → Lean.Grind.CommRing.Expr.below x → α | null | false |
TopologicalSpace.isTopologicalBasis_empty._simp_1 | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α], TopologicalSpace.IsTopologicalBasis ∅ = IsEmpty α | null | false |
_private.Mathlib.MeasureTheory.PiSystem.0.isPiSystem_piiUnionInter._simp_1_5 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
IsometryEquiv.mulLeft._proof_1 | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type u_1} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [IsIsometricSMul G G] (c b c_1 : G),
edist (c * b) (c * c_1) = edist b c_1 | null | false |
FirstOrder.Language.DirectLimit.unify_sigma_mk_self | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {ι : Type v} [inst : Preorder ι] {G : ι → Type w} [inst_1 : (i : ι) → L.Structure (G i)]
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) [DirectedSystem G fun i j h => ⇑(f i j h)] {α : Type u_1} {i : ι}
{x : α → G i},
FirstOrder.Language.DirectLimit.unify f (fun a => FirstOrder.Langu... | null | true |
OnePoint.isClosed_image_coe._simp_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsClosed (OnePoint.some '' s) = (IsClosed s ∧ IsCompact s) | null | false |
Nat.lt_add_one_of_lt | Init.Data.Nat.Basic | ∀ {a b : ℕ}, a < b → a < b + 1 | null | true |
Finset.inv_subset_div_right | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : DivisionMonoid α] {s t : Finset α}, 1 ∈ s → t⁻¹ ⊆ s / t | null | true |
ContinuousLinearMap.ofIsTopCompl_zero | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} {F : Type u_3} [inst_1 : TopologicalSpace E] [inst_2 : AddCommGroup E]
[inst_3 : Module R E] [inst_4 : IsTopologicalAddGroup E] [inst_5 : TopologicalSpace F] [inst_6 : AddCommGroup F]
[inst_7 : Module R F] [inst_8 : ContinuousAdd F] {p q : Submodule R E} (h : Submodul... | null | true |
_private.Init.Data.List.Attach.0.List.attach_filterMap._simp_1_3 | Init.Data.List.Attach | ∀ {α : Sort u_1}, (∃ _a, False) = False | null | false |
Nat._aux_Mathlib_Data_Nat_Factorial_Basic___macroRules_Nat_term_!_1 | Mathlib.Data.Nat.Factorial.Basic | Lean.Macro | null | false |
AffineIsometry | 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] →
[NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[NormedAddTorsor V P] →
... | A `𝕜`-affine isometric embedding of one normed add-torsor over a normed `𝕜`-space into
another, denoted as `f : P →ᵃⁱ[𝕜] P₂`. | true |
Lean.Compiler.LCNF.UnreachableBranches.Value.merge._unsafe_rec | Lean.Compiler.LCNF.ElimDeadBranches | Lean.Environment →
Lean.Compiler.LCNF.UnreachableBranches.Value →
Lean.Compiler.LCNF.UnreachableBranches.Value → Lean.Compiler.LCNF.UnreachableBranches.Value | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.ToDepElimPattern.throwInvalidPattern | Lean.Elab.Match | {α : Type} → Lean.Expr → Lean.MetaM α | null | true |
Fin.foldl_zero | Init.Data.Fin.Fold | ∀ {α : Sort u_1} (f : α → Fin 0 → α) (x : α), Fin.foldl 0 f x = x | null | true |
Std.Async.System.UserId.casesOn | Std.Async.System | {motive : Std.Async.System.UserId → Sort u} →
(t : Std.Async.System.UserId) → ((toNat : ℕ) → motive { toNat := toNat }) → motive t | null | false |
Lean.Linter.CodeQualityLogEntry.mk.inj | Lean.Linter.PersistentLintLog | ∀ {linter? : Option Lean.Name} {entry : Lean.Linter.CodeQuality.Entry} {linter?_1 : Option Lean.Name}
{entry_1 : Lean.Linter.CodeQuality.Entry},
{ linter? := linter?, entry := entry } = { linter? := linter?_1, entry := entry_1 } →
linter? = linter?_1 ∧ entry = entry_1 | null | true |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.elementwiseExpr.mkHomElementwise.match_9 | Mathlib.Tactic.CategoryTheory.Elementwise | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((C instC : Lean.Expr) → motive (C, instC)) → motive x | null | false |
Semiquot.partialOrder | Mathlib.Data.Semiquot | {α : Type u_1} → PartialOrder (Semiquot α) | null | true |
ISize.minValue_div_neg_one | Init.Data.SInt.Lemmas | ISize.minValue / -1 = ISize.minValue | null | true |
Fin.finsetImage_natAdd_Ici | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Finset.image (Fin.natAdd m) (Finset.Ici i) = Finset.Ici (Fin.natAdd m i) | null | true |
Bundle.Trivialization.symm_apply_of_notMem | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {E : B → Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_3 : ∀ (x : B), Nonempty (E x)]
(e : Bundle.Trivialization F Bundle.TotalSpace.proj) {b : B},
b ∉ e.baseSet → ∀ (y : F), e.symm b y = Classical.arbi... | null | true |
Std.HashMap.Raw.mem_insertMany_of_mem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] {ρ : Type w}
[inst_2 : ForIn Id ρ (α × β)] [EquivBEq α] [LawfulHashable α], m.WF → ∀ {l : ρ} {k : α}, k ∈ m → k ∈ m.insertMany l | null | true |
BoundedContinuousFunction.instCommMonoid | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{R : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace R] →
[inst_2 : CommMonoid R] → [BoundedMul R] → [ContinuousMul R] → CommMonoid (BoundedContinuousFunction α R) | null | true |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.eapproxDiff.match_1.splitter | Mathlib.MeasureTheory.Function.SimpleFunc | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | true |
Finset.mulLECancellable_prod._simp_2 | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] [inst_1 : LE α] [MulLeftMono α] {s : Finset ι} {f : ι → α},
MulLECancellable (∏ i ∈ s, f i) = ∀ ⦃i : ι⦄, i ∈ s → MulLECancellable (f i) | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance._unary | Init.Data.String.Pattern.String | (pat : String.Slice) →
UInt8 →
(table : Array ℕ) →
table.size ≤ pat.utf8ByteSize →
(∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) → (guess : ℕ) ×' guess < table.size → { n // n ≤ table.size } | null | false |
Lean.Doc.MarkdownBlock.toMarkdown | Lean.DocString.Markdown | {i : Type u} →
{b : Type v} →
[self : Lean.Doc.MarkdownBlock i b] →
(Lean.Doc.Inline i → Lean.Doc.MarkdownM (Array String)) →
(Lean.Doc.Block i b → Lean.Doc.MarkdownM (Array String)) →
b → Array (Lean.Doc.Block i b) → Lean.Doc.MarkdownM (Array String) | Render the `b` and its contents to Markdown lines, given recursive renderers
for inline and block content.
| true |
Std.HashSet.Raw.erase_emptyWithCapacity | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {k : α} {c : ℕ},
(Std.HashSet.Raw.emptyWithCapacity c).erase k = Std.HashSet.Raw.emptyWithCapacity c | null | true |
LeftPreLieRing.casesOn | Mathlib.Algebra.NonAssoc.PreLie.Basic | {L : Type u_1} →
{motive : LeftPreLieRing L → Sort u} →
(t : LeftPreLieRing L) →
([toNonUnitalNonAssocRing : NonUnitalNonAssocRing L] →
(assoc_symm' : ∀ (x y z : L), associator x y z = associator y x z) →
motive { toNonUnitalNonAssocRing := toNonUnitalNonAssocRing, assoc_symm' := assoc... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.