name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
BoxIntegral.Prepartition.instSemilatticeInf._proof_3 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (x π₁ x_1 : BoxIntegral.Prepartition I),
x ≤ π₁ → x ≤ x_1 → x ≤ π₁.biUnion fun J => x_1.restrict J | null | false |
String.Model.positionsFrom_eq_cons | Init.Data.String.Lemmas.Iterate | ∀ {s : String} {p : s.Pos} (hp : p ≠ s.endPos),
String.Model.positionsFrom p = ⟨p, hp⟩ :: String.Model.positionsFrom (p.next hp) | null | true |
ByteArray.get_set_eq._proof_1 | Batteries.Data.ByteArray | ∀ (a : ByteArray) (i : Fin a.size) (v : UInt8), ↑i < (a.set (↑i) v ⋯).size | null | false |
MeasureTheory.Measure.OuterRegular.smul | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] (μ : MeasureTheory.Measure α) [μ.OuterRegular]
{x : ENNReal}, x ≠ ⊤ → (x • μ).OuterRegular | null | true |
CategoryTheory.unop_inv_associator | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y Z : Cᵒᵖ),
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv.unop =
(CategoryTheory.MonoidalCategoryStruct.associator (Opposite.unop X) (Opposite.unop Y) (Opposite.unop Z)).hom | null | true |
_private.Mathlib.Analysis.CStarAlgebra.PositiveLinearFunctional.0.ContinuousLinearMap.im_apply_eq_zero_of_tendsto_nhds_opNorm._simp_1_2 | Mathlib.Analysis.CStarAlgebra.PositiveLinearFunctional | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
DFinsupp.erase_neg | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} [inst : DecidableEq ι] {β : ι → Type v} [inst_1 : (i : ι) → AddGroup (β i)] (i : ι)
(f : Π₀ (i : ι), β i), DFinsupp.erase i (-f) = -DFinsupp.erase i f | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AccLevelState.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{t t' : Lean.Elab.Command.AccLevelState✝} → t = t' → Lean.Elab.Command.AccLevelState.noConfusionType✝ P t t' | null | false |
MvPolynomial.degrees_map_of_injective | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {S : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S] (p : MvPolynomial σ R)
{f : R →+* S}, Function.Injective ⇑f → ((MvPolynomial.map f) p).degrees = p.degrees | null | true |
Filter.Eventually.exists_lt | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : Preorder α] {a : α} [(nhdsWithin a (Set.Iio a)).NeBot]
{p : α → Prop}, (∀ᶠ (x : α) in nhds a, p x) → ∃ b < a, p b | null | true |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.abstractGroundMismatches?.goCore._sparseCasesOn_7 | Lean.Meta.Tactic.Grind.ProveEq | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Analysis.SpecialFunctions.PolarCoord.0.polarCoord._simp_7 | Mathlib.Analysis.SpecialFunctions.PolarCoord | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | null | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.CollectDerivedValInfo.State._sizeOf_inst | Lean.Compiler.LCNF.ExplicitRC | SizeOf Lean.Compiler.LCNF.CollectDerivedValInfo.State✝ | null | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.spectrum.«_aux_Mathlib_Algebra_Algebra_Spectrum_Basic___macroRules__private_Mathlib_Algebra_Algebra_Spectrum_Basic_0_spectrum_term↑ₐ_2_1» | Mathlib.Algebra.Algebra.Spectrum.Basic | Lean.Macro | null | false |
TopPair.HomologyPretheory._sizeOf_1 | Mathlib.AlgebraicTopology.EilenbergSteenrod | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{ι : Type u_2} → {c : ComplexShape ι} → [SizeOf C] → [SizeOf ι] → TopPair.HomologyPretheory C c → ℕ | null | false |
HasFDerivAt.lim_real | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {f : E → F} {f' : E →L[ℝ] F} {x : E},
HasFDerivAt f f' x → ∀ (v : E), Filter.Tendsto (fun c => c • (f (x + c⁻¹ • v) - f x)) Filter.atTop (nhds (f' v)) | null | true |
Mathlib.Tactic.DepRewrite.eq_of_heq | Mathlib.Tactic.DepRewrite | ∀ {α : Sort u} {a a' : α}, a ≍ a' → a = a' | null | true |
CategoryTheory.Limits.compCoyonedaSectionsEquiv_symm_apply_coe | Mathlib.CategoryTheory.Limits.Types.Yoneda | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] (F : CategoryTheory.Functor J C) (X : C)
(τ : (CategoryTheory.Functor.const J).obj X ⟶ F) (X_1 : J),
↑((CategoryTheory.Limits.compCoyonedaSectionsEquiv F X).symm τ) X_1 = τ.app X_1 | null | true |
Std.Http.Version.toNumber | Std.Http.Data.Version | Std.Http.Version → ℕ × ℕ | Converts a `Version` to its corresponding major and minor numbers as a pair.
| true |
TopologicalSpace.Compacts.compactNhdsMkOfOpens | Mathlib.Topology.Sets.Compacts | {α : Type u_1} →
[inst : TopologicalSpace α] →
{K : TopologicalSpace.Compacts α} →
(L : TopologicalSpace.Compacts α) → (U : TopologicalSpace.Opens α) → ↑K ⊆ ↑U → ↑U ⊆ ↑L → ↑K.compactNhds | The compact neighbourhood induced by the existence of an open subset between two compacts | true |
CategoryTheory.BiconeHom.decidableEq._proof_16 | Mathlib.CategoryTheory.Limits.Bicones | ∀ (J : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} J] (j : J)
(g : CategoryTheory.BiconeHom J CategoryTheory.Bicone.left (CategoryTheory.Bicone.diagram j)), g ≍ g | null | false |
_private.Mathlib.Algebra.Order.BigOperators.Group.Finset.0.Fintype.one_lt_prod_iff_of_one_le._simp_1_1 | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : Fintype ι] [inst_1 : CommMonoid M] [inst_2 : PartialOrder M]
[IsOrderedCancelMonoid M] {f : ι → M}, 1 < f → (1 < ∏ i, f i) = True | null | false |
derivWithin_pi | Mathlib.Analysis.Calculus.Deriv.Prod | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {ι : Type u_1} {E' : ι → Type u_2}
[inst_1 : (i : ι) → NormedAddCommGroup (E' i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E' i)] {φ : 𝕜 → (i : ι) → E' i},
(∀ (i : ι), DifferentiableWithinAt 𝕜 (fun x => φ x i) s x) →
derivWithin φ s x = fun ... | null | true |
_private.Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences.0.CategoryTheory.Abelian.Ext.δ._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ (n₀ n₁ : ℕ), n₀ + 1 = n₁ → 1 + n₀ = n₁ | null | false |
FreeAbelianGroup.distrib._proof_2 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u_1} [inst : Mul α] (x x_1 x_2 : FreeAbelianGroup α),
(FreeAbelianGroup.lift fun x₂ => (FreeAbelianGroup.lift fun x₁ => FreeAbelianGroup.of (x₁ * x₂)) x) (x_1 + x_2) =
(FreeAbelianGroup.lift fun x₂ => (FreeAbelianGroup.lift fun x₁ => FreeAbelianGroup.of (x₁ * x₂)) x) x_1 +
(FreeAbelianGroup.lift... | null | false |
CategoryTheory.PreGaloisCategory.instPreservesColimitsOfShapeFintypeCatSingleObjInclOfFinite | Mathlib.CategoryTheory.Galois.GaloisObjects | ∀ {G : Type v} [inst : Group G] [Finite G],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.SingleObj G) FintypeCat.incl | null | true |
Std.Time.Week.Aligned.instOrdOrdinal | Std.Time.Date.Unit.Week | Ord Std.Time.Week.Aligned.Ordinal | null | true |
CondensedSet.LocallyConstant.instFaithfulCondensedTypeDiscrete | Mathlib.Condensed.Discrete.LocallyConstant | (Condensed.discrete (Type (u_1 + 1))).Faithful | null | true |
NonAssocRing.toNonUnitalNonAssocRing | Mathlib.Algebra.Ring.Defs | {α : Type u_1} → [self : NonAssocRing α] → NonUnitalNonAssocRing α | null | true |
Lean.TraceState | Lean.Util.Trace | Type | null | true |
_private.Mathlib.Algebra.Lie.Free.0._aux_Mathlib_Algebra_Lie_Free___unexpand_FreeNonUnitalNonAssocAlgebra_lift_comp_of_1 | Mathlib.Algebra.Lie.Free | Lean.PrettyPrinter.Unexpander | null | false |
ImportGraph.Shake.NeedsKind.casesOn | ImportGraph.Shake.Core | {motive : ImportGraph.Shake.NeedsKind → Sort u} →
(t : ImportGraph.Shake.NeedsKind) →
((isExported isMeta isAll : Bool) →
(not_isExported_and_isAll : ¬(isExported = true ∧ isAll = true)) →
motive
{ isExported := isExported, isMeta := isMeta, isAll := isAll,
not_isExport... | null | false |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Option.getD.match_1.eq_1 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (x : α) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match some x with
| some x => h_1 x
| none => h_2 ()) =
h_1 x | null | true |
MeasureTheory.Measure.add_right_inj | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ ν₁ ν₂ : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ],
μ + ν₁ = μ + ν₂ ↔ ν₁ = ν₂ | null | true |
CategoryTheory.regularTopology.isLimit_forkOfι_equiv._proof_4 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X B : C} (π : X ⟶ B)
(c : CategoryTheory.Limits.PullbackCone π π),
∃ Y h g,
CategoryTheory.Presieve.ofArrows (fun x => X) (fun x => π) g ∧
CategoryTheory.CategoryStruct.comp h g = CategoryTheory.CategoryStruct.comp c.fst π | null | false |
_private.Init.Data.List.ToArray.0.Array.replace.eq_1 | Init.Data.List.ToArray | ∀ {α : Type u} [inst : BEq α] (xs : Array α) (a b : α),
xs.replace a b =
match xs.finIdxOf? a with
| none => xs
| some i => xs.set (↑i) b ⋯ | null | true |
GenContFract.ext | Mathlib.Algebra.ContinuedFractions.Basic | ∀ {α : Type u_1} {x y : GenContFract α}, x.h = y.h → x.s = y.s → x = y | null | true |
SpectrumRestricts.of_rightInvOn | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ {R : Type u_3} {S : Type u_4} {A : Type u_5} [inst : Semifield R] [inst_1 : Semifield S] [inst_2 : Ring A]
[inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] {a : A} {f : S → R},
Function.LeftInverse f ⇑(algebraMap R S) → Set.RightInvOn f (⇑(algebraMap R S)) (spectrum S a) → SpectrumRestricts a ... | null | true |
MinimalFor.not_lt | Mathlib.Order.Minimal | ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] {Q : ι → Prop} {f : ι → α} {i j : ι},
MinimalFor Q f i → Q j → ¬f j < f i | null | true |
CompleteDistribLattice.MinimalAxioms.toCoframe | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [inst : CompleteLattice α], CompleteDistribLattice.MinimalAxioms α → Order.Coframe.MinimalAxioms α | Turn minimal axioms for `CompleteDistribLattice` into minimal axioms for `Order.Coframe`. | true |
Multiset.coe_card | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} (l : List α), (↑l).card = l.length | null | true |
Std.LawfulOrderMin.casesOn | Init.Data.Order.Classes | {α : Type u} →
[inst : Min α] →
[inst_1 : LE α] →
{motive : Std.LawfulOrderMin α → Sort u_1} →
(t : Std.LawfulOrderMin α) →
([toMinEqOr : Std.MinEqOr α] → [toLawfulOrderInf : Std.LawfulOrderInf α] → motive ⋯) → motive t | null | false |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.exists_bucket_of_uset._simp_1_2 | Std.Data.DHashMap.Internal.Model | ∀ {x y : Bool}, ((x || y) = false) = (x = false ∧ y = false) | null | false |
_private.Lean.Elab.Tactic.LibrarySearch.0.Lean.Elab.LibrarySearch.evalExact._regBuiltin.Lean.Elab.LibrarySearch.evalExact_1 | Lean.Elab.Tactic.LibrarySearch | IO Unit | null | false |
FinBddDistLat.Iso.mk._proof_13 | Mathlib.Order.Category.FinBddDistLat | ∀ {α β : FinBddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat), e.symm ⊤ = ⊤ | null | false |
List.flatMap_eq_nil_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : α → List β}, List.flatMap f l = [] ↔ ∀ x ∈ l, f x = [] | null | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram._sizeOf_inst | Mathlib.CategoryTheory.Presentable.Directed | (J : Type w) →
{inst : CategoryTheory.SmallCategory J} →
(κ : Cardinal.{w}) → [SizeOf J] → SizeOf (CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ) | null | false |
QuotientAddGroup.liftEquiv._proof_4 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] (N : AddSubgroup G) [nN : N.Normal]
{φ : G →+ H},
Function.Surjective ⇑φ →
∀ (HN : N = φ.ker),
Function.Injective ⇑(QuotientAddGroup.lift N φ ⋯) ∧ Function.Surjective ⇑(QuotientAddGroup.lift N φ ⋯) | null | false |
Lean.Elab.UserWidgetInfo.ctorIdx | Lean.Elab.InfoTree.Types | Lean.Elab.UserWidgetInfo → ℕ | null | false |
Stream'.Seq1.join_nil | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (a : α) (S : Stream'.Seq (Stream'.Seq1 α)), Stream'.Seq1.join ((a, Stream'.Seq.nil), S) = (a, S.join) | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_11 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs rls : ℕ) (rll rlr : Std.DTreeMap.Internal.Impl α β) (size : ℕ)
(l r : Std.DTreeMap.Internal.Impl α β),
(rll.Balanced ∧
rlr.Balanced ∧
(rll.size + rlr.size ≤ 1 ∨ rll.size ≤ 3 * rlr.size ∧ rlr.size ≤ 3 * rll.size) ∧
rls = rll.size + 1 + rlr.size) ∧... | null | false |
IsDecompositionField.ringEquiv._proof_1 | Mathlib.NumberTheory.RamificationInertia.HilbertTheory | ∀ (L : Type u_2) [inst : Field L] (D : Type u_1) [inst_1 : Field D] [inst_2 : Algebra D L], FaithfulSMul D L | null | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.elabPipeProj.match_1 | Lean.Elab.App | (motive : Option (Lean.Syntax.TSepArray `level ",") → Sort u_1) →
(us? : Option (Lean.Syntax.TSepArray `level ",")) →
((us? : Lean.Syntax.TSepArray `level ",") → motive (some us?)) →
((x : Option (Lean.Syntax.TSepArray `level ",")) → motive x) → motive us? | null | false |
finSuccEquivLast | Mathlib.Logic.Equiv.Fin.Basic | {n : ℕ} → Fin (n + 1) ≃ Option (Fin n) | `Equiv` between `Fin (n + 1)` and `Option (Fin n)` sending `Fin.last n` to `none` | true |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqvArg._sparseCasesOn_2 | Lean.Compiler.LCNF.AlphaEqv | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.Arg pu → Sort u} →
(t : Lean.Compiler.LCNF.Arg pu) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Arg.fvar fvarId)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
RestrictedProduct.mapAlongAddMonoidHom._proof_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι₁ : Type u_4} {ι₂ : Type u_1} (R₁ : ι₁ → Type u_5) (R₂ : ι₂ → Type u_2) {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂}
{S₁ : ι₁ → Type u_6} {S₂ : ι₂ → Type u_3} [inst : (i : ι₁) → SetLike (S₁ i) (R₁ i)]
[inst_1 : (j : ι₂) → SetLike (S₂ j) (R₂ j)] {B₁ : (i : ι₁) → S₁ i} {B₂ : (j : ι₂) → S₂ j} (f : ι₂ → ι₁)
(hf : Filter.T... | null | false |
MeasureTheory.spanningSets_mono | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SigmaFinite μ] {m n : ℕ},
m ≤ n → MeasureTheory.spanningSets μ m ⊆ MeasureTheory.spanningSets μ n | null | true |
HasStrictFDerivAt.eventually_apply_eq_iff_implicitFunctionOfProdDomain | Mathlib.Analysis.Calculus.ImplicitFunction.ProdDomain | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E₁ : Type u_2} [inst_1 : NormedAddCommGroup E₁]
[inst_2 : NormedSpace 𝕜 E₁] [inst_3 : CompleteSpace E₁] {E₂ : Type u_3} [inst_4 : NormedAddCommGroup E₂]
[inst_5 : NormedSpace 𝕜 E₂] [inst_6 : CompleteSpace E₂] {F : Type u_4} [inst_7 : NormedAddCommGroup F]
[... | null | true |
IsOfFinOrder.inv | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Group G] {x : G}, IsOfFinOrder x → IsOfFinOrder x⁻¹ | **Alias** of the reverse direction of `isOfFinOrder_inv_iff`.
---
Inverses of elements of finite order have finite order. | true |
CategoryTheory.Limits.colimit.smul._proof_2 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] [inst_1 : CategoryTheory.IsFiltered C]
(R : CategoryTheory.Functor C RingCat) (M : CategoryTheory.Functor C Ab)
[inst_2 : (i : C) → Module ↑(R.obj i) ↑(M.obj i)],
(∀ {i j : C} (f : i ⟶ j) (r : ↑(R.obj i)) (m : ↑(M.obj i)),
(CategoryTheory.ConcreteCate... | null | false |
_private.Mathlib.RingTheory.IsTensorProduct.0.IsTensorProduct.assoc._proof_3 | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_6} {S : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {M₁ : Type u_4}
{M₂ : Type u_7} {M₃ : Type u_3} {M₁₂ : Type u_2} {M₂₃ : Type u_5} [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₂] [inst_5 : AddCommMonoid M₃] [inst_6 : AddCommMonoid M₁₂] [inst_7 : AddCom... | null | false |
UniqueFactorizationMonoid.iff_exists_prime_mem_of_isPrime | Mathlib.RingTheory.UniqueFactorizationDomain.Kaplansky | ∀ {R : Type u_1} [inst : CommSemiring R] [IsDomain R],
UniqueFactorizationMonoid R ↔ ∀ (I : Ideal R), I ≠ ⊥ → I.IsPrime → ∃ x ∈ I, Prime x | Kaplansky's criterion: an integral domain is a UFD if and only if every nonzero prime ideal
contains a prime element. | true |
SSet.Truncated.HomotopyCategory.functorEquiv._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ {X : SSet.Truncated 2} {C : Type u_1} [inst : CategoryTheory.SmallCategory C]
(φ : X ⟶ (SSet.truncation 2).obj (CategoryTheory.nerve C))
(s : X.obj (Opposite.op { obj := { len := 1 }, property := ⋯ })),
(CategoryTheory.ConcreteCategory.hom
((SSet.Truncated.HomotopyCategory.homToNerveMk (SSet.Truncated.H... | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.mk.noConfusion | Init.Data.Format.Basic | {P : Sort u} →
{foundLine foundFlattenedHardLine : Bool} →
{space : ℕ} →
{foundLine' foundFlattenedHardLine' : Bool} →
{space' : ℕ} →
{ foundLine := foundLine, foundFlattenedHardLine := foundFlattenedHardLine, space := space } =
{ foundLine := foundLine', foundFlattenedHardLi... | null | false |
ContinuousMultilinearMap.smul_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {M : Type u_1} {F : Type u_2} {α : outParam (Type u_3)} {β : outParam (Type u_4)} {inst : FunLike F α β}
{inst_1 : SMul M β} {inst_2 : SMul M F} [self : IsSMulApply M F α β] (f : F) (n : M) (x : α), (n • f) x = n • f x | **Alias** of `smul_apply`. | true |
le_liminf_add._auto_3 | Mathlib.Topology.Algebra.Order.LiminfLimsup | Lean.Syntax | null | false |
Ideal.Quotient.divisionRing._proof_7 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [inst_1 : I.IsTwoSided] [inst_2 : I.IsMaximal] (a : R ⧸ I),
a ≠ 0 → a * a⁻¹ = 1 | null | false |
Mathlib.Tactic.Rify._aux_Mathlib_Tactic_Rify___macroRules_Mathlib_Tactic_Rify_rify_1 | Mathlib.Tactic.Rify | Lean.Macro | null | false |
CategoryTheory.MonoidalCategory.rightUnitor_tensor_hom | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associato... | null | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion.0.CovariantDerivative.torsion._proof_1 | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Torsion | ∀ {𝕜 : 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] [inst_6 : IsManifold I 2 M]
(cov : Co... | null | false |
CategoryTheory.GrothendieckTopology.Cover.oneHypercover | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} → {X : C} → J.Cover X → J.OneHypercover X | The tautological 1-hypercover induced by `S : J.Cover X`. Its index type `I₀`
is given by `S.Arrow` (i.e. all the morphisms in the sieve `S`), while `I₁` is given
by all possible pullback cones. | true |
List.TProd.elim'.eq_1 | Mathlib.Data.Prod.TProd | ∀ {ι : Type u} {α : ι → Type v} {l : List ι} [inst : DecidableEq ι] (h : ∀ (i : ι), i ∈ l) (v : List.TProd α l) (i : ι),
List.TProd.elim' h v i = v.elim ⋯ | null | true |
Mathlib.Notation3.DelabKey.app | Mathlib.Util.Notation3 | Option Lean.Name → ℕ → Mathlib.Notation3.DelabKey | The key `app.const` or `app` with a specific arity. | true |
AbsoluteValue.IsAdmissible.exists_approx_aux | Mathlib.NumberTheory.ClassNumber.AdmissibleAbsoluteValue | ∀ {R : Type u_1} [inst : EuclideanDomain R] {abv : AbsoluteValue R ℤ} (n : ℕ) (h : abv.IsAdmissible) {ε : ℝ},
0 < ε →
∀ {b : R},
b ≠ 0 →
∀ (A : Fin (h.card ε ^ n).succ → Fin n → R),
∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(abv (A i₁ k % b - A i₀ k % b)) < abv b • ε | Any large enough family of vectors in `R^n` has a pair of elements
whose remainders are close together, pointwise. | true |
IsUnifLocDoublingMeasure.definition._proof_1._@.Mathlib.MeasureTheory.Covering.DensityTheorem.1554790178._hygCtx._hyg.2 | Mathlib.MeasureTheory.Covering.DensityTheorem | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] [inst_1 : MeasurableSpace α] (μ : MeasureTheory.Measure α)
[inst_2 : IsUnifLocDoublingMeasure μ] (K : ℝ),
0 < IsUnifLocDoublingMeasure.scalingScaleOf μ (max (4 * K + 3) 3) →
0 < IsUnifLocDoublingMeasure.scalingScaleOf μ (max (4 * K + 3) 3) / 4 | null | false |
integrableOn_Icc_iff_integrableOn_Ioc'._auto_3 | Mathlib.MeasureTheory.Integral.IntegrableOn | Lean.Syntax | null | false |
_private.Mathlib.NumberTheory.NumberField.Completion.FinitePlace.0.NumberField.FinitePlace.hasFiniteMulSupport_int._simp_1_1 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (w : NumberField.FinitePlace K) (x : K),
w x = ‖(NumberField.FinitePlace.embedding w.maximalIdeal) x‖ | null | false |
CategoryTheory.SpectralSequence.pageXIsoOfEq | Mathlib.Algebra.Homology.SpectralSequence.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
(E : CategoryTheory.SpectralSequence C c r₀) →
(pq : κ) →
(r r' : ℤ) →
(... | If `E` is a spectral sequence, and `r = r'`, this is the
isomorphism `(E.page r).X pq ≅ (E.page r').X pq`. | true |
MonoidHom.fst | Mathlib.Algebra.Group.Prod | (M : Type u_3) → (N : Type u_4) → [inst : MulOneClass M] → [inst_1 : MulOneClass N] → M × N →* M | Given monoids `M`, `N`, the natural projection homomorphism from `M × N` to `M`. | true |
_private.Batteries.Data.List.Lemmas.0.List.isChain_iff_getElem._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (a : α) (i : ℕ), i + 2 ≤ [a].length → i + 1 < [a].length | null | false |
Matrix.diagonalInvertibleEquivInvertible._proof_2 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u_1} {α : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (v : n → α)
(x : Invertible v), Matrix.invertibleOfDiagonalInvertible v = x | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex.0.SSet.Subcomplex.preimage_image_of_isIso._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G H : CategoryTheory.Functor C D} (α : F ⟶ G) (β : G ⟶ H) (X : C) {F_1 : D → D → Type uF} {carrier : D → Type w}
{instFunLike : (X Y : D) → FunLike (F_1 X Y) (carrier X) (carrier Y)} [inst_2 : ... | null | false |
MeasureTheory.condExp_add | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | ∀ {α : Type u_1} {E : Type u_3} {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → E}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E],
MeasureTheory.Integrable f μ →
MeasureTheory.Integrable g μ → ∀ (m : MeasurableSpace α), μ[f + g | m] =ᵐ[μ] μ[f | m] + μ[g | m] | null | true |
MeasureTheory.measure_ne_top._simp_1 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ] (s : Set α),
(μ s = ⊤) = False | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0._regBuiltin.String.reduceLE.declare_54._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.574354642._hygCtx._hyg.27 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.count_support_of_mem._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} {c : G.Walk v v}, 0 < c.support.length | null | false |
ProbabilityTheory.IsRatCondKernelCDFAux.mono' | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α × β → ℚ → ℝ}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β},
ProbabilityTheory.IsRatCondKernelCDFAux f κ ν → ∀ (a : α) {q r : ℚ}, q ≤ r → ∀ᵐ (c : β) ∂ν a, f (a, c) q ≤ f (a, c) r | null | true |
List.instSingletonList | Mathlib.Data.List.Basic | {α : Type u} → Singleton α (List α) | null | true |
UInt8.ofNatTruncate_toNat | Init.Data.UInt.Lemmas | ∀ (n : UInt8), UInt8.ofNatClamp n.toNat = n | null | true |
String.Slice.Pos.skip?_cast | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[inst_1 : String.Slice.Pattern.ForwardPattern pat] [String.Slice.Pattern.Model.LawfulForwardPatternModel pat]
{s t : String.Slice} (hst : s.copy = t.copy) {pos : s.Pos},
(pos.cast hst).skip? pat = Option.map (fun x => x.cast hst) (pos.ski... | null | true |
Std.ExtHashSet.insertMany_list_eq_empty_iff | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{l : List α}, m.insertMany l = ∅ ↔ m = ∅ ∧ l = [] | null | true |
List.forall_mem_replicate | Init.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Prop} {a : α} {n : ℕ}, (∀ b ∈ List.replicate n a, p b) ↔ n = 0 ∨ p a | null | true |
OrderMonoidIso.recOn | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : Mul α] →
[inst_3 : Mul β] →
{motive : (α ≃*o β) → Sort u} →
(t : α ≃*o β) →
((toMulEquiv : α ≃* β) →
(map_le_map_iff' : ∀ {a b : α}, toMul... | null | false |
Localization.one_rel | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} (y : ↥S), (Localization.r S) 1 (↑y, y) | null | true |
Ideal.mem_inertia | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : Ring α] {G : Type u_1} [inst_1 : Group G] [inst_2 : MulAction G α] {I : Ideal α} {σ : G},
σ ∈ Ideal.inertia G I ↔ ∀ (x : α), σ • x - x ∈ I | null | true |
MonomialOrder.degree_add_eq_right_of_lt | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {f g : MvPolynomial σ R},
m.toSyn (m.degree f) < m.toSyn (m.degree g) → m.degree (f + g) = m.degree g | null | true |
Algebra.IsIntegral.adjoin | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {S : Set A},
(∀ x ∈ S, IsIntegral R x) → Algebra.IsIntegral R ↥(Algebra.adjoin R S) | null | true |
CategoryTheory.Limits.ColimitPresentation.bind._proof_3 | Mathlib.CategoryTheory.Presentable.ColimitPresentation | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_3} {I : J → Type u_3}
[inst_1 : CategoryTheory.SmallCategory J] [inst_2 : (j : J) → CategoryTheory.SmallCategory (I j)] {X : C}
(P : CategoryTheory.Limits.ColimitPresentation J X)
(Q : (j : J) → CategoryTheory.Limits.ColimitPresentation (I... | null | false |
List.mem_zipIdx'._proof_2 | Init.Data.List.Nat.Range | ∀ {α : Type u_1} {x : α} {i : ℕ} {xs : List α}, (x, i) ∈ xs.zipIdx → i < xs.length | null | false |
Multiset.instUnion | Mathlib.Data.Multiset.UnionInter | {α : Type u_1} → [DecidableEq α] → Union (Multiset α) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.