name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.exists_iso_single._proof_1_4 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (n i : ℤ), n < i → n < i | null | false |
Std.DHashMap.Internal.mkIdx._proof_2 | Std.Data.DHashMap.Internal.Index | ∀ (sz : ℕ),
0 < sz → ∀ (hash : UInt64), ((Std.DHashMap.Internal.scrambleHash hash).toUSize &&& USize.ofNat sz - 1).toNat < sz | null | false |
IsLocalization.Away.mvPolynomialQuotientEquiv.congr_simp | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u_2} [inst : CommRing R] (S : Type u_3) [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : R)
[inst_3 : IsLocalization.Away r S],
IsLocalization.Away.mvPolynomialQuotientEquiv S r = IsLocalization.Away.mvPolynomialQuotientEquiv S r | null | true |
Hindman.FP.below.casesOn | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FP a a_1 → Prop}
{motive_1 : {a : Stream' M} → {a_1 : M} → (t : Hindman.FP a a_1) → Hindman.FP.below t → Prop} {a : Stream' M}
{a_1 : M} {t : Hindman.FP a a_1} (t_1 : Hindman.FP.below t),
(∀ (a : Stream' M), motive_1 ⋯ ⋯) →
... | null | false |
Std.HashMap.Raw.size_filter_le_size | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → Bool}, m.WF → (Std.HashMap.Raw.filter f m).size ≤ m.size | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.xor_right_inj._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Lean.Lsp.CallHierarchyItem._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CallHierarchyItem | null | false |
Associates.normalize_out | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : MonoidWithZero α] [inst_1 : NormalizationMonoid α] (a : Associates α), normalize a.out = a.out | null | true |
Locale.pt | Mathlib.Topology.Order.Category.FrameAdjunction | CategoryTheory.Functor Locale TopCat | The covariant functor `pt` from the category of locales to the category of
topological spaces, which sends a locale `L` to the topological space `PT L` of homomorphisms
from `L` to `Prop` and a locale homomorphism `f` to a continuous function between the spaces
of points. | true |
CategoryTheory.Lax.OplaxTrans.associator | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G H I : CategoryTheory.LaxFunctor B C} →
(η : F ⟶ G) →
(θ : G ⟶ H) →
(ι : H ⟶ I) →
CategoryTheory.CategoryStruct.comp (CategoryTheory... | Associator for the vertical composition of oplax natural transformations. | true |
Class.coe_empty | Mathlib.SetTheory.ZFC.Class | ↑∅ = ∅ | null | true |
nnnorm_apply_le_nnnorm_cfcₙ._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
AlgHom.tensorEqualizerEquiv_apply | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_3)
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {A : Type u_4}
{B : Type u_5} [inst_7 : CommRing A] [inst_8 : CommRing B] [inst_9 : Algebra R A] [inst_10... | null | true |
Std.Http.Status._sizeOf_inst | Std.Http.Data.Status | SizeOf Std.Http.Status | null | false |
Set.Finite.iSup_biInf_of_antitone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Preorder ι'] [Nonempty ι'] [IsCodirectedOrder ι']
[inst_3 : Order.Frame α] {s : Set ι},
s.Finite → ∀ {f : ι → ι' → α}, (∀ i ∈ s, Antitone (f i)) → ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j | null | true |
Std.Time.GenericFormat.ctorIdx | Std.Time.Format.Basic | {awareness : Std.Time.Awareness} → Std.Time.GenericFormat awareness → ℕ | null | false |
Lean.PrettyPrinter.Parenthesizer.many1NoAntiquot.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer | null | true |
Set.pi_univ_Ici | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x : (i : ι) → α i),
(Set.univ.pi fun i => Set.Ici (x i)) = Set.Ici x | null | true |
instMulDistribMulActionSubtypeMemSubmonoidNonZeroDivisors._proof_6 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {G : Type u_2} {M : Type u_1} [inst : Group G] [inst_1 : MonoidWithZero M] [inst_2 : MulDistribMulAction G M]
(m : ↥(nonZeroDivisors M)), 1 • m = m | null | false |
Homogenization.weight_eq_one_iff | Mathlib.LinearAlgebra.AffineSpace.Homogenization | ∀ {R : Type u_1} [inst : Ring R] {V : Type u_2} {P : Type u_3} [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] {x : Homogenization R P}, Homogenization.weight x = 1 ↔ ∃ p, x = Homogenization.ofPoint p | null | true |
DirSupClosedOn.mono | Mathlib.Order.DirSupClosed | ∀ {α : Type u_1} {s : Set α} {D₁ D₂ : Set (Set α)} [inst : Preorder α],
D₁ ⊆ D₂ → DirSupClosedOn D₂ s → DirSupClosedOn D₁ s | null | true |
Sym2.diagSet_compl_eq_fromRel_ne | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1}, Sym2.diagSetᶜ = Sym2.fromRel ⋯ | null | true |
List.right_sublist_interleave._f | Batteries.Data.List.Interleave | ∀ {α : Type u_1} (x : List α) (f : List.below (motive := fun x => ∀ (x_1 : List α), x_1.Sublist (x.interleave x_1)) x)
(x_1 : List α), x_1.Sublist (x.interleave x_1) | null | false |
BoxIntegral.IntegrationParams.RCond.eq_1 | Mathlib.Analysis.BoxIntegral.Partition.Filter | ∀ {ι : Type u_2} (l : BoxIntegral.IntegrationParams) (r : (ι → ℝ) → ↑(Set.Ioi 0)),
l.RCond r = (l.bRiemann = true → ∀ (x : ι → ℝ), r x = r 0) | null | true |
instFintypeWithTop._aux_1 | Mathlib.Data.Fintype.WithTopBot | {α : Type u_1} → [Fintype α] → Finset (WithTop α) | null | false |
Lean.Order.CompleteLattice.ofProp_intro_r | Std.Internal.Order.OfProp | ∀ {l : Type u_1} [inst : Lean.Order.CompleteLattice l] (p : Prop) (x y : l),
Lean.Order.PartialOrder.rel (Lean.Order.meet (Lean.Order.CompleteLattice.ofProp p) x) y =
(p → Lean.Order.PartialOrder.rel x y) | null | true |
FirstOrder.Language.LHom.IsExpansionOn.map_onFunction._autoParam | Mathlib.ModelTheory.LanguageMap | Lean.Syntax | null | false |
Lean.Elab.Term.Quotation.HeadCheck.slice.elim | Lean.Elab.Quotation | {motive : Lean.Elab.Term.Quotation.HeadCheck → Sort u} →
(t : Lean.Elab.Term.Quotation.HeadCheck) →
t.ctorIdx = 2 →
((numPrefix numSuffix : ℕ) → motive (Lean.Elab.Term.Quotation.HeadCheck.slice numPrefix numSuffix)) → motive t | null | false |
CategoryTheory.Functor.mapGrpIdIso.eq_1 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
CategoryTheory.Functor.mapGrpIdIso =
CategoryTheory.NatIso.ofComponents
(fun X => CategoryTheory.Grp.mkIso (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).mapGrp.obj X).X) ⋯ ⋯) ⋯ | null | true |
LinearMap.prodMapRingHom_apply | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (f : (M →ₗ[R] M) × (M₂ →ₗ[R] M₂)),
(LinearMap.prodMapRingHom R M M₂) f = f.1.prodMap f.2 | null | true |
LinearEquiv.mk.congr_simp | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_14} {S : Type u_15} [inst : Semiring R] [inst_1 : Semiring S] {σ : R →+* S} {σ' : S →+* R}
[inst_2 : RingHomInvPair σ σ'] [inst_3 : RingHomInvPair σ' σ] {M : Type u_16} {M₂ : Type u_17}
[inst_4 : AddCommMonoid M] [inst_5 : AddCommMonoid M₂] [inst_6 : Module R M] [inst_7 : Module S M₂]
(toLinearMap t... | null | true |
SNum.instNeg | Mathlib.Data.Num.Bitwise | Neg SNum | null | true |
ValueDistribution.circleAverage_log_norm_meromorphicTrailingCoeffAt_of_meromorphicOrderAt_eq_zero | Mathlib.Analysis.Complex.ValueDistribution.Cartan | ∀ {f : ℂ → ℂ},
meromorphicOrderAt f 0 = 0 →
Real.circleAverage (fun a => Real.log ‖meromorphicTrailingCoeffAt (fun x => f x - a) 0‖) 0 1 =
‖meromorphicTrailingCoeffAt f 0‖.posLog | Circle average of the function `fun a ↦ log ‖meromorphicTrailingCoeffAt (f · - a) 0‖` that appears
in Cartan's formula, in the case where `f` has order zero at the origin.
| true |
AddUnits.addAction'._proof_3 | Mathlib.Algebra.Group.Action.Units | ∀ {G : Type u_2} {M : Type u_1} [inst : AddGroup G] [inst_1 : AddMonoid M] [inst_2 : AddAction G M]
[inst_3 : VAddCommClass G M M] [inst_4 : VAddAssocClass G M M] (x x_1 : G) (x_2 : AddUnits M),
(x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 | null | false |
NNRat.divNat._proof_1 | Mathlib.Data.NNRat.Defs | ∀ (n d : ℕ), 0 ≤ Rat.divInt ↑n ↑d | null | false |
Filter.tendsto_sup | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y ↔ Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y | null | true |
jacobiSym.mod_right | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (a : ℤ) {b : ℕ}, Odd b → jacobiSym a b = jacobiSym a (b % (4 * a.natAbs)) | The Jacobi symbol `J(a | b)` depends only on `b` mod `4*a`. | true |
variationOnFromTo.rightLim_eq | Mathlib.Topology.EMetricSpace.VariationOnFromTo | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_4} [inst_1 : PseudoMetricSpace E] [CompleteSpace E] {f : α → E}
{a b : α},
BoundedVariationOn f Set.univ →
Function.rightLim (variationOnFromTo f Set.univ a) b =
variationOnFromTo f Set.univ a b + dist (f b) (Function.rightLim f b) | The jump of `variationOnFromTo` on the right of a point is given by the distance between the
right limit and the value of the function. | true |
Finset.single_le_sum_of_canonicallyOrdered | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : Preorder M] [CanonicallyOrderedAdd M] {f : ι → M}
{s : Finset ι} {i : ι}, i ∈ s → f i ≤ ∑ j ∈ s, f j | In a canonically-ordered additive monoid, a sum bounds each of its terms.
See also `Finset.single_le_sum`. | true |
CategoryTheory.FreeBicategory.liftHom.match_1 | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u_1} →
[inst : Quiver B] →
(motive : (x x_1 : CategoryTheory.FreeBicategory B) → (x ⟶ x_1) → Sort u_3) →
(x x_1 : CategoryTheory.FreeBicategory B) →
(x_2 : x ⟶ x_1) →
((x x_3 : B) → (f : x ⟶ x_3) → motive x x_3 (CategoryTheory.FreeBicategory.Hom.of f)) →
((a : B) → mo... | null | false |
summable_of_sum_range_le | Mathlib.Topology.Algebra.InfiniteSum.Real | ∀ {f : ℕ → ℝ} {c : ℝ}, (∀ (n : ℕ), 0 ≤ f n) → (∀ (n : ℕ), ∑ i ∈ Finset.range n, f i ≤ c) → Summable f | null | true |
Bimod.TensorBimod.actRight._proof_4 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{R S T : CategoryTheory.Mon C} (P : Bimod R S) (Q : Bimod S T)
[∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorRight X... | null | false |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.f'_eq | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
(hkf : CategoryTheory.Limits.IsLimit kf),
hkf.lift (CategoryTheory.Limits.KernelFork.ofι S.f ⋯) =
CategoryTheory.CategoryStruct.comp S.to... | null | true |
Finset.expect | Mathlib.Algebra.BigOperators.Expect | {ι : Type u_1} → {M : Type u_4} → [inst : AddCommMonoid M] → [Module ℚ≥0 M] → Finset ι → (ι → M) → M | Average of a function over a finset. If the finset is empty, this is equal to zero. | true |
_private.Mathlib.Topology.ContinuousOn.0.continuousOn_singleton._simp_1_2 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α} {l : Filter β}, Filter.Tendsto f (pure a) l = ∀ s ∈ l, f a ∈ s | null | false |
CategoryTheory.GradedObject.isInitialSingleObjApply._proof_1 | Mathlib.CategoryTheory.GradedObject.Single | ∀ {J : Type u_3} {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Limits.HasInitial C] [inst_2 : DecidableEq J] (j : J) (X : C) (i : J),
i ≠ j → CategoryTheory.Limits.IsInitial (if i = j then X else ⊥_ C) = CategoryTheory.Limits.IsInitial (⊥_ C) | null | false |
iInf_singleton | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {b : β}, ⨅ x ∈ {b}, f x = f b | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Φ_neg._simp_1_5 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a | null | false |
instFintypeWithTop | Mathlib.Data.Fintype.WithTopBot | {α : Type u_1} → [Fintype α] → Fintype (WithTop α) | null | true |
_private.Mathlib.CategoryTheory.Generator.Basic.0.CategoryTheory.ObjectProperty.IsCoseparating.isCodetecting._simp_1_2 | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.ObjectProperty C),
P.IsCoseparating = P.op.IsSeparating | null | false |
Finite.card_eq_zero_of_surjective | Mathlib.SetTheory.Cardinal.NatCard | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Surjective f → Nat.card β = 0 → Nat.card α = 0 | NB: `Nat.card` is defined to be `0` for infinite types. | true |
Std.ExtDHashMap.Const.get?_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] {f : α → β → Option γ} {k : α},
Std.ExtDHashMap.Const.get? (Std.ExtDHashMap.filterMap f m) k =
(Std.ExtDHashMap.Const.get? m k).pbind fun x_2 h' => f (m.getK... | null | true |
Vector.toList_map | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {xs : Vector α n}, (Vector.map f xs).toList = List.map f xs.toList | null | true |
Option.min_eq_some_iff._simp_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Min α] {o o' : Option α} {a : α},
(o ⊓ o' = some a) = ∃ b c, o = some b ∧ o' = some c ∧ b ⊓ c = a | null | false |
fourierSubalgebra_coe | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ}, Subalgebra.toSubmodule fourierSubalgebra.toSubalgebra = Submodule.span ℂ (Set.range fourier) | The star subalgebra of `C(AddCircle T, ℂ)` generated by `fourier n` for `n ∈ ℤ` is in fact the
linear span of these functions. | true |
AlgebraicGeometry.Spec.map_surjective | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | ∀ {R S : CommRingCat}, Function.Surjective AlgebraicGeometry.Spec.map | Useful for replacing `f` by `Spec.map φ` everywhere in proofs. | true |
FreeMonoid.map._proof_2 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x x_1 : FreeMonoid α),
List.map f (FreeMonoid.toList x ++ FreeMonoid.toList x_1) =
List.map f (FreeMonoid.toList x) ++ List.map f (FreeMonoid.toList x_1) | null | false |
Std.CloseableChannel.Error.alreadyClosed | Std.Sync.Channel | Std.CloseableChannel.Error | Tried to close an already closed channel.
| true |
_private.Mathlib.Analysis.Analytic.Within.0.hasFPowerSeriesWithinAt_iff_exists_hasFPowerSeriesAt._simp_1_10 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c < min a b) = (c < a ∧ c < b) | null | false |
MeasureTheory.Lp.coe_posPart._simp_1 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} (f : ↥(MeasureTheory.Lp ℝ p μ)),
(↑f).posPart = ↑(MeasureTheory.Lp.posPart f) | null | false |
CategoryTheory.mono_iff_injective | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} (f : X ⟶ Y), CategoryTheory.Mono f ↔ Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom f) | A morphism in `Type` is a monomorphism if and only if it is injective. | true |
ENNReal.tendsto_nat_tsum | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ (f : ℕ → ENNReal), Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (nhds (∑' (n : ℕ), f n)) | null | true |
Std.DTreeMap.Internal.Impl.getKey_insertMany!_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {l : List ((a : α) × β a)} {k k' : α},
compare k k' = Ordering.eq →
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l →
∀ {... | null | true |
Std.Do.Spec.seq' | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {P : Std.Do.Assertion ps} [inst : Monad m]
[inst_1 : Std.Do.WPMonad m ps] {α β : Type u} {x : m (α → β)} {y : m α} {Q : Std.Do.PostCond β ps},
⦃P⦄ x ⦃(fun f => (Std.Do.wp y).apply (fun a => Q.1 (f a), Q.2), Q.2)⦄ → ⦃P⦄ (x <*> y) ⦃Q⦄ | null | true |
Lean.MetavarContext.getDelayedMVarAssignmentCore? | Lean.MetavarContext | Lean.MetavarContext → Lean.MVarId → Option Lean.DelayedMetavarAssignment | null | true |
Std.DTreeMap.mem_of_mem_insert | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k a : α}
{v : β k}, a ∈ t.insert k v → cmp k a ≠ Ordering.eq → a ∈ t | null | true |
MvPowerSeries.rescaleMonoidHom._proof_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (a b : σ → R),
MvPowerSeries.rescale (a * b) = MvPowerSeries.rescale a * MvPowerSeries.rescale b | null | false |
MeasureTheory.ennrealPreVariation.congr_simp | Mathlib.MeasureTheory.Measure.PreVariation | ∀ {X : Type u_1} [inst : MeasurableSpace X] (f f_1 : Set X → ENNReal) (e_f : f = f_1)
(hf : MeasureTheory.IsSigmaSubadditiveSetFun f) (hf' : f ∅ = 0),
MeasureTheory.ennrealPreVariation f hf hf' = MeasureTheory.ennrealPreVariation f_1 ⋯ ⋯ | null | true |
integral_sin_pow_aux | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ} (n : ℕ),
∫ (x : ℝ) in a..b, Real.sin x ^ (n + 2) =
(Real.sin a ^ (n + 1) * Real.cos a - Real.sin b ^ (n + 1) * Real.cos b +
(↑n + 1) * ∫ (x : ℝ) in a..b, Real.sin x ^ n) -
(↑n + 1) * ∫ (x : ℝ) in a..b, Real.sin x ^ (n + 2) | null | true |
thickenedIndicator.congr_simp | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {δ δ_1 : ℝ} (e_δ : δ = δ_1) (δ_pos : 0 < δ) (E E_1 : Set α),
E = E_1 → thickenedIndicator δ_pos E = thickenedIndicator ⋯ E_1 | null | true |
Ordinal.instCountableToTypeGammaOfNat | Mathlib.SetTheory.Ordinal.Veblen | Countable (Ordinal.gamma 0).ToType | null | true |
Representation.Coinvariants.mk_tmul_inv | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} {W : Type u_9} [inst : CommRing k] [inst_1 : Group G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
(ρ : Representation k G V) (τ : Representation k G W) (x : V) (y : W) (g : G),
(Representation.Coinvariants.mk (ρ.tpr... | null | true |
CategoryTheory.ParametrizedAdjunction.preservesLimit_flip_obj | Mathlib.CategoryTheory.Adjunction.ParametrizedLimits | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor... | null | true |
Finpartition.ofErase.congr_simp | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {a : α} (parts parts_1 : Finset α)
(e_parts : parts = parts_1) (sup_indep : parts.SupIndep id) (sup_parts : parts.sup id = a),
Finpartition.ofErase parts sup_indep sup_parts = Finpartition.ofErase parts_1 ⋯ ⋯ | null | true |
ClassGroup.mk._proof_1 | Mathlib.RingTheory.ClassGroup.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R], (toPrincipalIdeal R (FractionRing R)).range.Normal | null | false |
NonarchimedeanGroup.mk._flat_ctor | Mathlib.Topology.Algebra.Nonarchimedean.Basic | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G],
(Continuous fun p => p.1 * p.2) → (Continuous fun a => a⁻¹) → (∀ U ∈ nhds 1, ∃ V, ↑V ⊆ U) → NonarchimedeanGroup G | null | false |
Lean.Name.hasMacroScopes._unsafe_rec | Init.Prelude | Lean.Name → Bool | null | false |
Lean.Diff.Action.skip | Lean.Util.Diff | Lean.Diff.Action | Leave the item in the source | true |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.Candidates.grw.noConfusion | Mathlib.Tactic.ClickSuggestions.TryPremises | {P : Sort u} →
{i : Mathlib.Tactic.ClickSuggestions.GrwInfo} →
{arr : Array Mathlib.Tactic.ClickSuggestions.GrwLemma} →
{i' : Mathlib.Tactic.ClickSuggestions.GrwInfo} →
{arr' : Array Mathlib.Tactic.ClickSuggestions.GrwLemma} →
Mathlib.Tactic.ClickSuggestions.Candidates.grw✝ i arr =
... | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.ofNat_sub_ofNat_of_le._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : ℕ), y < 2 ^ w → y ≤ x → ¬2 ^ w - y + x = 2 ^ w + (x - y) → False | null | false |
instMinInt16 | Init.Data.SInt.Basic | Min Int16 | null | true |
MeasureTheory.OuterMeasure.instLawfulFunctor | Mathlib.MeasureTheory.OuterMeasure.Operations | LawfulFunctor MeasureTheory.OuterMeasure | null | true |
Condensed.StoneanProfinite.stoneanToProfiniteEffectivePresentation._proof_5 | Mathlib.Condensed.Equivalence | 2 ≠ 0 | null | false |
NonemptyFinLinOrd.hom_hom_ofHom | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ {X Y : Type u} [inst : Nonempty X] [inst_1 : LinearOrder X] [inst_2 : Fintype X] [inst_3 : Nonempty Y]
[inst_4 : LinearOrder Y] [inst_5 : Fintype Y] (f : X →o Y), LinOrd.Hom.hom (NonemptyFinLinOrd.ofHom f).hom = f | null | true |
ProbabilityTheory.condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | {α : Type u_1} → {mα : MeasurableSpace α} → MeasureTheory.Measure (α × ℝ) → α → StieltjesFunction ℝ | Conditional cdf of the measure given the value on `α`, as a Stieltjes function. | true |
Nat.Weird.pos | Mathlib.NumberTheory.FactorisationProperties | ∀ {n : ℕ}, n.Weird → 0 < n | null | true |
ExceptCpsT.runCatch | Init.Control.ExceptCps | {m : Type u_1 → Type u_2} → {α : Type u_1} → [Monad m] → ExceptCpsT α m α → m α | Returns the value of a computation, forgetting whether it was an exception or a success.
This corresponds to early return.
| true |
_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff.mk.injEq | Lean.Widget.Diff | ∀ (changesBefore changesAfter changesBefore_1 changesAfter_1 : Lean.SubExpr.PosMap Lean.Widget.ExprDiffTag✝),
({ changesBefore := changesBefore, changesAfter := changesAfter } =
{ changesBefore := changesBefore_1, changesAfter := changesAfter_1 }) =
(changesBefore = changesBefore_1 ∧ changesAfter = changesA... | null | true |
NumberField.instCommRingInfiniteAdeleRing | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | (K : Type u_1) → [inst : Field K] → CommRing (NumberField.InfiniteAdeleRing K) | null | true |
Equivalence.of_isEquiv | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} (lt : α → α → Prop) [IsEquiv α lt], Equivalence lt | null | true |
Lean.Compiler.LCNF.FloatLetIn.Decision.recOn | Lean.Compiler.LCNF.FloatLetIn | {motive : Lean.Compiler.LCNF.FloatLetIn.Decision → Sort u} →
(t : Lean.Compiler.LCNF.FloatLetIn.Decision) →
((name : Lean.Name) → motive (Lean.Compiler.LCNF.FloatLetIn.Decision.arm name)) →
motive Lean.Compiler.LCNF.FloatLetIn.Decision.default →
motive Lean.Compiler.LCNF.FloatLetIn.Decision.dont →
... | null | false |
_private.Mathlib.CategoryTheory.MorphismProperty.LocalClosure.0.CategoryTheory.MorphismProperty.sourceLocalClosure.sourceLocalClosure_iff_of_respectsLeft.match_1_9 | Mathlib.CategoryTheory.MorphismProperty.LocalClosure | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {K : CategoryTheory.Precoverage C}
{P : CategoryTheory.MorphismProperty C} {X Y : C} {f : X ⟶ Y}
(motive : (∃ R ∈ K.coverings X, ∀ (U : C) (g : U ⟶ X), R g → P (CategoryTheory.CategoryStruct.comp g f)) → Prop)
(h : ∃ R ∈ K.coverings X, ∀ (U : C) (g : ... | null | false |
Seminorm.instSeminormClass | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : SMul 𝕜 E],
SeminormClass (Seminorm 𝕜 E) 𝕜 E | null | true |
AddCircle.denseRange_zsmul_iff | Mathlib.Topology.Instances.AddCircle.DenseSubgroup | ∀ {p : ℝ} [Fact (0 < p)] {a : AddCircle p}, (DenseRange fun x => x • a) ↔ addOrderOf a = 0 | The multiples of a number `a` are dense on a circle of length `p > 0`
iff `a` has infinite additive order. | true |
Multiset.equivDFinsupp._proof_2 | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α], Multiset.toDFinsupp.comp DFinsupp.toMultiset = AddMonoidHom.id (Π₀ (x : α), ℕ) | null | false |
Std.HashMap.Raw.getKeyD_inter_of_not_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k fallback : α}, k ∉ m₂ → (m₁ ∩ m₂).getKeyD k fallback = fallback | null | true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.1488711282._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
MeasureTheory.LocallyIntegrable.integrable_of_isBigO_atTop_of_norm_isNegInvariant | Mathlib.MeasureTheory.Integral.Asymptotics | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] {f : α → E} {g : α → F}
[inst_1 : TopologicalSpace α] [SecondCountableTopology α] [inst_3 : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_4 : NormedAddCommGroup F] [inst_5 : AddCommGroup α] [inst_6 : LinearOrder α] [IsOrderedAddMo... | If `f` is locally integrable, `‖f(-x)‖ = ‖f(x)‖`, and `f =O[atTop] g`, for some
`g` integrable at `atTop`, then `f` is integrable. | true |
Representation.norm_self_apply | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Group G] [inst_2 : Fintype G]
[inst_3 : AddCommMonoid V] [inst_4 : Module k V] (ρ : Representation k G V) (g : G) (x : V),
ρ.norm ((ρ g) x) = ρ.norm x | null | true |
WithCStarModule.instUnique | Mathlib.Analysis.CStarAlgebra.Module.Synonym | (A : Type u_3) → (E : Type u_4) → [Unique E] → Unique (WithCStarModule A E) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.