name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Holor.instAddMonoid._proof_3 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : AddMonoid α] (a : Holor α ds), a + 0 = a | null | false |
Complex.differentiable_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | Differentiable ℂ Complex.sinh | null | true |
ONote.fundamentalSequenceProp_inl_some | Mathlib.SetTheory.Ordinal.Notation | ∀ (o a : ONote), o.FundamentalSequenceProp (Sum.inl (some a)) ↔ o.repr = Order.succ a.repr ∧ (o.NF → a.NF) | null | true |
AddMonoidAlgebra.symm_mapAddEquiv | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Add M] (e : R ≃+ S),
(AddMonoidAlgebra.mapAddEquiv M e).symm = AddMonoidAlgebra.mapAddEquiv M e.symm | null | true |
LocallyConstant.instMul.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Mul Y],
LocallyConstant.instMul = { mul := fun f g => { toFun := ⇑f * ⇑g, isLocallyConstant := ⋯ } } | null | true |
Lean.Parser.withOpenDeclFn | Lean.Parser.Extension | Lean.Parser.ParserFn → Lean.Parser.ParserFn | If the parsing stack is of the form `#[.., openDecl]`, we process the open declaration, and execute `p` | true |
ValuativeRel.ValueGroupWithZero.mk_one_one | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R], ValuativeRel.ValueGroupWithZero.mk 1 1 = 1 | null | true |
Module.Basis.algebraMapCoeffs_apply | Mathlib.RingTheory.AlgebraTower | ∀ {R : Type u_1} (A : Type u_3) {ι : Type u_5} {M : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (b : Module.Basis ι R M) (h : Function.Bijective ⇑(algebraMap R A)) (i : ι),
(Mod... | null | true |
ContinuousLinearMap.mfderiv_eq | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(f : E →L[𝕜] E') {x : E}, mfderiv% ⇑f x = f | null | true |
OrderIso.isBoundedUnder_le_comp | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {l : Filter γ} {u : γ → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l fun x => e (u x)) ↔ Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l u | null | true |
ImportGraph.Shake.NeedsKind.metaPriv | ImportGraph.Shake.Core | ImportGraph.Shake.NeedsKind | null | true |
Std.Async.TCP.Socket.Client._sizeOf_1 | Std.Async.TCP | Std.Async.TCP.Socket.Client → ℕ | null | false |
Left.nsmul_nonpos | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddLeftMono M] {a : M}, a ≤ 0 → ∀ (n : ℕ), n • a ≤ 0 | null | true |
_private.Mathlib.Order.Monotone.Basic.0.Nat.stabilises_of_antitone._proof_1_3 | Mathlib.Order.Monotone.Basic | ∀ {f : ℕ → ℕ}, f 0 = f 0 | null | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.not_linearIndependent_iffₛ._simp_1_2 | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
_private.Mathlib.Topology.Instances.ENNReal.Lemmas.0.ENNReal.continuous_pow._simp_1_1 | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {y : Y},
(Continuous fun x => y) = True | null | false |
Int.natAbs_one | Init.Data.Int.Order | Int.natAbs 1 = 1 | null | true |
RingAut.toAddAut._proof_1 | Mathlib.Algebra.Ring.Aut | ∀ (R : Type u_1) [inst : Mul R] [inst_1 : Add R], RingEquiv.toAddEquiv 1 = RingEquiv.toAddEquiv 1 | null | false |
Matrix.submatrixEquivInvertible._proof_1 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u_3} {n : Type u_1} {α : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
[inst_3 : Fintype m] [inst_4 : DecidableEq m] (A : Matrix m m α) (e₁ e₂ : n ≃ m) [inst_5 : Invertible A],
A.submatrix ⇑e₁ ⇑e₂ * (⅟A).submatrix ⇑e₂ ⇑e₁ = 1 | null | false |
NormedAddGroupHom.inhabited | Mathlib.Analysis.Normed.Group.Hom | {V₁ : Type u_2} →
{V₂ : Type u_3} →
[inst : SeminormedAddCommGroup V₁] → [inst_1 : SeminormedAddCommGroup V₂] → Inhabited (NormedAddGroupHom V₁ V₂) | null | true |
MulArchimedeanClass.liftOrderHom.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {α : Type u_2}
[inst_3 : PartialOrder α] (f : M → α)
(h : ∀ (a b : M), MulArchimedeanClass.mk a ≤ MulArchimedeanClass.mk b → f a ≤ f b),
MulArchimedeanClass.liftOrderHom f h = { toFun := MulArchimedeanClass.lift f ⋯, monot... | null | true |
AlgebraicGeometry.Scheme.Opens.isRationalOver_of_dense | Mathlib.AlgebraicGeometry.Birational.Birational | ∀ {X S : AlgebraicGeometry.Scheme} (U : X.Opens) (sX : X ⟶ S),
Dense ↑U →
∀ [AlgebraicGeometry.Scheme.IsRationalOver sX],
AlgebraicGeometry.Scheme.IsRationalOver (CategoryTheory.CategoryStruct.comp U.ι sX) | A dense open set `U : Opens X` of a `S`-rational scheme `X` is `S`-rational. | true |
LieAlgebra.Orthogonal.soIndefiniteEquiv._proof_1 | Mathlib.Algebra.Lie.Classical | ∀ (p : Type u_1) (q : Type u_2) (R : Type u_3) [inst : DecidableEq p] [inst_1 : DecidableEq q] [inst_2 : CommRing R]
[inst_3 : Fintype p] [inst_4 : Fintype q] {i : R},
i * i = -1 →
↑(skewAdjointMatricesLieSubalgebra
((LieAlgebra.Orthogonal.Pso p q R i).transpose * LieAlgebra.Orthogonal.indefiniteDiago... | null | false |
AbstractCompletion.extend_unique | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type uα} [inst : UniformSpace α] (pkg : AbstractCompletion.{vα, uα} α) {β : Type uβ} [inst_1 : UniformSpace β]
{f : α → β} [CompleteSpace β] [T0Space β],
UniformContinuous f → ∀ {g : pkg.space → β}, UniformContinuous g → (∀ (a : α), f a = g (pkg.coe a)) → pkg.extend f = g | null | true |
Set.mem_cIcc | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularPreorder α] {a b x : α}, x ∈ Set.cIcc a b ↔ btw a x b | null | true |
Asymptotics.IsBigOTVS.add | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {f₁ f₂ : α → E} {g ... | null | true |
OrderMonoidIso.unitsCongr | Mathlib.Algebra.Order.Hom.Units | {α : Type u_1} →
{β : Type u_2} →
[inst : Preorder α] → [inst_1 : Monoid α] → [inst_2 : Preorder β] → [inst_3 : Monoid β] → (α ≃*o β) → αˣ ≃*o βˣ | An isomorphism of ordered monoids descends to their units. | true |
thickenedIndicatorAux.eq_1 | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (δ : ℝ) (E : Set α) (x : α),
thickenedIndicatorAux δ E x = 1 - Metric.infEDist x E / ENNReal.ofReal δ | null | true |
ValuationSubring.primeSpectrumEquiv_apply | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (P : PrimeSpectrum ↥A),
A.primeSpectrumEquiv P = ⟨A.ofPrime P.asIdeal, ⋯⟩ | null | true |
Representation.IntertwiningMap.snd_surjective | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W), Function.Surjective ⇑(Representation.IntertwiningMap.snd A ρ ... | null | true |
Std.DTreeMap.Raw.ordered_keys | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → List.Pairwise (fun a b => cmp a b = Ordering.lt) t.keys | null | true |
_private.Mathlib.CategoryTheory.Subfunctor.Basic.0.CategoryTheory.instCompleteLatticeSubfunctor._simp_5 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Metric.sphere_subset_closedBall | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.sphere x ε ⊆ Metric.closedBall x ε | null | true |
Std.WP.WhileInvariant.eq_1 | Std.WP.Triple.SpecLemmas | ∀ (α : Type u) (Pred : Type uₚ), Std.WP.WhileInvariant α Pred = (Bool → α → Pred) | null | true |
Complex.tsum_exp_neg_quadratic | Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation | ∀ {a : ℂ},
0 < a.re →
∀ (b : ℂ),
∑' (n : ℤ), Complex.exp (-↑Real.pi * a * ↑n ^ 2 + 2 * ↑Real.pi * b * ↑n) =
1 / a ^ (1 / 2) * ∑' (n : ℤ), Complex.exp (-↑Real.pi / a * (↑n + Complex.I * b) ^ 2) | Jacobi's theta-function transformation formula for the sum of `exp -Q(x)`, where `Q` is a
negative definite quadratic form. | true |
exists_isClopen_upper_or_lower_of_ne | Mathlib.Topology.Order.Priestley | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : PartialOrder α] [PriestleySpace α] {x y : α},
x ≠ y → ∃ U, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ y ∉ U | null | true |
DFinsupp.coe_sup | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → SemilatticeSup (α i)]
(f g : Π₀ (i : ι), α i), ⇑(f ⊔ g) = ⇑f ⊔ ⇑g | null | true |
CategoryTheory.op_add | Mathlib.CategoryTheory.Preadditive.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(f g : X ⟶ Y), (f + g).op = f.op + g.op | null | true |
Std.DHashMap.Internal.Raw₀.replaceₘ._proof_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Internal.Raw₀ α β) (a : α)
(b : β a),
0 <
{ size := (↑m).size,
buckets :=
Std.DHashMap.Internal.updateBucket (↑m).buckets ⋯ a fun l =>
Std.DHashMap.Internal.AssocList.replace a b l }.bu... | null | false |
RCLike.continuous_im | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], Continuous ⇑RCLike.im | null | true |
Std.Iterators.Types.Flatten.IsPlausibleStep.outerDone_flatMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α β α₂ γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[inst_3 : Std.Iterator α₂ m γ] {f : β → Std.IterM m γ} {it₁ : Std.IterM m β},
it₁.IsPlausibleStep Std.IterStep.done → (Std.IterM.flatMapAfter f it₁ none).IsPlausibleStep Std.IterStep.done | null | true |
Submodule.mem_span_image_finset_iff_exists_fun | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : α → M} {x : M} {s : Finset α}, x ∈ Submodule.span R (v '' ↑s) ↔ ∃ c, ∑ i, c i • v ↑i = x | null | true |
_private.Mathlib.Algebra.Homology.Augment.0.ChainComplex.augment.match_3.splitter | Mathlib.Algebra.Homology.Augment | (motive : ℕ → ℕ → Sort u_1) →
(x x_1 : ℕ) →
(Unit → motive 1 0) →
((i j : ℕ) → motive i.succ j.succ) →
((x x_2 : ℕ) → (x = 1 → x_2 = 0 → False) → (∀ (i j : ℕ), x = i.succ → x_2 = j.succ → False) → motive x x_2) →
motive x x_1 | null | true |
MonoidAlgebra.liftMagma._proof_2 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_2) {A : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : Mul M]
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : Module R A] [IsScalarTower R A A] [SMulCommClass R A A] (f : M →ₙ* A)
(a₁ a₂ : MonoidAlgebra R M),
(↑((Finsupp.liftAddHom fun x => (smulAddHom R A).flip (f x)).comp MonoidAlgebra.co... | null | false |
Functor.map_comp_map | Mathlib.Control.Functor | ∀ {F : Type u → Type v} {α β γ : Type u} [inst : Functor F] [LawfulFunctor F] (f : α → β) (g : β → γ),
((fun x => g <$> x) ∘ fun x => f <$> x) = fun x => (g ∘ f) <$> x | null | true |
TypeCat.EquivalenceRelation.ofEquivalence._proof_3 | Mathlib.CategoryTheory.EquivalenceRelation | ∀ {X : Type u_1} {φ : X → X → Prop} (hφ : Equivalence φ),
CategoryTheory.CategoryStruct.comp (TypeCat.TransitiveRelation.ofIsTrans ⋯).t (TypeCat.p₁OfRel φ) =
CategoryTheory.CategoryStruct.comp (TypeCat.TransitiveRelation.ofIsTrans ⋯).c.fst (TypeCat.p₁OfRel φ) | null | false |
CategoryTheory.ComposableArrows.threeδ₁Toδ₀_app_zero | Mathlib.CategoryTheory.ComposableArrows.Three | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {i j k l : C} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l)
(f₁₂ : i ⟶ k) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂),
(CategoryTheory.ComposableArrows.threeδ₁Toδ₀ f₁ f₂ f₃ f₁₂ h₁₂).app 0 = f₁ | null | true |
CategoryTheory.Oplax.StrongTrans.Modification.ext_iff | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} {x y : CategoryTheory.Oplax.StrongTrans.Modification η θ},
x = y ↔ x.app = y.app | null | true |
Polynomial.reflect_mul_induction | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (cf cg N O : ℕ) (f g : Polynomial R),
f.support.card ≤ cf.succ →
g.support.card ≤ cg.succ →
f.natDegree ≤ N →
g.natDegree ≤ O → Polynomial.reflect (N + O) (f * g) = Polynomial.reflect N f * Polynomial.reflect O g | null | true |
CategoryTheory.Limits.Cone.functoriality_obj_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor J C)
(G : CategoryTheory.Functor C D) (A : CategoryTheory.Limits.Cone F),
((CategoryTheory.Limits.Cone.fun... | null | true |
_private.Mathlib.Logic.Equiv.Defs.0.Equiv.permCongr_trans._proof_1_1 | Mathlib.Logic.Equiv.Defs | ∀ {α' : Type u_2} {β' : Type u_1} (e : α' ≃ β') (p p' : Equiv.Perm α'),
(e.permCongr p).trans (e.permCongr p') = e.permCongr (Equiv.trans p p') | null | false |
Int.gcd_comm | Init.Data.Int.Gcd | ∀ (a b : ℤ), a.gcd b = b.gcd a | null | true |
ContRepresentation.Equiv | Mathlib.RepresentationTheory.Continuous.Basic | {R : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Monoid G] →
[inst_1 : Ring R] →
[inst_2 : AddCommGroup V] →
[inst_3 : TopologicalSpace V] →
[inst_4 : IsTopologicalAddGroup V] →
[inst_5 : Module R V] →
... | The equivalence between continuous representations. | true |
Algebra.Extension.tensorCotangentSpaceOfFormallyEtale._proof_7 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_4} {S : Type u_1} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R T] [inst_4 : Algebra S T] {Q : Algebra.Extension R T}, SMulCommClass S Q.Ring T | null | false |
Std.Sat.AIG.Fanin.flip | Std.Sat.AIG.Basic | Std.Sat.AIG.Fanin → Bool → Std.Sat.AIG.Fanin | Flip the inverter bit according to `val`.
| true |
Bornology.ofDist._proof_4 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_1} (dist : α → α → ℝ) (z : α), ∃ C, ∀ ⦃x : α⦄, x ∈ {z} → ∀ ⦃y : α⦄, y ∈ {z} → dist x y ≤ C | null | false |
_private.Aesop.Forward.State.0.Aesop.ForwardState.enqueuePatSubsts.match_1 | Aesop.Forward.State | (motive : Aesop.ForwardRule × Aesop.Substitution → Sort u_1) →
(x : Aesop.ForwardRule × Aesop.Substitution) →
((r : Aesop.ForwardRule) → (patSubst : Aesop.Substitution) → motive (r, patSubst)) → motive x | null | false |
MeasurableSpace.generateMeasurable_eq_rec | Mathlib.MeasureTheory.MeasurableSpace.Card | ∀ {α : Type u} (s : Set (Set α)),
{t | MeasurableSpace.GenerateMeasurable s t} = MeasurableSpace.generateMeasurableRec s (Ordinal.omega 1) | `generateMeasurableRec s ω₁` generates precisely the smallest sigma-algebra containing `s`. | true |
Aesop.ScriptGenerated.Method.rec | Aesop.Stats.Basic | {motive : Aesop.ScriptGenerated.Method → Sort u} →
motive Aesop.ScriptGenerated.Method.static →
motive Aesop.ScriptGenerated.Method.dynamic → (t : Aesop.ScriptGenerated.Method) → motive t | null | false |
List.infix_append'._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} (l₁ l₂ l₃ : List α), (l₂ <:+: l₁ ++ (l₂ ++ l₃)) = True | null | false |
IsStrictOrderedRing.toContinuousInv₀ | Mathlib.Topology.Algebra.Order.Field | ∀ {𝕜 : Type u_1} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [inst_3 : TopologicalSpace 𝕜]
[OrderTopology 𝕜] [ContinuousMul 𝕜], ContinuousInv₀ 𝕜 | null | true |
ProfiniteAddGrp.limitConePtAux._proof_3 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max u_2 u_1})
{x : (j : J) → ↑(F.obj j).toProfinite.toTop},
x ∈ {x | ∀ ⦃i j : J⦄ (π : i ⟶ j), (ProfiniteAddGrp.Hom.hom (F.map π)) (x i) = x j} →
∀ (x_1 x_2 : J) (π : x_1 ⟶ x_2), (ProfiniteAddGrp.Hom.hom (F.ma... | null | false |
CategoryTheory.SimplicialThickening.mk.sizeOf_spec | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SizeOf J] (as : J), sizeOf { as := as } = 1 + sizeOf as | null | true |
MeasureTheory.Measure.ofMultiset | Mathlib.Probability.Distributions.Uniform | {α : Type u_2} → [inst : MeasurableSpace α] → Multiset α → MeasureTheory.Measure α | Given a non-empty multiset `s` we construct the measure which sends `a` to the fraction of
elements in `s` that are `a`. | true |
IsClosed.upperSemicontinuousAt_indicator | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {s : Set α} {x : α} {y : β} [inst_1 : Zero β]
[inst_2 : Preorder β], IsClosed s → 0 ≤ y → UpperSemicontinuousAt (s.indicator fun _x => y) x | null | true |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_of_getElem?.match_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {a : α} (motive : (∃ (h : i < n), xs[i] = a) → Prop)
(x : ∃ (h : i < n), xs[i] = a), (∀ (w : i < n) (e : xs[i] = a), motive ⋯) → motive x | null | false |
ContinuousMultilinearMap.sum_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {F : Type u_8} {α : Type u_9} {β : Type u_10} {ι : Type u_11} [inst : FunLike F α β] [inst_1 : AddCommMonoid β]
[inst_2 : AddCommMonoid F] [IsZeroApply F α β] [IsAddApply F α β] (s : Finset ι) (f : ι → F) (x : α),
(∑ i ∈ s, f i) x = ∑ i ∈ s, (f i) x | **Alias** of `sum_apply`. | true |
IO.FS.Metadata.numLinks | Init.System.IO | IO.FS.Metadata → UInt64 | The number of hard links to the file. | true |
FintypeCat.equivEquivIso_symm_apply_apply | Mathlib.CategoryTheory.FintypeCat | ∀ {A B : FintypeCat} (i : A ≅ B) (a : A.obj),
(FintypeCat.equivEquivIso.symm i) a = (CategoryTheory.ConcreteCategory.hom i.hom) a | null | true |
CategoryTheory.Lax.LaxTrans.homCategory.ext_iff | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {Γ Δ : η ⟶ θ}, Γ = Δ ↔ ∀ (a : B), Γ.as.app a = Δ.as.app a | null | true |
Lean.SourceInfo.none.sizeOf_spec | Init.SizeOf | sizeOf Lean.SourceInfo.none = 1 | null | true |
ContinuousMultilinearMap.mk.inj | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} {inst : Semiring R}
{inst_1 : (i : ι) → AddCommMonoid (M₁ i)} {inst_2 : AddCommMonoid M₂} {inst_3 : (i : ι) → Module R (M₁ i)}
{inst_4 : Module R M₂} {inst_5 : (i : ι) → TopologicalSpace (M₁ i)} {inst_6 : TopologicalSpace M₂}
{toMultilinearMap : Multil... | null | true |
Polynomial.instMulSemiringActionGalSplittingField._proof_4 | Mathlib.FieldTheory.PolynomialGaloisGroup | ∀ {F : Type u_1} [inst : Field F] (p : Polynomial F) (b : p.SplittingField), 1 • b = b | null | false |
CategoryTheory.Limits.cokernel.condition_apply | Mathlib.CategoryTheory.ConcreteCategory.Elementwise | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {F : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) → FunLike (F X Y) (carrier X) (carrier Y)} [inst_3 : CategoryTheory.... | null | true |
UniformContinuous.nndist | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : UniformSpace β] {f g : β → α},
UniformContinuous f → UniformContinuous g → UniformContinuous fun b => nndist (f b) (g b) | null | true |
ComplexShape.σ_def | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ (p q : ℤ),
TotalComplexShapeSymmetry.σ (ComplexShape.up ℤ) (ComplexShape.up ℤ) (ComplexShape.up ℤ) p q = (p * q).negOnePow | null | true |
WithCStarModule.instNormedAddCommGroupProd._proof_10 | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_3} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {E : Type u_2} {F : Type u_1}
[inst_2 : NormedAddCommGroup E] [inst_3 : Module ℂ E] [inst_4 : SMul A E] [inst_5 : NormedAddCommGroup F]
[inst_6 : Module ℂ F] [inst_7 : SMul A F] [inst_8 : CStarModule A E] [inst_9 : CStarModule A F]
[inst_... | null | false |
Submodule.adjoint._proof_3 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
Lean.Lsp.CompletionOptions.allCommitCharacters?._default | Lean.Data.Lsp.LanguageFeatures | Option (Array String) | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.initFn._@.Lean.Parser.Term.1815602713._hygCtx._hyg.8 | Lean.Parser.Term | IO Unit | null | false |
CircleDeg1Lift.translationNumber_eq_int_iff | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), Continuous ⇑f → ∀ {m : ℤ}, f.translationNumber = ↑m ↔ ∃ x, f x = x + ↑m | null | true |
Std.DTreeMap.Internal.Impl.isEmpty_inter!_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → m₁.isEmpty = true → (m₁.inter! m₂).isEmpty = true | null | true |
_private.Mathlib.Tactic.Translate.Expr.0.Mathlib.Tactic.Translate.applyReplacementFun.visitApp.match_17 | Mathlib.Tactic.Translate.Expr | (motive : Lean.Expr → Sort u_1) →
(f : Lean.Expr) →
((n : Lean.Name) → (i : ℕ) → (b : Lean.Expr) → motive (Lean.Expr.proj n i b)) →
((n₀ : Lean.Name) → (ls₀ : List Lean.Level) → motive (Lean.Expr.const n₀ ls₀)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(... | null | false |
Setoid.eqvGen_of_setoid | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} (r : Setoid α), Relation.EqvGen.setoid ⇑r = r | The equivalence closure of an equivalence relation r is r. | true |
AlgCat.HasLimits.limitConeIsLimit._proof_14 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections]
(s : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget (AlgCat R)).map
... | null | false |
Lean.Macro.resolveGlobalName | Init.Prelude | Lean.Name → Lean.MacroM (List (Lean.Name × List String)) | Resolves the given name to an overload list of global definitions.
The `List String` in each alternative is the deduced list of projections
(which are ambiguous with name components).
Remark: it will not trigger actions associated with reserved names. Recall that Lean
has reserved names. For example, a definition `foo... | true |
StrongDual.polar_univ | Mathlib.Analysis.LocallyConvex.Polar | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] {E : Type u_5} [inst_1 : AddCommGroup E]
[inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E], StrongDual.polar 𝕜 Set.univ = {0} | null | true |
Ideal.polynomialQuotientEquivQuotientPolynomial._proof_4 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (f g : Polynomial (R ⧸ I)),
(Polynomial.eval₂RingHom (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map Polynomial.C I)).comp Polynomial.C) ⋯)
((Ideal.Quotient.mk (Ideal.map Polynomial.C I)) Polynomial.X))
(f * g) =
(Polynomial.eval₂RingHom
... | null | false |
Lean.Omega.Constraint.isImpossible.match_1 | Init.Omega.Constraint | (motive : Lean.Omega.Constraint → Sort u_1) →
(x : Lean.Omega.Constraint) →
((x y : ℤ) → motive { lowerBound := some x, upperBound := some y }) →
((x : Lean.Omega.Constraint) → motive x) → motive x | null | false |
LawfulBitraversable.const | Mathlib.Control.Bitraversable.Instances | LawfulBitraversable Functor.Const | null | true |
MonoidAlgebra.addCommGroup._proof_5 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] (a : MonoidAlgebra R M), -a + a = 0 | null | false |
NormedRing.algEquivComplexOfComplete._proof_7 | Mathlib.Analysis.Normed.Algebra.GelfandFormula | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : NormedAlgebra ℂ A] (r : ℂ),
(↑↑(Algebra.ofId ℂ A).toRingHom).toFun ((algebraMap ℂ ℂ) r) = (algebraMap ℂ A) r | null | false |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon C =
{ obj := fun F => F.mapAddMon.obj (CategoryTheory.AddMon.trivial (CategoryTheory.Discrete PUnit.{w + 1})),
map := fun {X Y} α =... | null | true |
CategoryTheory.Limits.Trident.IsLimit.mk'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : C} {f : J → (X ⟶ Y)}
(t : CategoryTheory.Limits.Trident f)
(create :
(s : CategoryTheory.Limits.Trident f) →
{ l //
CategoryTheory.CategoryStruct.comp l t.ι = s.ι ∧
∀
{m :
((Cat... | null | false |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.857132795._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | IO (Lean.Option Bool) | null | false |
trdeg_eq_zero_iff | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {R : Type u_3} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
Algebra.trdeg R A = 0 ↔ Algebra.IsAlgebraic R A | null | true |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.evalAdd.match_7 | Mathlib.Tactic.Ring.Common | (motive : Ordering → Sort u_1) → (x : Ordering) → (Unit → motive Ordering.lt) → ((x : Ordering) → motive x) → motive x | null | false |
_private.Mathlib.Probability.Kernel.Representation.0.ProbabilityTheory.Kernel.exists_measurable_map_eq_unitInterval_aux._simp_1_6 | Mathlib.Probability.Kernel.Representation | ∀ {q : ℚ} {K : Type u_2} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K], (0 ≤ ↑q) = (0 ≤ q) | null | false |
Real.floor_pi_eq_three | Mathlib.Analysis.Real.Pi.Bounds | ⌊Real.pi⌋ = 3 | null | true |
RingHom.coe_id | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {x : NonAssocSemiring α}, ⇑(RingHom.id α) = id | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.