name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DHashMap.Internal.Raw₀.Const.Equiv.beq | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β}
[LawfulHashable α] [EquivBEq α] [inst_4 : BEq β] [ReflBEq β],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → Std.DHashMap.Internal.Raw₀.Const.beq m₁ m₂ = true | null | true |
_private.Mathlib.Data.Seq.Computation.0.Computation.lift_eq_iff_equiv.match_1_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} (c₁ c₂ : Computation α) (motive : Computation.LiftRel (fun x1 x2 => x1 = x2) c₁ c₂ → Prop)
(x : Computation.LiftRel (fun x1 x2 => x1 = x2) c₁ c₂),
(∀ (h1 : ∀ {a : α}, a ∈ c₁ → ∃ b ∈ c₂, (fun x1 x2 => x1 = x2) a b)
(h2 : ∀ {b : α}, b ∈ c₂ → ∃ a ∈ c₁, (fun x1 x2 => x1 = x2) a b), motive ⋯) →
... | null | false |
Convexity.IsAffineMap.rec | Mathlib.Geometry.Convex.ConvexSpace.Defs | {R : Type u_1} →
{X : Type u_2} →
{Y : Type u_3} →
[inst : PartialOrder R] →
[inst_1 : Semiring R] →
[inst_2 : IsStrictOrderedRing R] →
[inst_3 : Convexity.ConvexSpace R X] →
[inst_4 : Convexity.ConvexSpace R Y] →
{f : X → Y} →
{m... | null | false |
Lean.instReprConstantKind.repr | Lean.Environment | Lean.ConstantKind → ℕ → Std.Format | null | true |
_private.Init.Data.List.Lemmas.0.List.getLast?_dropLast._simp_1_3 | Init.Data.List.Lemmas | ∀ (a b c : ℕ), a - b - c = a - (b + c) | null | false |
_private.Mathlib.Data.Nat.Nth.0.Nat.image_nth_Iio_card._simp_1_1 | Mathlib.Data.Nat.Nth | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
StarAlgHom.realContinuousMapOfNNReal._proof_4 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_2} [inst : TopologicalSpace X] {A : Type u_1} [inst_1 : Ring A] [inst_2 : StarRing A]
[inst_3 : Algebra ℝ A] (φ : C(X, NNReal) →⋆ₐ[NNReal] A), φ (ContinuousMap.toNNReal 0) - φ (-0).toNNReal = 0 | null | false |
_private.Lean.Compiler.LCNF.Simp.InlineCandidate.0.Lean.Compiler.LCNF.Simp.inlineCandidate?._sparseCasesOn_24 | Lean.Compiler.LCNF.Simp.InlineCandidate | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((fvarId : Lean.FVarId) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) → motive (Lean.Compiler.LCNF.LetValue.fvar fvarId args)) →
(Nat.hasNotBit 16 t.ctorIdx → motiv... | null | false |
AddCommGrpCat.leftExactFunctorForgetEquivalence.unitIso._proof_3 | Mathlib.Algebra.Category.Grp.LeftExactFunctor | CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.forget AddCommGrpCat) | null | false |
ClassGroup.mkMMem_surjective | Mathlib.NumberTheory.ClassNumber.Finite | ∀ {R : Type u_1} {S : Type u_2} [inst : EuclideanDomain R] [inst_1 : CommRing S] [inst_2 : IsDomain S]
[inst_3 : Algebra R S] {abv : AbsoluteValue R ℤ} {ι : Type u_5} [inst_4 : DecidableEq ι] [inst_5 : Fintype ι]
(bS : Module.Basis ι R S) (adm : abv.IsAdmissible) [inst_6 : Infinite R] [inst_7 : DecidableEq R]
[in... | null | true |
Num.oneBits | Mathlib.Data.Num.Bitwise | Num → List ℕ | `n.oneBits` is the list of indices of active bits in the binary representation of `n`. | true |
instCommRingPadicInt._proof_6 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (a : ℤ_[p]), 0 + a = a | null | false |
Std.Internal.List.isNone_maxKey?_eq_isEmpty | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {l : List ((a : α) × β a)},
(Std.Internal.List.maxKey? l).isNone = l.isEmpty | null | true |
AddMonoidAlgebra.instModule._proof_2 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_3} {S : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S]
(x : AddMonoidAlgebra S M), 0 • x = 0 | null | false |
Set.powersetCard.coe_compl | Mathlib.Data.Set.PowersetCard | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] [inst_1 : Fintype α] {m : ℕ} {hm : m + n = Fintype.card α}
{s : ↑(Set.powersetCard α n)}, ↑((Set.powersetCard.compl hm) s) = (↑s)ᶜ | null | true |
ContDiffOn.lineMap | Mathlib.Analysis.Calculus.AddTorsor.AffineMap | ∀ {𝕜 : Type u_1} {V : Type u_2} {E : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : NormedSpace 𝕜 V] [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {f₁ f₂ : E → V} {g : E → 𝕜}
{s : Set E} {n : WithTop ℕ∞},
ContDiffOn 𝕜 n f₁ s →
ContDiffOn 𝕜 n f₂ s → C... | null | true |
Finset.mem_shatterer | Mathlib.Combinatorics.SetFamily.Shatter | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α}, s ∈ 𝒜.shatterer ↔ 𝒜.Shatters s | null | true |
_private.Init.Data.String.Basic.0.String.utf8ByteSize_push._simp_1_1 | Init.Data.String.Basic | ∀ {s : String}, s.utf8ByteSize = s.toByteArray.size | null | false |
CategoryTheory.Idempotents.Karoubi.mk._flat_ctor | Mathlib.CategoryTheory.Idempotents.Karoubi | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(X : C) →
(p : X ⟶ X) →
autoParam (CategoryTheory.CategoryStruct.comp p p = p) CategoryTheory.Idempotents.Karoubi.idem._autoParam →
CategoryTheory.Idempotents.Karoubi C | null | false |
AffineEquiv.symm_apply_eq | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] (e : P₁ ≃ᵃ[k] P₂) {p₁ : P₂} {p₂ : P₁},
e.symm p₁ = p₂ ↔ p₁ = e ... | null | true |
RootPairing.Equiv.coweightEquiv | Mathlib.LinearAlgebra.RootSystem.Hom | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{ι₂ : Type u_5} →
... | The contravariant equivalence of coweight spaces given by an equivalence of root pairings. | true |
Order.IsNormal.isClub_range | Mathlib.SetTheory.Cardinal.Cofinality.Club | ∀ {α : Type v} [inst : LinearOrder α] [WellFoundedLT α] {f : α → α}, Order.IsNormal f → IsClub (Set.range f) | null | true |
WeierstrassCurve.j_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [inst_1 : W.IsElliptic], W.c₄ = 0 → W.j = 0 | null | true |
Std.ExtDHashMap.mem_of_getKey?_eq_some | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k k' : α}, m.getKey? k = some k' → k' ∈ m | null | true |
Std.DTreeMap.Raw.Equiv.getEntryLTD_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp] {k : α}
{fallback : (a : α) × β a}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getEntryLTD k fallback = t₂.getEntryLTD k fallback | null | true |
NumberField.mixedEmbedding.normAtAllPlaces_normAtAllPlaces | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] (x : NumberField.mixedEmbedding.mixedSpace K),
NumberField.mixedEmbedding.normAtAllPlaces
(NumberField.mixedEmbedding.mixedSpaceOfRealSpace (NumberField.mixedEmbedding.normAtAllPlaces x)) =
NumberField.mixedEmbedding.normAtAllPlaces x | null | true |
Lean.TSyntax.getLmfdbId | Mathlib.Tactic.CrossRefAttribute | Lean.TSyntax Mathlib.CrossRef.lmfdbIdKind → Lean.CoreM String | Extract the underlying identifier as a string from a `lmfdbId` node. | true |
spectralNorm.normedField._proof_7 | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ (K : Type u_1) [inst : NontriviallyNormedField K] (L : Type u_2) [inst_1 : Field L] [inst_2 : Algebra K L]
[Algebra.IsAlgebraic K L] [hu : IsUltrametricDist K] (x y : L), spectralNorm K L (x - y) = spectralNorm K L (-x + y) | null | false |
CategoryTheory.Projective.zero_projective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C],
CategoryTheory.Projective 0 | null | true |
Int.instLinearOrder | Mathlib.Data.Int.Order.Basic | LinearOrder ℤ | null | true |
CochainComplex.ofHom | Mathlib.Algebra.Homology.HomologicalComplex | {V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{α : Type u_2} →
[inst_2 : AddRightCancelSemigroup α] →
[inst_3 : One α] →
{X Y : CochainComplex V α} →
(f : (i : α) → X.X i ⟶ Y.X i) →
... | A constructor for chain maps between `α`-indexed cochain complexes built using `CochainComplex.of`,
from a dependently typed collection of morphisms.
| true |
AlgebraicTopology.DoldKan.Γ₀.Obj.summand._proof_1 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | IsRightCancelAdd ℕ | null | false |
_private.Init.Data.Nat.Lemmas.0.Nat.sub_min_sub_right.match_1_1 | Init.Data.Nat.Lemmas | ∀ (motive : ℕ → ℕ → ℕ → Prop) (x x_1 x_2 : ℕ),
(∀ (x x_3 : ℕ), motive x x_3 0) → (∀ (x x_3 n : ℕ), motive x x_3 n.succ) → motive x x_1 x_2 | null | false |
instReprId | Init.Data.Repr | {α : Type u_1} → [Repr α] → Repr (id α) | null | true |
MeasureTheory.Measure.rnDeriv_smul_right_of_ne_top' | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (ν μ : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite ν]
[MeasureTheory.SigmaFinite μ] {r : ENNReal}, r ≠ 0 → r ≠ ⊤ → ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ | Radon-Nikodym derivative with respect to the scalar multiple of a measure.
See also `rnDeriv_smul_right_of_ne_top`, which has no hypothesis on `μ` but requires finite `ν`. | true |
SubMulAction.instBot | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} → {M : Type v} → [inst : SMul R M] → Bot (SubMulAction R M) | null | true |
CategoryTheory.Limits.colimit.ι_pre_assoc | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor J C)
[inst_3 : CategoryTheory.Limits.HasColimit F] (E : CategoryTheory.Functor K J)
[inst_4 : CategoryTheory.... | null | true |
Std.ExtDTreeMap.Const.ofList | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : Type v} →
List (α × β) →
(cmp : autoParam (α → α → Ordering) Std.ExtDTreeMap.Const.ofList._auto_1) → Std.ExtDTreeMap α (fun x => β) cmp | Transforms a list of mappings into a tree map. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.edgeDisjointTriangles_iff_mem_sym2_subsingleton._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {α : Sort u_1} {a' : α} {P Q : α → Prop}, (∀ (a : α), a = a' ∨ Q a → P a) = (P a' ∧ ∀ (a : α), Q a → P a) | null | false |
LightCondMod | Mathlib.Condensed.Light.Module | (R : Type u) → [Ring R] → Type (u + 1) | The category of light condensed `R`-modules, defined as sheaves of `R`-modules over
`LightProfinite.{u}` with respect to the coherent Grothendieck topology.
| true |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.Result.add._proof_1 | Mathlib.Tactic.NormNum.Basic | ∀ {u : Lean.Level} {α : Q(Type u)} (inst : Q(Add «$α»)) (_rα : Q(Ring «$α»)), «$inst» =Q instDistribOfSemiring.toAdd | null | false |
ContinuousMap.IccExtendCM | Mathlib.Topology.ContinuousMap.Interval | {α : Type u_1} →
[inst : LinearOrder α] →
[inst_1 : TopologicalSpace α] →
[OrderTopology α] →
{a b : α} → [Fact (a ≤ b)] → {E : Type u_2} → [inst_4 : TopologicalSpace E] → C(C(↑(Set.Icc a b), E), C(α, E)) | The extension operation from continuous maps on an interval to continuous maps on the whole
type, as a `ContinuousMap`. | true |
BialgCat.MonoidalCategory.inducingFunctorData._proof_8 | Mathlib.Algebra.Category.BialgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (x : BialgCat R),
(AlgCat.Hom.hom
((CategoryTheory.forget₂ (BialgCat R) (AlgCat R)).map
(CategoryTheory.MonoidalCategoryStruct.rightUnitor x).hom)).comp
Algebra.TensorProduct.includeLeft =
(AlgCat.Hom.hom
(((CategoryTheory.Iso.refl
... | null | false |
compactOperator_topologicalClosure | Mathlib.Analysis.Normed.Operator.Compact.Basic | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NontriviallyNormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ₁₂ : 𝕜₁ →+* 𝕜₂}
{M₁ : Type u_3} {M₂ : Type u_4} [inst_2 : SeminormedAddCommGroup M₁] [inst_3 : AddCommGroup M₂]
[inst_4 : NormedSpace 𝕜₁ M₁] [inst_5 : Module 𝕜₂ M₂] [inst_6 : UniformSpace M₂] [inst_7 : IsUnifor... | null | true |
ZFSet.«_aux_Mathlib_SetTheory_ZFC_Basic___macroRules_ZFSet_term⋂₀__1» | Mathlib.SetTheory.ZFC.Basic | Lean.Macro | null | false |
Nat.findGreatest_of_not | Mathlib.Data.Nat.Find | ∀ {P : ℕ → Prop} [inst : DecidablePred P] {n : ℕ}, ¬P (n + 1) → Nat.findGreatest P (n + 1) = Nat.findGreatest P n | null | true |
DoubleCentralizer.toProdMulOppositeHom_apply | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (a : DoubleCentralizer 𝕜 A),
DoubleCentralizer.toProdMulOppositeHom a = a.toProdMulOpposite | null | true |
Std.DTreeMap.Internal.Impl.getKey?_inter!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → ∀ {k : α}, Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter! m₂).getKey? k = none | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Clique.0.SimpleGraph.IsClique.of_induce._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
Aesop.RuleTerm.noConfusion | Aesop.RuleTac.RuleTerm | {P : Sort u} → {t t' : Aesop.RuleTerm} → t = t' → Aesop.RuleTerm.noConfusionType P t t' | null | false |
ContinuousMapZero.instR1Space | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_3} [inst : Zero X] [inst_1 : Zero R] [inst_2 : TopologicalSpace X]
[inst_3 : TopologicalSpace R] [R1Space R], R1Space (ContinuousMapZero X R) | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0._regBuiltin.Char.reduceVal.declare_71._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.164368340._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | null | false |
Even.natAbs | Mathlib.Algebra.Ring.Int.Parity | ∀ {n : ℤ}, Even n → Even n.natAbs | **Alias** of the reverse direction of `Int.natAbs_even`. | true |
MultilinearMap.fromDFinsuppEquiv._proof_7 | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {ι : Type u_2} (κ : ι → Type u_3) (R : Type u_4) [inst : CommSemiring R] {N : Type u_1} [inst_1 : AddCommMonoid N]
[inst_2 : Module R N], LinearMap.CompatibleSMul (Π₀ (i : (i : ι) → κ i), N) N R R | null | false |
AddCommGrpCat.preadditiveCoyonedaIso._proof_1 | Mathlib.CategoryTheory.Preadditive.Yoneda.Basic | ∀ (X : AddCommGrpCatᵒᵖ) {X_1 Y : AddCommGrpCat} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.preadditiveCoyoneda.obj X).map f)
AddCommGrpCat.homAddEquiv.toAddCommGrpIso.hom =
CategoryTheory.CategoryStruct.comp AddCommGrpCat.homAddEquiv.toAddCommGrpIso.hom
((AddCommGrpCat.coyoneda... | null | false |
IsStrictOrderedRing.topologicalRing | Mathlib.Topology.Algebra.Order.Field | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [inst_3 : TopologicalSpace 𝕜]
[OrderTopology 𝕜], IsTopologicalRing 𝕜 | null | true |
Set.sub_nonempty._simp_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Sub α] {s t : Set α}, (s - t).Nonempty = (s.Nonempty ∧ t.Nonempty) | null | false |
_private.Std.Async.Select.0.Std.Async.Selectable.one._proof_1 | Std.Async.Select | ∀ {α : Type}, Nonempty (Except IO.Error α) | null | false |
_private.Mathlib.RingTheory.Ideal.GoingUp.0.Ideal.comap_ne_bot_of_root_mem.match_1_1 | Mathlib.RingTheory.Ideal.GoingUp | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {f : R →+* S} {I : Ideal S} {p : Polynomial R}
(motive : (∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ Ideal.comap f I) → Prop)
(x : ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ Ideal.comap f I),
(∀ (w : ℕ) (hi : p.coeff w ≠ 0) (mem : p.coeff w ∈ Ideal.comap f I),... | null | false |
List.disjoint_cons_right._simp_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α}, l₁.Disjoint (a :: l₂) = (a ∉ l₁ ∧ l₁.Disjoint l₂) | null | false |
Subgroup.lowerCentralSeries_le_self | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] (S : Subgroup G) (n : ℕ), S.lowerCentralSeries n ≤ S | null | true |
ContinuousLinearMapWOT.algebraMapCLM_apply | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} [inst : NormedField 𝕜₁] {E : Type u_3} [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜₁ E] {S : Type u_5} [inst_4 : CommSemiring S] [inst_5 : Module S E] [inst_6 : SMulCommClass 𝕜₁ S E]
[inst_7 : SMul S 𝕜₁] [inst_8 : IsScalarTower S 𝕜₁ E] [inst_9 : ContinuousConstS... | null | true |
Equiv.divLeft._proof_2 | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_1} [inst : Group G] (a b : G), (fun b => a / b) ((fun b => b⁻¹ * a) b) = b | null | false |
_private.Lean.Elab.BuiltinCommand.0.Lean.Elab.Command.elabSetOption._regBuiltin.Lean.Elab.Command.elabSetOption.declRange_3 | Lean.Elab.BuiltinCommand | IO Unit | null | false |
_private.Std.Http.Data.Version.0.Std.Http.Version.ofNumber?.match_1 | Std.Http.Data.Version | (motive : ℕ → ℕ → Sort u_1) →
(x x_1 : ℕ) →
(Unit → motive 1 0) →
(Unit → motive 1 1) → (Unit → motive 2 0) → (Unit → motive 3 0) → ((x x_2 : ℕ) → motive x x_2) → motive x x_1 | null | false |
_private.Mathlib.LinearAlgebra.Dimension.Torsion.Basic.0.rank_quotient_eq_of_le_torsion._simp_1_6 | Mathlib.LinearAlgebra.Dimension.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} {x : M} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(p : Submodule R M), (Submodule.Quotient.mk x = 0) = (x ∈ p) | null | false |
MvPolynomial.rename_comp_toMvPolynomial | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {R : Type u_1} {σ : Type u_3} {τ : Type u_4} [inst : CommSemiring R] (f : σ → τ) (a : σ),
(MvPolynomial.rename f).comp (Polynomial.toMvPolynomial a) = Polynomial.toMvPolynomial (f a) | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionOfMonoidalFunctorToEndofunctor_actionHom | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) [inst_3 : F.Monoidal] {c c' : C} {d d' : D} (f : d ⟶ d')
(g : c ⟶ c'),
CategoryTh... | null | true |
PEquiv.mem_ofSet_self_iff | Mathlib.Basic.PEquiv | ∀ {α : Type u} {s : Set α} [inst : DecidablePred fun x => x ∈ s] {a : α}, a ∈ (PEquiv.ofSet s) a ↔ a ∈ s | null | true |
Algebra.FinitePresentation.baseChange | Mathlib.RingTheory.FiniteStability | ∀ {R : Type w₁} [inst : CommRing R] {A : Type w₂} [inst_1 : CommRing A] [inst_2 : Algebra R A] (B : Type w₃)
[inst_3 : CommRing B] [inst_4 : Algebra R B] [Algebra.FinitePresentation R A],
Algebra.FinitePresentation B (TensorProduct R B A) | null | true |
IsUltrametricDist.nnnorm_div_eq_max_of_nnnorm_div_ne_nnnorm_div | Mathlib.Analysis.Normed.Group.Ultra | ∀ {S : Type u_1} [inst : SeminormedGroup S] [IsUltrametricDist S] (x y z : S),
‖x / y‖₊ ≠ ‖y / z‖₊ → ‖x / z‖₊ = max ‖x / y‖₊ ‖y / z‖₊ | All triangles are isosceles in an ultrametric normed group. | true |
CommRingCat.Colimits.cocone_naturality | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat) {j j' : J}
(f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp (F.map f) (CommRingCat.Colimits.coconeMorphism F j') =
CommRingCat.Colimits.coconeMorphism F j | null | true |
Sym2.fromRel_bot_iff | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} {sym : Std.Symm r}, Sym2.fromRel sym = ∅ ↔ r = ⊥ | null | true |
Lean.Grind.CommRing.Poly.NonnegCoeffs.num | Init.Grind.Ring.CommSemiringAdapter | ∀ c ≥ 0, (Lean.Grind.CommRing.Poly.num c).NonnegCoeffs | null | true |
_private.Init.Data.SInt.Lemmas.0.ISize.toInt64_lt._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {x y : ISize}, (x < y) = (x.toInt < y.toInt) | null | false |
SimpleGraph.Walk.IsCycle.mapLe | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G G' : SimpleGraph V} (h : G ≤ G') {u : V} {p : G.Walk u u},
p.IsCycle → (SimpleGraph.Walk.mapLe h p).IsCycle | **Alias** of the reverse direction of `SimpleGraph.Walk.isCycle_mapLe`. | true |
_private.Lean.CoreM.0.Lean.initFn._@.Lean.CoreM.3719377344._hygCtx._hyg.4 | Lean.CoreM | IO (Lean.Option Bool) | null | false |
CategoryTheory.Limits.prod.rightUnitor.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasTerminal C] (P : C)
[inst_2 : CategoryTheory.Limits.HasBinaryProduct P (⊤_ C)],
CategoryTheory.Limits.prod.rightUnitor P =
{ hom := CategoryTheory.Limits.prod.fst,
inv :=
CategoryTheory.Limits.prod.lift (Ca... | null | true |
Lean.Grind.CommRing.lt_mul | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] [inst_1 : LE α] [inst_2 : LT α] [Std.LawfulOrderLT α]
[inst_4 : Std.IsPreorder α] [Lean.Grind.OrderedRing α] (ctx : Lean.Grind.CommRing.Context α)
(p₁ : Lean.Grind.CommRing.Poly) (k : ℤ) (p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.mul_ineq_cert p₁ k p = true... | null | true |
CategoryTheory.Limits.preservesLimit_subsingleton | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (K : CategoryTheory.Functor J C)
(F : CategoryTheory.Functor C D), Subsingleton (CategoryTheory.Limits.PreservesLimit K F) | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex.0.SSet.prodStdSimplex.exists_nonDegenerate_max_dim_aux._simp_1_10 | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex | ∀ {n : ℕ} {a b : Fin n}, (a ≤ b) = (↑a ≤ ↑b) | null | false |
SSet.Truncated.Edge.CompStruct.d₀._autoParam | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | Lean.Syntax | null | false |
Metric.preimage_vadd_closedBall | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} {X : Type w} [inst : PseudoMetricSpace X] [inst_1 : AddGroup G] [inst_2 : AddAction G X]
[IsIsometricVAdd G X] (c : G) (x : X) (r : ℝ),
(fun x => c +ᵥ x) ⁻¹' Metric.closedBall x r = Metric.closedBall (-c +ᵥ x) r | null | true |
Lean.Meta.RefinedDiscrTree.ExprInfo.noConfusionType | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Sort u → Lean.Meta.RefinedDiscrTree.ExprInfo → Lean.Meta.RefinedDiscrTree.ExprInfo → Sort u | null | false |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.uniformity_eq_comap_nhds_zero._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set (α × α)},
(s ∈ uniformity α) = ∃ ε > 0, ∀ ⦃a b : α⦄, dist a b < ε → (a, b) ∈ s | null | false |
CategoryTheory.instFinallySmallOfHasTerminal | Mathlib.CategoryTheory.Limits.FinallySmall | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] [CategoryTheory.Limits.HasTerminal J],
CategoryTheory.FinallySmall J | null | true |
TopPair.HomologyPretheory.instCategory._proof_8 | Mathlib.AlgebraicTopology.EilenbergSteenrod | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_4} {c : ComplexShape ι} {X Y Z : TopPair.HomologyPretheory C c} (f : X.Hom Y) (g : Y.Hom Z) (i j : ι),
CategoryTheory.CategoryStruct.comp (X.δ i j)
(TopPair.proj₂.whiskerLeft
... | null | false |
Std.DTreeMap.Internal.Impl.maxKeyD.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → α → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(x_1 : α) →
((fallback : α) → motive Std.DTreeMap.Internal.Impl.leaf fallback) →
((size : ℕ) →
(k : α) →
(v ... | null | false |
Path.Homotopic.pi_lift | Mathlib.Topology.Homotopy.Product | ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {as bs : (i : ι) → X i}
(γ : (i : ι) → Path (as i) (bs i)),
(Path.Homotopic.pi fun i => Path.Homotopic.Quotient.mk (γ i)) = Path.Homotopic.Quotient.mk (Path.pi γ) | null | true |
Complex.cosh_two_mul | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℂ), Complex.cosh (2 * x) = Complex.cosh x ^ 2 + Complex.sinh x ^ 2 | [DLMF 4.35.E27](https://dlmf.nist.gov/4.35.E27) | true |
CategoryTheory.Functor.CoreMonoidal.mk'._auto_3 | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | null | false |
instFiniteProp | Mathlib.Data.Fintype.EquivFin | ∀ (p : Prop), Finite p | null | true |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.initFn._@.Mathlib.Tactic.Ring.Basic.3588287011._hygCtx._hyg.2 | Mathlib.Tactic.Ring.Basic | IO (IO.Ref (Lean.Expr → Lean.MetaM Lean.Expr)) | null | false |
Primcodable.ulower | Mathlib.Computability.Primrec.Basic | {α : Type u_1} → [inst : Primcodable α] → Primcodable (ULower α) | null | true |
Std.IterM.toList_filter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {β : Type w} [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {f : β → Bool} {it : Std.IterM m β},
(Std.IterM.filter f it).toList = List.filter f <$> it.toList | null | true |
Std.Http.Protocol.H1.RedirectOutcome.done | Std.Http.Protocol.H1.Redirect | Std.Http.Protocol.H1.RedirectOutcome | Response is final. Stop redirecting and return it.
| true |
_private.Mathlib.Analysis.AbsoluteValue.Equivalence.0.AbsoluteValue.exists_one_lt_lt_one_pi_of_not_isEquiv.match_1_11 | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {R : Type u_1} {S : Type u_2} [inst : Field R] [inst_1 : Field S] [inst_2 : LinearOrder S] (ι : Type u_3)
(v : ι → AbsoluteValue R S) (i j : ι)
(motive :
(∃ a,
1 < (Subtype.restrict (fun k => k = i ∨ k = j) v ⟨i, ⋯⟩) a ∧
∀ (j_1 : { k // k = i ∨ k = j }), j_1 ≠ ⟨i, ⋯⟩ → (Subtype.restrict (fun... | null | false |
Aesop.CasesTarget.ctorIdx | Aesop.RuleTac.Basic | Aesop.CasesTarget → ℕ | null | false |
Ideal.Filtration.mem_submodule._simp_1 | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {I : Ideal R}
(F : I.Filtration M) (f : PolynomialModule R M), (f ∈ F.submodule) = ∀ (i : ℕ), f.coeff i ∈ F.N i | null | false |
PiLp.basisFun.eq_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (ι : Type u_2) [inst : Finite ι] [inst_1 : Ring 𝕜],
PiLp.basisFun p 𝕜 ι = Module.Basis.ofEquivFun (WithLp.linearEquiv p 𝕜 (ι → 𝕜)) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.