name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Basic.0.Lean.Meta.lambdaMetaTelescope.process.match_1 | Lean.Meta.Basic | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((binderName : Lean.Name) → (d b : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.lam binderName d b bi)) →
((x : Lean.Expr) → motive x) → motive type | null | false |
MvPolynomial.degrees_one | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], MvPolynomial.degrees 1 = 0 | null | true |
Real.not_summable_indicator_one_div_natCast | Mathlib.Analysis.PSeries | ∀ {m : ℕ}, m ≠ 0 → ∀ (k : ZMod m), ¬Summable ({n | ↑n = k}.indicator fun n => 1 / ↑n) | The harmonic series restricted to a residue class is not summable. | true |
CategoryTheory.Limits.biproduct.isLimit | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(F : J → C) →
[inst_2 : CategoryTheory.Limits.HasBiproduct F] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.biproduct.bicone F).toCone | `biproduct.bicone F` is a limit cone. | true |
QuasispectrumRestricts.nonUnitalStarAlgHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | {R : Type u} →
{S : Type v} →
{A : Type w} →
[inst : Semifield R] →
[inst_1 : StarRing R] →
[inst_2 : TopologicalSpace R] →
[inst_3 : IsTopologicalSemiring R] →
[inst_4 : ContinuousStar R] →
[inst_5 : Field S] →
[inst_6 : StarRing... | If the quasispectrum of an element restricts to a smaller scalar ring, then a non-unital
continuous functional calculus over the larger scalar ring descends to the smaller one. | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.disjoint_filter_pairs_lt_filter_pairs_eq | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (σ : Type u_1) [inst : DecidableEq σ] [inst_1 : Fintype σ] (k : ℕ),
Disjoint ({t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k | t.1.card < k})
({t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k | t.1.card = k}) | null | true |
EStateM.Result.map_error | Batteries.Lean.EStateM | ∀ {ε σ α β : Type u_1} (f : α → β) (e : ε) (s : σ),
EStateM.Result.map f (EStateM.Result.error e s) = EStateM.Result.error e s | null | true |
DFinsupp.mkAddGroupHom | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{β : ι → Type v} →
[DecidableEq ι] → [inst : (i : ι) → AddGroup (β i)] → (s : Finset ι) → ((i : ↑↑s) → β ↑i) →+ Π₀ (i : ι), β i | If `s` is a subset of `ι` then `mk_addGroupHom s` is the canonical additive
group homomorphism from $\prod_{i\in s}\beta_i$ to $\prod_{\mathtt{i : \iota}}\beta_i$. | true |
MonoidHom.noncommPiCoprod.eq_1 | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {M : Type u_1} [inst : Monoid M] {ι : Type u_2} [inst_1 : Fintype ι] {N : ι → Type u_3}
[inst_2 : (i : ι) → Monoid (N i)] (ϕ : (i : ι) → N i →* M)
(hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)),
MonoidHom.noncommPiCoprod ϕ hcomm =
{ toFun := fun f => Finset.univ.noncommProd... | null | true |
MulEquiv.monoidHomCongrLeftEquiv._proof_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M₁ : Type u_1} {M₂ : Type u_3} {N : Type u_2} [inst : MulOneClass M₁] [inst_1 : MulOneClass M₂] [inst_2 : Monoid N]
(e : M₁ ≃* M₂) (f : M₁ →* N), (fun f => f.comp e.toMonoidHom) ((fun f => f.comp e.symm.toMonoidHom) f) = f | null | false |
Pi.involutiveNeg._proof_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → InvolutiveNeg (f i)] (x : (i : I) → f i), - -x = x | null | false |
String.Slice.SplitIterator.instIteratorIdSubslice._proof_7 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] {pat : ρ}
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat σ] {s : String.Slice} (currPos : s.Pos)
(searcher searcher' : Std.Iter (String.Slice.Pattern.SearchStep s)) (startPos endPos... | null | false |
_private.Lean.DefEqAttrib.0.Lean.withEqLhsRhs.match_1 | Lean.DefEqAttrib | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs rhs : Lean.Expr) → motive (some (fst, lhs, rhs))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x | null | false |
abs_eq_abs | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] {a b : α}, |a| = |b| ↔ a = b ∨ a = -b | null | true |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.continuous_dom_pi._simp_1_4 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_minKey!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
UInt32.and_not_self | Init.Data.UInt.Bitwise | ∀ {a : UInt32}, a &&& ~~~a = 0 | null | true |
OrderRingHom | Mathlib.Algebra.Order.Hom.Ring | (α : Type u_6) →
(β : Type u_7) → [NonAssocSemiring α] → [Preorder α] → [NonAssocSemiring β] → [Preorder β] → Type (max u_6 u_7) | `OrderRingHom α β`, denoted `α →+*o β`,
is the type of monotone semiring homomorphisms from `α` to `β`.
When possible, instead of parametrizing results over `(f : OrderRingHom α β)`,
you should parametrize over `(F : Type*) [OrderRingHomClass F α β] (f : F)`.
When you extend this structure, make sure to extend `Order... | true |
Std.DTreeMap.Internal.Impl.minView.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hl_2 : Std.DTreeMap.Internal.Impl.leaf.Balanced)
(hlr_2 : Std.DTreeMap.Internal.Impl.BalancedAtRoot Std.DTreeMap.Internal.Impl.leaf.size r.size),
Std.DTreeMap.Internal.Impl.minView k v Std.DTreeMap.Internal.I... | null | true |
TopCat.effectiveEpiStructOfQuotientMap._proof_2 | Mathlib.Topology.Category.TopCat.EffectiveEpi | ∀ {B X : TopCat} (π : X ⟶ B) {W : TopCat} (e : X ⟶ W),
(∀ {Z : TopCat} (g₁ g₂ : Z ⟶ X),
CategoryTheory.CategoryStruct.comp g₁ π = CategoryTheory.CategoryStruct.comp g₂ π →
CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e) →
∀ (a b : ↑X),
(CategoryTheory.Concret... | null | false |
NormedAddGroup.induced._proof_7 | Mathlib.Analysis.Normed.Group.Basic | ∀ {𝓕 : Type u_3} (E : Type u_1) (F : Type u_2) [inst : FunLike 𝓕 E F] [inst_1 : NormedAddGroup F] (f : 𝓕),
Function.Injective ⇑f → ∀ {x y : E}, dist x y = 0 → x = y | null | false |
IsUltrametricDist.closedBall_openSubgroup._proof_3 | Mathlib.Analysis.Normed.Group.Ultra | ∀ (S : Type u_1) [inst : SeminormedGroup S] {r : ℝ} {x : S}, x ∈ Metric.closedBall 1 r → x⁻¹ ∈ Metric.closedBall 1 r | null | false |
OpenSubgroup.mem_inf._simp_2 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] {U V : OpenSubgroup G} {x : G},
(x ∈ U ⊓ V) = (x ∈ U ∧ x ∈ V) | null | false |
Std.DHashMap.Raw.contains_inter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {k : α}, m₁.WF → m₂.WF → (m₁ ∩ m₂).contains k = (m₁.contains k && m₂.contains k) | null | true |
_private.Mathlib.Algebra.DirectSum.Basic.0.DirectSum.id._proof_3 | Mathlib.Algebra.DirectSum.Basic | ∀ (M : Type u_2) (ι : Type u_1) [inst : AddCommMonoid M] [inst_1 : Unique ι] (x y : DirectSum ι fun i => M),
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) x) = x →
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) y) = y →
(Dire... | null | false |
Lean.EffectiveImport.mk.noConfusion | Lean.Environment | {P : Sort u} →
{toImport : Lean.Import} →
{irPhases : Lean.IRPhases} →
{hasData : Bool} →
{toImport' : Lean.Import} →
{irPhases' : Lean.IRPhases} →
{hasData' : Bool} →
{ toImport := toImport, irPhases := irPhases, hasData := hasData } =
{ toImpor... | null | false |
Set.Ioi_insert | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, insert a (Set.Ioi a) = Set.Ici a | null | true |
Lean.Compiler.LCNF.MonadCodeBind.recOn | Lean.Compiler.LCNF.Bind | {m : Type → Type} →
{motive : Lean.Compiler.LCNF.MonadCodeBind m → Sort u} →
(t : Lean.Compiler.LCNF.MonadCodeBind m) →
((codeBind :
{pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu →
(Lean.FVarId → m (Lean.Compiler.LCNF.Code pu)) → m (Lean.Compiler.LCN... | null | false |
_private.Mathlib.MeasureTheory.Measure.Restrict.0.MeasureTheory.ae_restrict_iff₀._simp_1_3 | Mathlib.MeasureTheory.Measure.Restrict | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
CategoryTheory.SmallObject.SuccStruct.Iteration.mkOfLimit._proof_1 | Mathlib.CategoryTheory.SmallObject.Iteration.Nonempty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {Φ : CategoryTheory.SmallObject.SuccStruct C}
{J : Type u_3} [inst_1 : LinearOrder J] [inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] {j : J} (hj : Order.IsSuccLimit j)
(... | null | false |
CategoryTheory.DifferentialObject.Hom.mk.congr_simp | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_1} [inst : AddMonoidWithOne S] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S]
{X Y : CategoryTheory.DifferentialObject S C} (f f_1 : X.obj ⟶ Y.obj) (e_f : f = f_1)
(comm :
CategoryTheory.Category... | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.alterKey_cons_perm.match_1.splitter | Std.Data.Internal.List.Associative | {α : Type u_3} →
{β : α → Type u_1} →
{k : α} →
(motive : Option (β k) → Sort u_2) →
(x : Option (β k)) → (Unit → motive none) → ((v : β k) → motive (some v)) → motive x | null | true |
ComplexShape.Embedding.extendFunctor_obj | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') (C : Type u_3)
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c),
(e.extendFunctor C).obj ... | null | true |
GradedAlgebra.algebraMap_apply | Mathlib.RingTheory.GradedAlgebra.TensorProduct | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : DecidableEq ι] [inst_4 : AddCommMonoid ι] [inst_5 : CommSemiring A]
[inst_6 : Algebra R A] (𝒜 : ι → Submodule R A) [inst_7 : GradedAlgebra 𝒜] (x : ↥(Submodule.baseChange... | null | true |
WittVector.truncateFun_add | Mathlib.RingTheory.WittVector.Truncated | ∀ {p : ℕ} (n : ℕ) {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (x y : WittVector p R),
WittVector.truncateFun n (x + y) = WittVector.truncateFun n x + WittVector.truncateFun n y | null | true |
ite_true_left | Init.PropLemmas | ∀ {p q : Prop} [h : Decidable p], (if p then True else q) ↔ ¬p → q | null | true |
Pi.vaddAssocClass | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} {α : ι → Type u_4} [inst : VAdd M N] [inst_1 : (i : ι) → VAdd N (α i)]
[inst_2 : (i : ι) → VAdd M (α i)] [∀ (i : ι), VAddAssocClass M N (α i)], VAddAssocClass M N ((i : ι) → α i) | null | true |
instPseudoEMetricSpaceULift | Mathlib.Topology.EMetricSpace.Defs | {α : Type u_2} → [PseudoEMetricSpace α] → PseudoEMetricSpace (ULift.{u_3, u_2} α) | null | true |
Action.forget._proof_2 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (G : Type u_3) [inst_1 : Monoid G] {X Y Z : Action V G}
(f : X ⟶ Y) (g : Y ⟶ Z), (CategoryTheory.CategoryStruct.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom | null | false |
Subadditive.eq_1 | Mathlib.Analysis.Subadditive | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Add β] [inst_2 : LE β] (u : α → β),
Subadditive u = ∀ (m n : α), u (m + n) ≤ u m + u n | null | true |
_private.Mathlib.CategoryTheory.Presentable.Comma.0.CategoryTheory.Comma.isCardinalAccessibleCategory.J.snd | Mathlib.CategoryTheory.Presentable.Comma | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : 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} D] →
{F₁ : CategoryTheory.Functor C₁ D} →
{F₂ : CategoryTheory.Fun... | The map `J κ f → J₂ κ f` which extracts the second part. | true |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.dvd_C_mul.match_1_1 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u_1} {a : R} [inst : Field R] {p q : Polynomial R} (motive : p ∣ Polynomial.C a * q → Prop)
(x : p ∣ Polynomial.C a * q), (∀ (r : Polynomial R) (hr : Polynomial.C a * q = p * r), motive ⋯) → motive x | null | false |
Std.Sat.AIG.denote._proof_4 | Std.Sat.AIG.Basic | ∀ {α : Type} (x : ℕ) (decls : Array (Std.Sat.AIG.Decl α)),
x < decls.size → ∀ (lhs rhs : Std.Sat.AIG.Fanin), lhs.gate < x ∧ rhs.gate < x → rhs.gate < decls.size | null | false |
Antitone.lowerBounds_range_comp_tendsto_atTop | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : Preorder γ] {l : Filter α} [l.NeBot]
{f : β → γ},
Antitone f →
∀ {g : α → β}, Filter.Tendsto g l Filter.atTop → lowerBounds (Set.range (f ∘ g)) = lowerBounds (Set.range f) | If `f` is an antitone function and `g` tends to `atTop` along a nontrivial filter.
then the upper bounds of the range of `f ∘ g`
are the same as the upper bounds of the range of `f`. | true |
CategoryTheory.ProjectiveResolution.isoExt._proof_4 | Mathlib.CategoryTheory.Abelian.Ext | ∀ {R : Type u_2} [inst : Ring R] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.Linear R C] {X : C}
(P : CategoryTheory.ProjectiveResolution X) (n : ℕ) (Y : C),
(HomologicalComplex.sc (P.complex.linearYonedaObj R Y) n).HasHomology | null | false |
Int.natAbs_inj_of_nonpos_of_nonneg | Mathlib.Data.Int.Lemmas | ∀ {a b : ℤ}, a ≤ 0 → 0 ≤ b → (a.natAbs = b.natAbs ↔ -a = b) | null | true |
LinearMap.BilinForm.Isometry.rec | Mathlib.LinearAlgebra.BilinearForm.Isometry | {R : Type u_1} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M₁] →
[inst_4 : Module R M₂] →
{B₁ : LinearMap.BilinForm R M₁} →
{B₂ : L... | null | false |
Nat.coprime_of_dvd' | Mathlib.Data.Nat.Prime.Basic | ∀ {m n : ℕ}, (∀ (k : ℕ), Nat.Prime k → k ∣ m → k ∣ n → k ∣ 1) → m.Coprime n | null | true |
Set.univ_inter | Mathlib.Data.Set.Basic | ∀ {α : Type u} (a : Set α), Set.univ ∩ a = a | null | true |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula.0.ModularForm.sturm_bound_levelOne_nat._simp_1_1 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, (f = g) = ∀ (x : α), f x = g x | null | false |
CategoryTheory.Functor.splitMonoCategoryImpOfIsEquivalence | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [F.IsEquivalence] [CategoryTheory.SplitMonoCategory C],
CategoryTheory.SplitMonoCategory D | If `F : C ⥤ D` is an equivalence of categories and `C` is a `SplitMonoCategory`,
then `D` also is. | true |
PreTilt.mk_comp_untilt_eq_coeff_zero | Mathlib.RingTheory.Perfectoid.Untilt | ∀ {O : Type u_1} [inst : CommRing O] {p : ℕ} [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p]
[inst_3 : IsAdicComplete (Ideal.span {↑p}) O],
⇑(Ideal.Quotient.mk (Ideal.span {↑p})) ∘ ⇑PreTilt.untilt = ⇑(PreTilt.coeff 0) | The composition of the mod `p` map
with the untilt function equals taking the zeroth component of the perfection.
A variation of `PreTilt.mk_untilt_eq_coeff_zero`.
| true |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.pIntegral._proof_1 | Mathlib.NumberTheory.Bernoulli | IsOrderedCancelMonoid (Multiplicative ℤ) | null | false |
Topology.WithScott.instPreorder | Mathlib.Topology.Order.ScottTopology | {α : Type u_1} → [Preorder α] → Preorder (Topology.WithScott α) | null | true |
Array.all_eq_false' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α}, as.all p = false ↔ ∃ x ∈ as, ¬p x = true | Variant of `all_eq_false` in terms of membership rather than an array index. | true |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithInitial.coconeBack._proof_7 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {J : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Under X)}
(X_1 : CategoryTheory.Limits.Cocone (CategoryTheory.WithInitial.liftFromUnder.obj K)),
{ hom := CategoryTheory.Under.homMk (... | null | false |
CategoryTheory.Limits.CompleteLattice.hasColimits_of_completeLattice | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u} [inst : CompleteLattice α], CategoryTheory.Limits.HasColimitsOfSize.{w, w', u, u} α | null | true |
nhds_bot_basis | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : OrderBot α] [OrderTopology α]
[Nontrivial α], (nhds ⊥).HasBasis (fun a => ⊥ < a) fun a => Set.Iio a | null | true |
Set.sInter_subset_of_mem | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, t ∈ S → ⋂₀ S ⊆ t | null | true |
CategoryTheory.Limits.HasColimit.isoOfNatIso_ι_inv_assoc | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
[inst_3 : CategoryTheory.Limits.HasColimit G] (w : F ≅ G) (j : J) {Z : C} (h : CategoryTheory.Limits.colimit F ⟶ Z),
... | **Alias** of `CategoryTheory.Limits.HasColimit.ι_isoOfNatIso_inv_assoc`. | true |
_private.Mathlib.Tactic.ProxyType.0.Mathlib.ProxyType.defaultMkProxyType.mkCType._f | Mathlib.Tactic.ProxyType | (Lean.Expr → Lean.Elab.TermElabM Lean.Expr) →
(ctypes : List Lean.Expr) → List.below ctypes → Lean.Elab.TermElabM (Lean.Expr × Lean.TSyntax `tactic) | null | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.foldrM.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(x : δ) (x_1 : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldrM f x x_1 =
match x, x_1 with
| d, Std.DHashMap.Internal.AssocList.nil => pure d
| d, Std.DHashMap.... | null | true |
_private.Mathlib.Tactic.Inclusion.Core.Elab.0.Inclusion.collectInclusionArgs.match_1 | Mathlib.Tactic.Inclusion.Core.Elab | (motive : Option Inclusion.InclusionParamDecl → Sort u_1) →
(x : Option Inclusion.InclusionParamDecl) →
((decl : Inclusion.InclusionParamDecl) → motive (some decl)) →
((x : Option Inclusion.InclusionParamDecl) → motive x) → motive x | null | false |
Lean.Json.brecOn_2.eq | Lean.Data.Json.Basic | ∀ {motive_1 : Lean.Json → Sort u} {motive_2 : Array Lean.Json → Sort u}
{motive_3 : Std.TreeMap.Raw String Lean.Json compare → Sort u} {motive_4 : List Lean.Json → Sort u}
{motive_5 : Std.DTreeMap.Raw String (fun x => Lean.Json) compare → Sort u}
{motive_6 : (Std.DTreeMap.Internal.Impl String fun x => Lean.Json) ... | null | true |
Real.holderTriple_iff | Mathlib.Basic.Real.ConjExponents | ∀ (p q r : ℝ), p.HolderTriple q r ↔ p⁻¹ + q⁻¹ = r⁻¹ ∧ 0 < p ∧ 0 < q | null | true |
Lean.Elab.Tactic.Conv.getRhs | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.TacticM Lean.Expr | null | true |
MeasureTheory.Measure.innerRegularWRT_preimage_one_hasCompactSupport_measure_ne_top_of_group | Mathlib.MeasureTheory.Measure.EverywherePos | ∀ {G : Type u_2} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [LocallyCompactSpace G]
[inst_4 : MeasurableSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant]
[MeasureTheory.IsFiniteMeasureOnCompacts μ] [μ.InnerRegularCompactLTTop],
μ.InnerRegularWRT (fun s => ∃ f,... | **Halmos' theorem: Haar measure is completion regular.** More precisely, any finite measure
set can be approximated from inside by a level set of a continuous function with compact support. | true |
FreeAlgebra.instFree | Mathlib.LinearAlgebra.FreeAlgebra | ∀ (R : Type u) (X : Type v) [inst : CommSemiring R], Module.Free R (FreeAlgebra R X) | null | true |
Polynomial.mapAlgHom_coe_ringHom | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ {R : Type u} {A : Type z} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), ↑(Polynomial.mapAlgHom f) = Polynomial.mapRingHom ↑f | **Alias** of `Polynomial.toRingHom_mapAlgHom`. | true |
List.zip_eq_zip_take_min | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {β : Type u_2} {l₁ : List α} {l₂ : List β},
l₁.zip l₂ = (List.take (min l₁.length l₂.length) l₁).zip (List.take (min l₁.length l₂.length) l₂) | null | true |
_private.Mathlib.RingTheory.DedekindDomain.Ideal.Basic.0.isDedekindDomainInv_iff | Mathlib.RingTheory.DedekindDomain.Ideal.Basic | ∀ {A : Type u_2} {K : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] [inst_4 : IsDomain A],
IsDedekindDomainInv✝ A ↔ ∀ (I : FractionalIdeal (nonZeroDivisors A) K), I ≠ ⊥ → I * I⁻¹ = 1 | null | true |
CategoryTheory.instIsRegularEpiCategorySheafTypeOfHasSheafify | Mathlib.CategoryTheory.Sites.RegularEpi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
[CategoryTheory.HasSheafify J (Type u)], CategoryTheory.IsRegularEpiCategory (CategoryTheory.Sheaf J (Type u)) | null | true |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_singleton._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α), {a}.erase a = ∅ | null | false |
MonomialOrder.lex._proof_1 | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} [inst : LinearOrder σ], IsOrderedAddMonoid (Lex (σ →₀ ℕ)) | null | false |
Lean.Order.Array.monotone_mapM | Init.Internal.Order.Lemmas | ∀ {m : Type u → Type v} [inst : Monad m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m]
{α β : Type u} {γ : Type w} [inst_3 : Lean.Order.PartialOrder γ] (xs : Array α) (f : γ → α → m β),
Lean.Order.monotone f → Lean.Order.monotone fun x => Array.mapM (f x) xs | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Variation.Semivariation.0.MeasureTheory.VectorMeasure.semivariation_univ_lt_top | Mathlib.MeasureTheory.VectorMeasure.Variation.Semivariation | ∀ {X : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {mX : MeasurableSpace X}
{μ : MeasureTheory.VectorMeasure X E}, μ.semivariation Set.univ < ⊤ | null | true |
Std.Internal.List.DistinctKeys.casesOn | Std.Data.Internal.List.Defs | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
{l : List ((a : α) × β a)} →
{motive : Std.Internal.List.DistinctKeys l → Sort u_1} →
(t : Std.Internal.List.DistinctKeys l) →
((distinct : List.Pairwise (fun a b => (a == b) = false) (Std.Internal.List.keys l)) → motive ⋯) → m... | null | false |
Lean.PPFns | Lean.Util.PPExt | Type | null | true |
Lean.KVMap.instValueBool.match_1 | Lean.Data.KVMap | (motive : Lean.DataValue → Sort u_1) →
(x : Lean.DataValue) → ((b : Bool) → motive (Lean.DataValue.ofBool b)) → ((x : Lean.DataValue) → motive x) → motive x | null | false |
MvPowerSeries.weightedOrder_le | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) {f : MvPowerSeries σ R} {d : σ →₀ ℕ},
(MvPowerSeries.coeff d) f ≠ 0 → MvPowerSeries.weightedOrder w f ≤ ↑((Finsupp.weight w) d) | If the `d`th coefficient of a formal power series is nonzero,
then the weighted order of the power series is less than or equal to `weight d w`. | true |
Continuous.edist | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : TopologicalSpace β] {f g : β → α},
Continuous f → Continuous g → Continuous fun b => edist (f b) (g b) | null | true |
_private.Mathlib.Basic.ENNReal.Inv.0.ENNReal.zpow_neg._simp_1_1 | Mathlib.Basic.ENNReal.Inv | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a < b → (a = b) = False | null | false |
BoxIntegral.TaggedPrepartition.IsSubordinate | Mathlib.Analysis.BoxIntegral.Partition.Tagged | {ι : Type u_1} →
{I : BoxIntegral.Box ι} → [Fintype ι] → BoxIntegral.TaggedPrepartition I → ((ι → ℝ) → ↑(Set.Ioi 0)) → Prop | A tagged partition `π` is subordinate to `r : (ι → ℝ) → ℝ` if each box `J ∈ π` is included in
the closed ball with center `π.tag J` and radius `r (π.tag J)`. | true |
_private.Mathlib.RingTheory.DedekindDomain.AdicValuation.0.IsDedekindDomain.HeightOneSpectrum.exists_primeCompl_mul_eq_or_mul_eq._proof_1_4 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_1} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (x : K)
(r : ↥(IsDedekindDomain.HeightOneSpectrum.valuationSubringAtPrime K v)),
(algebraMap (↥(IsDedekindDomain.Heig... | null | false |
_private.Init.Data.List.Range.0.List.getElem?_zipIdx.match_1_1 | Init.Data.List.Range | ∀ {α : Type u_1} (motive : List α → ℕ → ℕ → Prop) (x : List α) (x_1 x_2 : ℕ),
(∀ (x x_3 : ℕ), motive [] x x_3) →
(∀ (head : α) (tail : List α) (x : ℕ), motive (head :: tail) x 0) →
(∀ (head : α) (l : List α) (n m : ℕ), motive (head :: l) n m.succ) → motive x x_1 x_2 | null | false |
VitaliFamily.filterAt_enlarge | Mathlib.MeasureTheory.Covering.VitaliFamily | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m0 : MeasurableSpace X} {μ : MeasureTheory.Measure X}
(v : VitaliFamily μ) {δ : ℝ} (δpos : 0 < δ), (v.enlarge δ δpos).filterAt = v.filterAt | null | true |
_private.Batteries.Recycling.MonadSatisfying.Array.0.Array.SatisfiesM_mapM.match_1_7 | Batteries.Recycling.MonadSatisfying.Array | ∀ {α : Type u_1} {β : Type u_2} {as : Array α} {motive : ℕ → Prop} {p : Fin as.size → β → Prop} (i : ℕ)
(hi : i < as.size) (arr : Array β)
(motive_1 : (motive ↑⟨i, hi⟩ ∧ arr.size = ↑⟨i, hi⟩ ∧ ∀ (i : Fin as.size) (h2 : ↑i < arr.size), p i arr[↑i]) → Prop)
(h : motive ↑⟨i, hi⟩ ∧ arr.size = ↑⟨i, hi⟩ ∧ ∀ (i : Fin as.... | null | false |
DoubleCentralizer.coe._proof_2 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ (𝕜 : Type u_1) {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A], SMulCommClass 𝕜 𝕜 A | null | false |
_private.Mathlib.NumberTheory.Padics.HeightOneSpectrum.0.Rat.int_algebraMap_surjective._simp_1_1 | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | null | false |
CategoryTheory.Pseudofunctor.mapComp'_comp_id_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
(F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {b₀ b₁ : B} (f : b₀ ⟶ b₁) (X : ↑(F.obj b₀)) {Z : ↑(F.obj b₁)}
(h : (F.map (CategoryTheory.CategoryStruct.id b₁)).toFunctor.obj ((F.map f).toFunctor.obj X) ⟶ Z),... | null | true |
ImportGraph.Widget.CopyDisplay.ctorElim | ImportGraph.Widget.Copy | {motive : ImportGraph.Widget.CopyDisplay → Sort u} →
(ctorIdx : ℕ) →
(t : ImportGraph.Widget.CopyDisplay) →
ctorIdx = t.ctorIdx → ImportGraph.Widget.CopyDisplay.ctorElimType ctorIdx → motive t | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct.0.SSet.PtSimplex.MulStruct.assocAux.α_of_gt._auto_1 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | Lean.Syntax | null | false |
hasBasis_nhdsSet_Ici_Ici | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] (a : α)
[(nhdsWithin a (Set.Iio a)).NeBot], (nhdsSet (Set.Ici a)).HasBasis (fun x => x < a) Set.Ici | null | true |
CategoryTheory.Cat.HasLimits.limitConeIsLimit | Mathlib.CategoryTheory.Category.Cat.Limit | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CategoryTheory.Cat) →
CategoryTheory.Limits.IsLimit (CategoryTheory.Cat.HasLimits.limitCone F) | Auxiliary definition: the proposed cone is a limit cone. | true |
Mathlib.Tactic.Matrix.ListMatrix.transpose._unsafe_rec | Mathlib.Tactic.Matrix.ListMatrix | {α : Type u_1} → [Zero α] → ℕ → List (List α) → List (List α) | null | false |
_private.Mathlib.MeasureTheory.Measure.AEMeasurable.0.cond.match_1.eq_1 | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () | null | true |
IsAbsoluteValue.mk | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_4} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_5} [inst_2 : Semiring R] {f : R → S},
(∀ (x : R), 0 ≤ f x) →
(∀ {x : R}, f x = 0 ↔ x = 0) →
(∀ (x y : R), f (x + y) ≤ f x + f y) → (∀ (x y : R), f (x * y) = f x * f y) → IsAbsoluteValue f | null | true |
Filter.frequently_imp_distrib_right | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} [f.NeBot] {p : α → Prop} {q : Prop},
(∃ᶠ (x : α) in f, p x → q) ↔ (∀ᶠ (x : α) in f, p x) → q | null | true |
Std.Time.TimeZone.DaylightSavingRule.mk.noConfusion | Std.Time.Zoned.RecurringRule | {P : Sort u} →
{name : String} →
{offset : Std.Time.TimeZone.Offset} →
{start end_ : Option Std.Time.TimeZone.TransitionRule} →
{name' : String} →
{offset' : Std.Time.TimeZone.Offset} →
{start' end_' : Option Std.Time.TimeZone.TransitionRule} →
{ name := name, off... | null | false |
matPolyEquiv_symm_apply_coeff | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type w} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
(p : Polynomial (Matrix n n R)) (i j : n) (k : ℕ), (matPolyEquiv.symm p i j).coeff k = p.coeff k i j | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.