name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SFinKer.instMonoidalCategory._proof_15 | Mathlib.Probability.Kernel.Category.SFinKer | ∀ (X Y Z : SFinKer),
CategoryTheory.CategoryStruct.comp
{ hom := ProbabilityTheory.Kernel.deterministic ⇑MeasurableEquiv.prodAssoc.symm ⋯, property := ⋯ }
{ hom := ProbabilityTheory.Kernel.deterministic ⇑MeasurableEquiv.prodAssoc ⋯, property := ⋯ } =
CategoryTheory.CategoryStruct.id
{ carrier :=... | null | false |
WType.mk.injEq | Mathlib.Data.W.Basic | ∀ {α : Type u_1} {β : α → Type u_2} (a : α) (f : β a → WType β) (a_1 : α) (f_1 : β a_1 → WType β),
(WType.mk a f = WType.mk a_1 f_1) = (a = a_1 ∧ f ≍ f_1) | null | true |
NormedSpace.inclusionInDoubleDualWeak | Mathlib.Analysis.Normed.Module.DoubleDual | (𝕜 : Type u_1) →
[inst : NontriviallyNormedField 𝕜] →
(X : Type u_2) →
[inst_1 : SeminormedAddCommGroup X] → [inst_2 : NormedSpace 𝕜 X] → WeakSpace 𝕜 X →L[𝕜] WeakDual 𝕜 (StrongDual 𝕜 X) | The map from a normed space with the weak topology into the weak-star bidual, as a continuous
linear map. Built using `LinearEquiv.arrowCongr` to properly bundle the topology changes via
`toWeakSpace` and `StrongDual.toWeakDual`. | true |
subset_interior_add_left | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : AddGroup α] [ContinuousConstVAdd αᵃᵒᵖ α] {s t : Set α},
interior s + t ⊆ interior (s + t) | null | true |
RingCon.dfinsuppSum | Mathlib.RingTheory.Congruence.BigOperators | ∀ {ι : Type u_1} {β : ι → Type u_2} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : Mul M]
[inst_3 : (i : ι) → Zero (β i)] [inst_4 : (i : ι) → (y : β i) → Decidable (y ≠ 0)] (c : RingCon M)
(h h' : (i : ι) → β i → M) {f g : Π₀ (i : ι), β i},
(∀ (i : ι), c (h i 0) 0) →
(∀ (i : ι), c ... | null | true |
Lean.Parser.Term.doIfCond.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | null | true |
MeasureTheory.SimpleFunc.range_const | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {β : Type u_2} (α : Type u_5) [inst : MeasurableSpace α] [Nonempty α] (b : β),
(MeasureTheory.SimpleFunc.const α b).range = {b} | null | true |
Lean.Quote.mk._flat_ctor | Init.Meta.Defs | {α : Type} → {k : optParam Lean.SyntaxNodeKind `term} → (α → Lean.TSyntax k) → Lean.Quote α k | null | false |
addMonoidAlgebraAlgEquivDirectSum._proof_4 | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | ∀ {ι : Type u_2} {A : Type u_1} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : (m : A) → Decidable (m ≠ 0)] (x y : AddMonoidAlgebra A ι),
addMonoidAlgebraRingEquivDirectSum.toFun (x + y) =
addMonoidAlgebraRingEquivDirectSum.toFun x + addMonoidAlgebraRingEquivDirectSum.toFun y | null | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.instIsCancelMulZeroOfIsCancelAdd._simp_15 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsRightCancelMulZero M₀] {a b c : M₀}, (a * c = b * c) = (a = b ∨ c = 0) | null | false |
ContinuousLinearMap.hasDerivWithinAt_of_bilinear | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type w} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {G : Type u_1}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : 𝕜} {s : Set 𝕜} {B : E →L[𝕜] F →L[𝕜... | null | true |
OmegaCompletePartialOrder.ContinuousHom.ωSup._proof_1 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_1} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(c : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c' : OmegaCompletePartialOrder.Chain α) (a : β),
(OmegaCompletePartialOrder.ωSup (c.map OmegaCompletePartialOrder.ContinuousHom.toMono)).toFun
(OmegaCo... | null | false |
MulEquiv.funUnique._proof_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ (α : Type u_2) (M : Type u_1) [inst : Mul M] [inst_1 : Unique α] (x y : α → M),
(Equiv.funUnique α M).toFun (x * y) = (Equiv.funUnique α M).toFun x * (Equiv.funUnique α M).toFun y | null | false |
HasFDerivAt.multiset_prod | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_4} {𝔸' : Type u_6} [inst_3 : NormedCommRing 𝔸'] [inst_4 : NormedAlgebra 𝕜 𝔸']
{g : ι → E → 𝔸'} {g' : ι → E →L[𝕜] 𝔸'} [inst_5 : DecidableEq ι] {u : Multiset ι} {x : E},
... | Unlike `HasFDerivAt.finsetProd`, supports duplicate elements.
| true |
_private.Mathlib.Algebra.Module.SpanRank.0.Submodule.spanRank_toENat_eq_iInf_finset_card._simp_1_1 | Mathlib.Algebra.Module.SpanRank | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (iInf s = ⊤) = ∀ (i : ι), s i = ⊤ | null | false |
instAddLeftCancelSemigroupPNat._proof_2 | Mathlib.Data.PNat.Basic | IsLeftCancelAdd ℕ+ | null | false |
Std.ExtHashSet.size_diff_add_size_inter_eq_size_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ \ m₂).size + (m₁ ∩ m₂).size = m₁.size | null | true |
Ideal.connectedComponentOfZero._proof_2 | Mathlib.Topology.Algebra.Ring.Ideal | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R] (c x : R),
x ∈ (AddSubgroup.connectedComponentOfZero R).carrier → c • x ∈ connectedComponent 0 | null | false |
_private.Mathlib.MeasureTheory.Measure.OpenPos.0.IsMeagre.of_isSigmaCompact_null.match_1_1 | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} (K : ℕ → Set X) (t : Set X) (motive : t ∈ Set.range K → Prop) (x : t ∈ Set.range K),
(∀ (n : ℕ) (hn : K n = t), motive ⋯) → motive x | null | false |
Matrix.mulVecLin_reindex | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {k : Type u_2} {l : Type u_3} {m : Type u_4} {n : Type u_5}
[inst_1 : Fintype n] [inst_2 : Fintype l] (e₁ : k ≃ m) (e₂ : l ≃ n) (M : Matrix k l R),
((Matrix.reindex e₁ e₂) M).mulVecLin =
↑(LinearEquiv.funCongrLeft R R e₁.symm) ∘ₗ M.mulVecLin ∘ₗ ↑(LinearEquiv.funCongrLeft... | A variant of `Matrix.mulVecLin_submatrix` that keeps around `LinearEquiv`s. | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat.0.SSet.Truncated.HomotopyCategory.subsingleton_hom._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ (X : SSet.Truncated 2)
[inst : Unique (X.obj (Opposite.op { obj := { len := 0 }, property := SSet.OneTruncation₂._proof_1 }))]
(a : SSet.OneTruncation₂ X), a = default | null | false |
Ordinal.CNF.snd_lt | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {b o : Ordinal.{u}}, 1 < b → ∀ {x : Ordinal.{u} × Ordinal.{u}}, x ∈ Ordinal.CNF b o → x.2 < b | Every coefficient in the Cantor normal form `CNF b o` is less than `b`. | true |
Complex.UnitClosedDisc.mk_eq_zero._simp_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ {z : ℂ} (hz : ‖z‖ ≤ 1), (Complex.UnitClosedDisc.mk z hz = 0) = (z = 0) | null | false |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.disjoint_iff._simp_1_3 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {f : Filter α}, (f ≠ ⊥) = f.NeBot | null | false |
Std.Do.Spec.Iter.forIn_map | Std.Do.Triple.SpecLemmas | ∀ {α β β₂ γ : Type w} [inst : Std.Iterator α Id β] {ps : Std.Do.PostShape} {n : Type w → Type u_1} [inst_1 : Monad n]
[LawfulMonad n] [inst_3 : Std.Do.WPMonad n ps] [Std.Iterators.Finite α Id] [inst_5 : Std.IteratorLoop α Id n]
[Std.LawfulIteratorLoop α Id n] {it : Std.Iter β} {f : β → β₂} {init : γ} {g : β₂ → γ → ... | null | true |
Manifold.IsImmersionOfComplement.contMDiff | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {E'' : Type u} {F : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'']
[inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {H : Type u_7}
[inst_7 : Topolo... | A `C^n` immersion is `C^n`. | true |
Vector.mk_isPrefixOf_mk | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] {xs ys : Array α} (h : xs.size = n) (h' : ys.size = n),
(Vector.mk xs h).isPrefixOf (Vector.mk ys h') = xs.isPrefixOf ys | null | true |
AddSubgroup.continuousVAdd | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X] [inst_2 : AddGroup M]
[inst_3 : AddAction M X] [ContinuousVAdd M X] {S : AddSubgroup M}, ContinuousVAdd (↥S) X | null | true |
CategoryTheory.Limits.CompleteLattice.finiteColimitCocone._proof_2 | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u_2} {J : Type u_1} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
[inst_2 : SemilatticeSup α] [inst_3 : OrderBot α] (F : CategoryTheory.Functor J α)
(s : CategoryTheory.Limits.Cocone F) (j : J),
CategoryTheory.CategoryStruct.comp
({ pt := Finset.univ.sup F.obj, ... | null | false |
Real.Angle.toReal_neg_iff_sign_neg | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, θ.toReal < 0 ↔ θ.sign = -1 | null | true |
Array.extract.loop.eq_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (as : Array α) (i j : ℕ) (bs : Array α),
Array.extract.loop as i j bs =
if hlt : j < as.size then
match i with
| 0 => bs
| i'.succ => Array.extract.loop as i' (j + 1) (bs.push (as.getInternal j hlt))
else bs | null | true |
NonUnitalRingHom.srange_eq_top_iff_surjective | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] {f : R →ₙ+* S},
f.srange = ⊤ ↔ Function.Surjective ⇑f | null | true |
Std.DHashMap.get?_insert_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{v : β k}, (m.insert k v).get? k = some v | null | true |
Std.Time.PlainTime.toHours | Std.Time.Time.PlainTime | Std.Time.PlainTime → Std.Time.Hour.Offset | Converts a `PlainTime` value to the total number of hours.
| true |
_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix.go._unsafe_rec | Lean.Util.Diff | {α : Type u_1} → [BEq α] → Subarray α → Subarray α → ℕ → Subarray α × Subarray α × Array α | null | false |
FormalMultilinearSeries.iteratedFDerivSeries._proof_1 | Mathlib.Analysis.Analytic.IteratedFDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | null | false |
AddValuation.map_eq_of_lt_sub | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{x y : R}, v x < v (y - x) → v y = v x | null | true |
instShiftLeftUSize | Init.Data.UInt.Basic | ShiftLeft USize | null | true |
_private.Mathlib.Order.Filter.Pi.0.Filter.tendsto_pi._simp_1_2 | Mathlib.Order.Filter.Pi | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : α → β} {x : Filter α} {y : ι → Filter β},
Filter.Tendsto f x (⨅ i, y i) = ∀ (i : ι), Filter.Tendsto f x (y i) | null | false |
CategoryTheory.Pseudofunctor.CoGrothendieck.mapCompIso._proof_2 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} 𝒮]
{F G H : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} (α : F ⟶ G) (β : G ⟶ H)
{X Y : F.CoGrothendieck} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pseudofunctor.CoGrothendieck.map ... | null | false |
AffineIndepOn.singleton._simp_1 | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {ι : Type u_4} (p : ι → P) (i : ι), AffineIndepOn k p {i} = True | null | false |
LieAlgebra.maxNilpotentIdeal_le_radical | Mathlib.Algebra.Lie.Nilpotent | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.maxNilpotentIdeal R L ≤ LieAlgebra.radical R L | null | true |
Lean.Doc.builtinDocDirectives | Lean.Elab.DocString | IO.Ref (Lean.NameMap (Array (Lean.Name × Lean.Doc.DocDirectiveExpander))) | Built-in docstring directives, for bootstrapping.
| true |
IsEllipticNet.atom_abs_left | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] {W : ℤ → R},
Function.Odd W → ∀ (a b : ℤ), IsEllipticNet.atom W |a| b = IsEllipticNet.atom W a b | null | true |
toAdd_div | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u} [inst : Sub α] (x y : Multiplicative α),
Multiplicative.toAdd (x / y) = Multiplicative.toAdd x - Multiplicative.toAdd y | null | true |
powMonoidWithZeroHom_apply | Mathlib.Algebra.GroupWithZero.Hom | ∀ {M₀ : Type u_6} [inst : CommMonoidWithZero M₀] {n : ℕ} (hn : n ≠ 0) (a : M₀), (powMonoidWithZeroHom hn) a = a ^ n | null | true |
_private.Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo.0.CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp_hom._simp_1_2 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : Y ⟶ X) [inst_1 : CategoryTheory.IsIso α]
{f : Z ⟶ X} {g : Z ⟶ Y},
(f = CategoryTheory.CategoryStruct.comp g α) = (CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g) | null | false |
MonomialOrder.coeff_degree_ne_zero_iff | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {f : MvPolynomial σ R},
f.coeff (m.degree f) ≠ 0 ↔ f ≠ 0 | null | true |
SchwartzMap._aux_Mathlib_Analysis_Distribution_TemperedDistribution___unexpand_TemperedDistribution_1 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.PrettyPrinter.Unexpander | null | false |
localCohomology.ringModIdealComp._proof_1 | Mathlib.Algebra.Homology.LocalCohomology | ∀ {R : Type u_3} [inst : CommRing R] {D : Type u_5} [inst_1 : CategoryTheory.Category.{u_4, u_5} D] {E : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} E] (I' : CategoryTheory.Functor E D)
(I : CategoryTheory.Functor D (Ideal R)) {X Y : E} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((localCohomology.... | null | false |
Submodule.Quotient.restrictScalarsEquiv_symm_mk | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Type u_3)
[inst_3 : Ring S] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M] (P : Submodule R M)
(x : M), (Submodule.Quotient.restrictScalarsEquiv S P).symm (Submodule.Quotient.mk x) = Submod... | null | true |
ValueDistribution.characteristic | Mathlib.Analysis.Complex.ValueDistribution.CharacteristicFunction | {E : Type u_1} → [inst : NormedAddCommGroup E] → [NormedSpace ℂ E] → (ℂ → E) → WithTop E → ℝ → ℝ | The Characteristic Function of Value Distribution Theory
If `f : ℂ → E` is meromorphic and `a : WithTop E` is any value, the characteristic function of `f`
is defined as the sum of two terms: the proximity function, which quantifies how close `f` gets to
`a` on the circle `∣z∣ = r`, and the logarithmic counting functi... | true |
Lean.Parser.Tactic.constructorBang | Init.Tactics | Lean.ParserDescr | `constructor!` is short for `constructor +first`: it solves the main goal with the first matching
constructor of its target type, without checking whether any further constructors match.
| true |
IsMulTorsionFree.zpow_eq_one_iff | Mathlib.Algebra.Group.Torsion | ∀ {G : Type u_2} [inst : Group G] {n : ℤ} {a : G} [IsMulTorsionFree G], a ^ n = 1 ↔ a = 1 ∨ n = 0 | null | true |
Multiset.Icc_eq_zero_iff._simp_1 | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, (Multiset.Icc a b = 0) = ¬a ≤ b | null | false |
StructureGroupoid.noConfusion | Mathlib.Geometry.Manifold.StructureGroupoid | {P : Sort u} →
{H : Type u_2} →
{inst : TopologicalSpace H} →
{t : StructureGroupoid H} →
{H' : Type u_2} →
{inst' : TopologicalSpace H'} →
{t' : StructureGroupoid H'} → H = H' → inst ≍ inst' → t ≍ t' → StructureGroupoid.noConfusionType P t t' | null | false |
_private.Mathlib.Data.Part.0.Part.mem_unique.match_1_1 | Mathlib.Data.Part | ∀ {α : Type u_1} (motive : (x x_1 : α) → (x_2 : Part α) → x ∈ x_2 → x_1 ∈ x_2 → Prop) (x x_1 : α) (x_2 : Part α)
(x_3 : x ∈ x_2) (x_4 : x_1 ∈ x_2),
(∀ (Dom : Prop) (get : Dom → α) (w w_1 : { Dom := Dom, get := get }.Dom),
motive ({ Dom := Dom, get := get }.get w) ({ Dom := Dom, get := get }.get w_1) { Dom := ... | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorObj_hom_ext.match_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀
(motive :
(x y z : AugmentedSimplexCategory) →
(f g : CategoryTheory.MonoidalCategoryStruct.tensorObj x y ⟶ z) →
CategoryTheory.CategoryStruct.comp (x.inl y) f = CategoryTheory.CategoryStruct.comp (x.inl y) g →
CategoryTheory.CategoryStruct.comp (x.inr y) f = CategoryTheory.CategoryStruc... | null | false |
CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Functor_Oplax___unexpand_CategoryTheory_OplaxFunctor_1 | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | Lean.PrettyPrinter.Unexpander | null | false |
convex_iff_pairwise_pos | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {s : Set E},
Convex 𝕜 s ↔ s.Pairwise fun x y => ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s | null | true |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.continuous_map_iff._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_3} [inst_1 : TopologicalSpace Y] (f : OnePoint X → Y),
Continuous f =
(Filter.Tendsto (fun x => f ↑x) (Filter.coclosedCompact X) (nhds (f OnePoint.infty)) ∧ Continuous fun x => f ↑x) | null | false |
CategoryTheory.Idempotents.split_imp_of_iso | Mathlib.CategoryTheory.Idempotents.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X X' : C} (φ : X ≅ X') (p : X ⟶ X) (p' : X' ⟶ X'),
CategoryTheory.CategoryStruct.comp p φ.hom = CategoryTheory.CategoryStruct.comp φ.hom p' →
(∃ Y i e,
CategoryTheory.CategoryStruct.comp i e = CategoryTheory.CategoryStruct.id Y ∧
Ca... | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.IterM.step_filterM.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {β : Type u_1} {n : Type u_1 → Type u_2} {f : β → n (ULift.{u_1, 0} Bool)} [inst : MonadAttach n] (out : β)
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) (hf : MonadAttach.CanReturn (f out) { down := false })
(h_1 : (hf : MonadAttach.CanReturn (f out) { down := false }) → motive ⟨{ down := false }... | null | true |
Interval.lattice._proof_2 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : DecidableLE α] (s t : Interval α),
(match s, t with
| none, x => ⊥
| x, none => ⊥
| some s, some t =>
if h : s.toProd.1 ≤ t.toProd.2 ∧ t.toProd.1 ≤ s.toProd.2 then
↑{ fst := s.toProd.1 ⊔ t.toProd.1, snd := s.toProd.2 ⊓ t.toProd.2, fst_le_snd := ⋯... | null | false |
Algebra.IsAlgebraic.algHomEmbeddingOfSplits._proof_3 | Mathlib.FieldTheory.Normal.Closure | ∀ {F : Type u_2} [inst : Field F] (L' : Type u_1) [inst_1 : Field L'] [inst_2 : Algebra F L'],
SubsemiringClass (IntermediateField F L') L' | null | false |
isCyclic_tfae | Mathlib.FieldTheory.KummerExtension | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L],
(primitiveRoots (Module.finrank K L) K).Nonempty →
[IsGalois K L ∧ IsCyclic Gal(L/K),
∃ a,
Irreducible (Polynomial.X ^ Module.finrank K L - Polynomial.C a) ∧
Polynomial... | Suppose `L/K` is a finite extension of dimension `n`,
and `K` contains a primitive`n`-th root of unity.
Then `L/K` is cyclic iff
`L` is a splitting field of some irreducible polynomial of the form `Xⁿ - a : K[X]` iff
`L = K[α]` for some `αⁿ ∈ K`.
| true |
DivisibleHull.instSMulRat._proof_1 | Mathlib.GroupTheory.DivisibleHull | ∀ (a : ℚ), 0 ≤ |a| | null | false |
Lean.HeadIndex.sort.sizeOf_spec | Lean.HeadIndex | sizeOf Lean.HeadIndex.sort = 1 | null | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_Ico_le_integral_of_le._simp_1_3 | Mathlib.Analysis.SumIntegralComparisons | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
_private.Init.PropLemmas.0.and_or_left.match_1_1 | Init.PropLemmas | ∀ {a b c : Prop} (motive : a ∧ (b ∨ c) → Prop) (x : a ∧ (b ∨ c)), (∀ (ha : a) (hbc : b ∨ c), motive ⋯) → motive x | null | false |
Array.map_set | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α} {i : ℕ} {h : i < xs.size} {a : α},
Array.map f (xs.set i a h) = (Array.map f xs).set i (f a) ⋯ | null | true |
Cardinal.commSemiring._proof_10 | Mathlib.SetTheory.Cardinal.Order | ∀ (a : Cardinal.{u_1}), a * 1 = a | null | false |
StateTransition.EvalsToInTime.noConfusion | Mathlib.Computability.StateTransition | {P : Sort u} →
{σ : Type u_1} →
{f : σ → Option σ} →
{a : σ} →
{b : Option σ} →
{m : ℕ} →
{t : StateTransition.EvalsToInTime f a b m} →
{σ' : Type u_1} →
{f' : σ' → Option σ'} →
{a' : σ'} →
{b' : Option σ'} →
... | null | false |
DilationEquivClass.mk | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {F : Type u_1} {X : outParam (Type u_2)} {Y : outParam (Type u_3)} [inst : PseudoEMetricSpace X]
[inst_1 : PseudoEMetricSpace Y] [inst_2 : EquivLike F X Y],
(∀ (f : F), ∃ r, r ≠ 0 ∧ ∀ (x y : X), edist (f x) (f y) = ↑r * edist x y) → DilationEquivClass F X Y | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.EvalNum.0.Lean.Meta.Grind.Arith.evalNatCore | Lean.Meta.Tactic.Grind.Arith.EvalNum | Lean.Expr → OptionT Lean.Meta.Grind.GrindM ℕ | null | true |
Ring.DimensionLEOne.localization | Mathlib.RingTheory.DedekindDomain.Dvr | ∀ {R : Type u_2} (Rₘ : Type u_3) [inst : CommRing R] [IsDomain R] [inst_2 : CommRing Rₘ] [inst_3 : Algebra R Rₘ]
{M : Submonoid R} [IsLocalization M Rₘ], M ≤ nonZeroDivisors R → ∀ [h : Ring.DimensionLEOne R], Ring.DimensionLEOne Rₘ | Localizing a domain of Krull dimension `≤ 1` gives another ring of Krull dimension `≤ 1`.
Note that the same proof can/should be generalized to preserving any Krull dimension,
once we have a suitable definition.
| true |
Lean.CodeAction.CommandCodeActions.noConfusion | Lean.Server.CodeActions.Attr | {P : Sort u} →
{t t' : Lean.CodeAction.CommandCodeActions} → t = t' → Lean.CodeAction.CommandCodeActions.noConfusionType P t t' | null | false |
Float.Model.instBEqUnpackedFloat.beq | Init.Data.Float.Model.Unpacked.Basic | Float.Model.UnpackedFloat → Float.Model.UnpackedFloat → Bool | null | true |
NNReal.coe_sub_of_lt._simp_1 | Mathlib.Basic.NNReal.Basic | ∀ {a b : NNReal}, a < b → ↑b - ↑a = ↑(b - a) | null | false |
UniformSpace.Completion.coe_vadd._simp_1 | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : VAdd M X] [UniformContinuousConstVAdd M X] (c : M)
(x : X), c +ᵥ ↑x = ↑(c +ᵥ x) | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.quot._regBuiltin.Lean.Parser.Command.quot.formatter_9 | Lean.Parser.Command | IO Unit | null | false |
CategoryTheory.SimplicialObject.Splitting.homotopyEquivNondegComplex_inv | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C], s.homotopyEquivNondegComplex.inv = s.fromNondegComplex | null | true |
OrderDual.instDivisionRing._proof_6 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] (a : Kᵒᵈ), a ≠ 0 → a * a⁻¹ = 1 | null | false |
ContMDiffWithinAt.prodMap' | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | The product map of two `C^n` functions within a set at a point is `C^n`
within the product set at the product point. | true |
MeasureTheory.Measure.MutuallySingular.zero_left._simp_1 | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
MeasureTheory.Measure.MutuallySingular 0 μ = True | null | false |
ComplexShape.Embedding.πTruncGENatTrans | Mathlib.Algebra.Homology.Embedding.TruncGE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
(e : c.Embedding c') →
[inst : e.IsTruncGE] →
(C : Type u_4) →
[inst_1 : CategoryTheory.Category.{v_2, u_4} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] ... | The natural transformation `K.πTruncGE e : K ⟶ K.truncGE e` for all `K`. | true |
AddMonoid.addOrderOf_le_exponent | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : AddMonoid G], AddMonoid.ExponentExists G → ∀ (g : G), addOrderOf g ≤ AddMonoid.exponent G | null | true |
Std.ExtTreeSet.min!_eq_iff_mem_and_forall | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
[inst_2 : Inhabited α], t ≠ ∅ → ∀ {km : α}, t.min! = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true | null | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.evalSuggestSeq1Tac | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.TryTactic | null | true |
TensorProduct.dualDistribEquivOfBasis_apply_apply | Mathlib.LinearAlgebra.Contraction | ∀ {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {ι : Type u_7} {κ : Type u_8}
[inst_5 : Fintype ι] [inst_6 : Fintype κ] [inst_7 : DecidableEq ι] [inst_8 : DecidableEq κ] (b : Module.Basis ι R M)
... | null | true |
NNReal.sqrt_le_sqrt | Mathlib.Analysis.Real.Sqrt | ∀ {x y : NNReal}, NNReal.sqrt x ≤ NNReal.sqrt y ↔ x ≤ y | null | true |
SimpleGraph.Walk.take_spec | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support),
(p.takeUntil u h).append (p.dropUntil u h) = p | The `takeUntil` and `dropUntil` functions split a walk into two pieces.
The lemma `SimpleGraph.Walk.count_support_takeUntil_eq_one` specifies where this split occurs. | true |
finSuccEquiv'_below | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {i : Fin (n + 1)} {m : Fin n}, m.castSucc < i → (finSuccEquiv' i) m.castSucc = some m | null | true |
Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[inst : Std.TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF)
(h' : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.filterMap f t ⋯).impl = true),
(f (t.getKey k ⋯) (Std.DTreeMap.Internal... | null | true |
Lean.Compiler.LCNF.ConfigOptions.recOn | Lean.Compiler.LCNF.ConfigOptions | {motive : Lean.Compiler.LCNF.ConfigOptions → Sort u} →
(t : Lean.Compiler.LCNF.ConfigOptions) →
((smallThreshold maxRecInline maxRecInlineIfReduce : ℕ) →
(checkTypes extractClosed : Bool) →
(maxRecSpecialize : ℕ) →
(resetReuse : Bool) →
motive
{ smallThr... | null | false |
CategoryTheory.StructuredArrow.isoMk | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{S : D} →
{T : CategoryTheory.Functor C D} →
{f f' : CategoryTheory.StructuredArrow S T} →
(g : f.right ≅ f'.right) →
auto... | To construct an isomorphism of structured arrows,
we need an isomorphism of the objects underlying the target,
and to check that the triangle commutes.
| true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.truncate.go.match_1 | Lean.Server.Completion.CompletionCollectors | (motive : Lean.Name × ℕ → Sort u_1) → (x : Lean.Name × ℕ) → ((p' : Lean.Name) → (len : ℕ) → motive (p', len)) → motive x | null | false |
_private.Mathlib.Computability.TuringMachine.Tape.0.Turing.ListBlank.append.match_1.eq_2 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (motive : List Γ → Turing.ListBlank Γ → Sort u_2) (a : Γ) (l : List Γ)
(L : Turing.ListBlank Γ) (h_1 : (L : Turing.ListBlank Γ) → motive [] L)
(h_2 : (a : Γ) → (l : List Γ) → (L : Turing.ListBlank Γ) → motive (a :: l) L),
(match a :: l, L with
| [], L => h_1 L
| a :: ... | null | true |
isTopologicalBasis_biInter_Ioi_Iio_of_generateFrom._to_dual_1 | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [ts : TopologicalSpace α] [inst : Preorder α] (c : Set α),
ts = TopologicalSpace.generateFrom {s | ∃ a ∈ c, s = Set.Iio a ∨ s = Set.Ioi a} →
TopologicalSpace.IsTopologicalBasis
{s | ∃ f g, f ⊆ c ∧ g ⊆ c ∧ f.Finite ∧ g.Finite ∧ s = (⋂ a ∈ f, Set.Iio a) ∩ ⋂ a ∈ g, Set.Ioi a} | null | false |
MeasureTheory.MemLp.aemeasurable | Mathlib.MeasureTheory.Function.LpSeminorm.Defs | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} [inst : ENorm ε] {μ : MeasureTheory.Measure α}
[inst_1 : MeasurableSpace ε] [inst_2 : TopologicalSpace ε] [TopologicalSpace.PseudoMetrizableSpace ε] [BorelSpace ε]
{f : α → ε} {p : ENNReal}, MeasureTheory.MemLp f p μ → AEMeasurable f μ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.