name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContMDiffAt.compContinuousLinearMapCLM | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F₁ : Type u_8} [inst_6 : NormedAddComm... | null | true |
Mathlib.Tactic.BicategoryCoherence.LiftHom.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
(CategoryTheory.FreeBicategory.of.obj a ⟶ CategoryTheory.FreeBicategory.of.obj b) →
Mathlib.Tactic.BicategoryCoherence.LiftHom f | null | false |
IsRegular.mem_nonZeroDivisors | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {r : M₀}, IsRegular r → r ∈ nonZeroDivisors M₀ | null | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.Context.casesOn | Lean.Server.Completion.CompletionCollectors | {motive : Lean.Server.Completion.Context✝ → Sort u} →
(t : Lean.Server.Completion.Context✝) →
((uri : Lean.Lsp.DocumentUri) →
(pos : Lean.Lsp.Position) →
(completionInfoPos : ℕ) → motive { uri := uri, pos := pos, completionInfoPos := completionInfoPos }) →
motive t | null | false |
Std.TreeMap.Raw.minKey?_insertIfNew_le_self | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp] (h : t.WF)
{k : α} {v : β} {kmi : α}, (t.insertIfNew k v).minKey?.get ⋯ = kmi → (cmp kmi k).isLE = true | null | true |
WithZero.instDivisionMonoid | Mathlib.Algebra.GroupWithZero.WithZero | {α : Type u_1} → [DivisionMonoid α] → DivisionMonoid (WithZero α) | null | true |
Nat.clog | Mathlib.Data.Nat.Log | ℕ → ℕ → ℕ | `clog b n`, is the upper logarithm of natural number `n` in base `b`. It returns the smallest
`k : ℕ` such that `n ≤ b^k`, so if `b^k = n`, it returns exactly `k`. | true |
SheafOfModules.instIsRightAdjointPushforward | Mathlib.Algebra.Category.ModuleCat.Sheaf.PullbackContinuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D}
{F : CategoryTheory.Functor C D} {S : CategoryTheory.Sheaf J RingCat} {R : CategoryTheory.Sheaf K RingCat}
... | null | true |
Array.idRun_ofFnM | Init.Data.Array.OfFn | ∀ {n : ℕ} {α : Type u_1} {f : Fin n → Id α}, (Array.ofFnM f).run = Array.ofFn fun i => (f i).run | null | true |
Std.ExtDHashMap.getD_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} {fallback : β k}, (m₁ ∪ m₂).getD k fallback = m₂.getD k (m₁.getD k fallback) | null | true |
PUnit.commGroup._proof_10 | Mathlib.Algebra.Group.PUnit | ∀ (x : PUnit.{u_1 + 1}), PUnit.unit * x = PUnit.unit * x | null | false |
Submonoid.comap_strictMono_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F}, Function.Surjective ⇑f → StrictMono (Submonoid.comap f) | null | true |
MeasureTheory.setLIntegral_trim_ae | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (hm : m ≤ m0) {f : α → ENNReal},
AEMeasurable f (μ.trim hm) →
∀ {s : Set α}, MeasurableSet s → ∫⁻ (x : α) in s, f x ∂μ.trim hm = ∫⁻ (x : α) in s, f x ∂μ | null | true |
Lean.CollectLevelParams.visitExpr | Lean.Util.CollectLevelParams | Lean.Expr → Lean.CollectLevelParams.Visitor | null | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.rightHomologyData_H | 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}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {... | null | true |
CategoryTheory.Pi.laxMonoidalPi._proof_4 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_5} [inst : (i : I) → CategoryTheory.Category.{u_4, u_5} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : I → Type u_3}
[inst_2 : (i : I) → CategoryTheory.Category.{u_1, u_3} (D i)]
[inst_3 : (i : I) → CategoryTheory.MonoidalCategory (D i)] (F : (i : I) → Cate... | null | false |
Std.Http.Protocol.H1.PulledChunk.ctorIdx | Std.Http.Protocol.H1 | Std.Http.Protocol.H1.PulledChunk → ℕ | null | false |
Lean.withoutModifyingEnv | Lean.MonadEnv | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → [MonadFinally m] → {α : Type} → m α → m α | null | true |
sInf_within_of_ordConnected | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] {s : Set α} [hs : s.OrdConnected] ⦃t : Set ↑s⦄,
t.Nonempty → BddBelow t → sInf (Subtype.val '' t) ∈ s | The `sInf` function on a nonempty `OrdConnected` set `s` in a conditionally complete linear
order takes values within `s`, for all nonempty bounded-below subsets of `s`. | true |
Real.arccos_eq_pi_div_two | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x : ℝ}, Real.arccos x = Real.pi / 2 ↔ x = 0 | null | true |
_private.Mathlib.Data.Nat.ChineseRemainder.0.Nat.modEq_list_map_prod_iff._simp_1_5 | Mathlib.Data.Nat.ChineseRemainder | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
InnerProductSpace.Core.normSq.eq_1 | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), InnerProductSpace.Core.normSq x = RCLike.re (inner 𝕜 x x) | null | true |
Bornology.isBounded_univ | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} [inst : Bornology α], Bornology.IsBounded Set.univ ↔ BoundedSpace α | null | true |
Std.Rxi.Iterator.instIteratorLoop.loop.eq_1 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] (γ : Type u) (Pl : α → γ → ForInStep γ → Prop) (LargeEnough : α → Prop)
(hl : ∀ (a b : α), Std.PRange.UpwardEnumerable.LE a b → LargeEnough a → LargeEnough b) (acc : γ) (next... | null | true |
Equiv.group._proof_3 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Group β] (x : α), e (e.symm (e.toFun x)⁻¹) = (e.toFun x)⁻¹ | null | false |
ContinuousAddEquiv.symm_apply_eq | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Add M]
[inst_3 : Add N] (e : M ≃ₜ+ N) {x : N} {y : M}, e.symm x = y ↔ x = e y | null | true |
PreAbstractSimplicialComplex.instSupSet | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | (ι : Type u_1) → SupSet (PreAbstractSimplicialComplex ι) | null | true |
Set.IicExtend | Mathlib.Order.Interval.Set.ProjIcc | {α : Type u_1} → {β : Type u_2} → [inst : LinearOrder α] → {b : α} → (↑(Set.Iic b) → β) → α → β | Extend a function `(-∞, b] → β` to a map `α → β`. | true |
CuspForm.discriminantEquiv._proof_2 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | ∀ {k : ℤ} (f : CuspForm (Matrix.SpecialLinearGroup.mapGL ℝ).range k),
∀ x ∈ (Matrix.SpecialLinearGroup.mapGL ℝ).range,
(SlashAction.map (k - 12) x fun z => f z / ModularForm.discriminant z) = fun z => f z / ModularForm.discriminant z | null | false |
EMetric.cauchy_iff | Mathlib.Topology.EMetricSpace.Basic | ∀ {γ : Type u} [inst : PseudoEMetricSpace γ] {f : Filter γ},
Cauchy f ↔ f ≠ ⊥ ∧ ∀ ε > 0, ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, edist x y < ε | ε-δ characterization of Cauchy sequences on pseudoemetric spaces | true |
TopRep.comp_smul' | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u} {G : Type v} [inst : TopologicalSpace k] [inst_1 : CommRing k] [inst_2 : Monoid G] (A B C : TopRep k G)
(f : A ⟶ B) (r : k) (g : B ⟶ C),
CategoryTheory.CategoryStruct.comp f (r • g) = r • CategoryTheory.CategoryStruct.comp f g | null | true |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.rwaSuggestion._sparseCasesOn_1 | Mathlib.Tactic.TacticAnalysis.Declarations | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
TensorAlgebra.ι_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
((TensorAlgebra.ι R) x = 0) = (x = 0) | null | false |
_private.Mathlib.Algebra.Group.Subsemigroup.Operations.0.Subsemigroup.prod_top._simp_1_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {s : Subsemigroup M} {t : Subsemigroup N} {p : M × N},
(p ∈ s.prod t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
Lean.Parser.ParserState.ctorIdx | Lean.Parser.Types | Lean.Parser.ParserState → ℕ | null | false |
Asymptotics.isBigOWith_const_one | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E : Type u_3} (F : Type u_4) [inst : Norm E] [inst_1 : Norm F] [inst_2 : One F] [NormOneClass F]
(c : E) (l : Filter α), Asymptotics.IsBigOWith ‖c‖ l (fun _x => c) fun _x => 1 | null | true |
WithBot.noMaxOrder | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] [NoMaxOrder α] [Nonempty α], NoMaxOrder (WithBot α) | null | true |
riemannZeta_neg_nat_eq_bernoulli' | Mathlib.NumberTheory.LSeries.HurwitzZetaValues | ∀ (k : ℕ), riemannZeta (-↑k) = -↑(bernoulli' (k + 1)) / (↑k + 1) | Value of Riemann zeta at `-ℕ` in terms of `bernoulli'`. | true |
Lean.Grind.Nat.le_lo | Init.Grind.Offset | ∀ (u w v k : ℕ), u ≤ w → w + k ≤ v → u + k ≤ v | null | true |
FixedPoints.minpoly.eval₂' | Mathlib.FieldTheory.Fixed | ∀ (G : Type u) [inst : Group G] (F : Type v) [inst_1 : Field F] [inst_2 : MulSemiringAction G F] [inst_3 : Fintype G]
(x : F), Polynomial.eval₂ (FixedPoints.subfield G F).subtype x (FixedPoints.minpoly G F x) = 0 | null | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.VisitStep | Mathlib.Tactic.DefEqAbuse | Type u_1 → Type u_1 | A return value for functions called by traversals of `MessageData`. May either descend into
children or ascend immediately (skipping children), optionally including a value accumulated by the
traversal in both cases. | true |
ENNReal.truncateToReal.eq_1 | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ (t x : ENNReal), t.truncateToReal x = (min t x).toReal | null | true |
AddSubgroup.iInf_normalizer_le_normalizer_iInf | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Sort u_5} (H : ι → AddSubgroup G),
⨅ i, AddSubgroup.normalizer ↑(H i) ≤ AddSubgroup.normalizer ↑(⨅ i, H i) | null | true |
FinBddDistLat.Hom | Mathlib.Order.Category.FinBddDistLat | FinBddDistLat → FinBddDistLat → Type u | The type of morphisms in `FinBddDistLat R`. | true |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.depForallDepth | Mathlib.Tactic.Translate.Reorder | Lean.Expr → ℕ | Determine how many forall binders should be introduced to get a non-dependent conclusion. | true |
CategoryTheory.Functor.leftKanExtensionUnit_leftKanExtension_map_leftKanExtensionObjIsoColimit_hom | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] (X : D) (f : Ca... | null | true |
Std.DTreeMap.Internal.Impl.alter._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.LawfulEqOrd α] →
(k : α) →
(Option (β k) → Option (β k)) →
(t : Std.DTreeMap.Internal.Impl α β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β (t.size - 1) (t.size + 1) | null | false |
Std.Http.Protocol.H1.Writer.messageHead | Std.Http.Protocol.H1.Writer | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Writer dir → Std.Http.Protocol.H1.Message.Head dir.swap | The outgoing message that will be written to the output.
| true |
Fin.encodeOrdering_decodeOrdering | Batteries.Data.Fin.Coding | ∀ (x : Fin 3), Fin.encodeOrdering (Fin.decodeOrdering x) = x | null | true |
CategoryTheory.rightDistrib | Mathlib.CategoryTheory.Distributive.Monoidal | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] →
[CategoryTheory.IsMonoidalRightDistrib C] →
(X Y Z : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj Y X ⨿... | The canonical right distributivity isomorphism | true |
Set.list_sum_subset_list_sum | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] (t : List ι) (f₁ f₂ : ι → Set α),
(∀ i ∈ t, f₁ i ⊆ f₂ i) → (List.map f₁ t).sum ⊆ (List.map f₂ t).sum | An n-ary version of `Set.add_subset_add`. | true |
UInt64.add_comm | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a + b = b + a | null | true |
Rep.hom_ext | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : Semiring k] [inst_1 : Monoid G] {A B : Rep.{w, u, v} k G} {f g : A ⟶ B},
Rep.Hom.hom f = Rep.Hom.hom g → f = g | null | true |
Ordinal.veblen_gamma_zero | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), Ordinal.veblen o.gamma 0 = o.gamma | null | true |
_private.Mathlib.Order.Concept.0.mem_lowerPolar_singleton._simp_1_2 | Mathlib.Order.Concept | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
CategoryTheory.Subgroupoid.hom | Mathlib.CategoryTheory.Groupoid.Subgroupoid | {C : Type u} →
[inst : CategoryTheory.Groupoid C] → (S : CategoryTheory.Subgroupoid C) → CategoryTheory.Functor (↑S.objs) C | The embedding of the coerced subgroupoid to its parent | true |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_3 | Init.Data.String.FindPos | ∀ (s : String.Slice) (offset : String.Pos.Raw) (h : offset ≤ s.rawEndPos) (this : offset < s.rawEndPos),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun offset h => s.utf8ByteSize - offset.byteIdx)
⟨offset.inc, ⋯⟩ ⟨offset, h⟩ | null | false |
Lean.Meta.mkSub | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Returns `a - b` using a heterogeneous `-`. This method assumes `a` and `b` have the same type. | true |
Algebra.RingHom.adjoinAlgebraMap | Mathlib.RingTheory.Adjoin.Singleton | {A : Type u_1} →
{B : Type u_2} →
{C : Type u_3} →
[inst : CommSemiring A] →
[inst_1 : CommSemiring B] →
[inst_2 : CommSemiring C] →
[inst_3 : Algebra A B] →
[inst_4 : Algebra B C] →
[inst_5 : Algebra A C] → [IsScalarTower A B C] → (b : B) → ↥A[b] ... | Ring homomorphism between `A[b]` and `A[↑b]`. | true |
Real.fromBinary._proof_2 | Mathlib.Topology.MetricSpace.HausdorffAlexandroff | ∀ (x : ℕ → Bool),
0 ≤ (Real.ofDigits ∘ ⇑(Homeomorph.piCongrRight fun x => finTwoEquiv.toHomeomorphOfDiscrete.symm)) x ∧
(Real.ofDigits ∘ ⇑(Homeomorph.piCongrRight fun x => finTwoEquiv.toHomeomorphOfDiscrete.symm)) x ≤ 1 | null | false |
StarAlgEquiv.arrowCongr'_comp | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_1} {A₁ : Type u_2} {A₂ : Type u_3} {A₃ : Type u_4} {A₁' : Type u_5} {A₂' : Type u_6} {A₃' : Type u_7}
[inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A₁] [inst_2 : DistribMulAction R A₁] [inst_3 : Star A₁]
[inst_4 : NonUnitalNonAssocSemiring A₂] [inst_5 : DistribMulAction R A₂] [inst_6 : Star A₂... | null | true |
Associated.isRelPrime_left | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M] {a b c : M}, Associated a b → IsRelPrime a c → IsRelPrime b c | null | true |
Lean.LocalContext.foldr | Lean.LocalContext | {β : Type u_1} → Lean.LocalContext → (Lean.LocalDecl → β → β) → β → β | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionHom_comp | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {C : Type u_1} {D : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {inst_2 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {c c' c'' : C} {d d' d'' : D} (f₁ : c ⟶ c')
(f₂ : c' ⟶ c'') (g₁ : d ⟶ d') (g₂ :... | null | true |
Affine.Simplex.orthogonalProjection_eq_circumcenter_of_exists_dist_eq | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n) {p : P},
(∃ r, ∀ (i : Fin (n + 1)), dist (s.points i) p = r) → ↑(s.orthogonalProjectionSpan p) = s.circumcenter | If there exists a distance that a point has from all vertices of a
simplex, the orthogonal projection of that point onto the subspace
spanned by that simplex is its circumcenter. | true |
Commute.sub_dvd_pow_sub_pow | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] {x y : R}, Commute x y → ∀ (n : ℕ), x - y ∣ x ^ n - y ^ n | null | true |
Lean.Meta.Sym.Canon.State.cache | Lean.Meta.Sym.SymM | Lean.Meta.Sym.Canon.State → Std.HashMap Lean.Expr Lean.Expr | Cache for value-level canonicalization (no type reductions applied). | true |
Erased.join | Mathlib.Data.Erased | {α : Sort u_1} → Erased (Erased α) → Erased α | Collapses two levels of erasure.
| true |
CategoryTheory.ObjectProperty.SerreClassLocalization.map_eq_zero_iff | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] (L : CategoryTheory.Functor C D) (P : CategoryTheory.ObjectProperty C)
[inst_3 : P.IsSerreClass] [L.IsLocalization P.isoModSerre] [inst_5 : CategoryTheory.Preaddit... | null | true |
_private.Mathlib.RingTheory.DividedPowerAlgebra.Init.0.DividedPowerAlgebra.dp_sum_smul._simp_1_1 | Mathlib.RingTheory.DividedPowerAlgebra.Init | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : CommMonoid M] {f g : ι → M},
(∏ x ∈ s, f x) * ∏ x ∈ s, g x = ∏ x ∈ s, f x * g x | null | false |
CategoryTheory.SmallCategoryCardinalLT.exists_equivalence | Mathlib.CategoryTheory.SmallRepresentatives | ∀ (κ : Cardinal.{w}) (C : Type u) [inst : CategoryTheory.Category.{v, u} C],
HasCardinalLT (CategoryTheory.Arrow C) κ →
∃ S, Nonempty (CategoryTheory.SmallCategoryCardinalLT.categoryFamily κ S ≌ C) | null | true |
ClosureOperator.le_closure | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : Preorder α] (c : ClosureOperator α) (x : α), x ≤ c x | Every element is less than its closure. This property is sometimes referred to as extensivity or
inflationarity. | true |
IsCoveringMap.liftHomotopyRel._proof_1 | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_3} {A : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X]
[inst_2 : TopologicalSpace A] {p : E → X} (cov : IsCoveringMap p) {f₀ f₁ : C(A, X)} {S : Set A}
(F : f₀.HomotopyRel f₁ S) {f₀' : C(A, E)} (F_0 : ∀ (a : A), F (0, a) = p (f₀' a)) (t : ↑unitInterval),
∀ a ∈ S, (... | null | false |
_private.Mathlib.Topology.Separation.Basic.0.t1Space_TFAE._simp_1_7 | Mathlib.Topology.Separation.Basic | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ⊆ {a}ᶜ) = (a ∉ s) | null | false |
commutator_def | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : Group G], commutator G = ⁅⊤, ⊤⁆ | null | true |
Pi.mulZeroClass._proof_2 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] (a : (i : ι) → α i), a * 0 = 0 | null | false |
SummationFilter.eventually_mem_or_notMem | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {β : Type u_2} (L : SummationFilter β) [L.HasSupport] (b : β),
(∀ᶠ (s : Finset β) in L.filter, b ∈ s) ∨ ∀ᶠ (s : Finset β) in L.filter, b ∉ s | null | true |
contDiff_one_iff_fderiv | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F},
ContDiff 𝕜 1 f ↔ Differentiable 𝕜 f ∧ Continuous (fderiv 𝕜 f) | null | true |
FiberBundleCore.mk_mem_localTrivAt_source | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (b : B) (a : F), ⟨b, a⟩ ∈ (Z.localTrivAt b).source | null | true |
CategoryTheory.SingleObj | Mathlib.CategoryTheory.SingleObj | Type u_1 → Type | Abbreviation that allows writing `CategoryTheory.SingleObj` rather than `Quiver.SingleObj`.
| true |
Std.Tactic.BVDecide.LRAT.instBEqAction.beq._sparseCasesOn_2 | Std.Tactic.BVDecide.LRAT.Actions | {β : Type u} →
{α : Type v} →
{motive : Std.Tactic.BVDecide.LRAT.Action β α → Sort u_1} →
(t : Std.Tactic.BVDecide.LRAT.Action β α) →
((id : ℕ) → (c : β) → (rupHints : Array ℕ) → motive (Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motiv... | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.ofIdeals_mono | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, Monotone AlgebraicGeometry.Scheme.IdealSheafData.ofIdeals | null | true |
_private.Lean.Level.0.Lean.Level.normLtAux._unary.eq_def | Lean.Level | ∀ (_x : (_ : Lean.Level) ×' (_ : ℕ) ×' (_ : Lean.Level) ×' ℕ),
Lean.Level.normLtAux._unary _x =
PSigma.casesOn _x fun a a_1 =>
PSigma.casesOn a_1 fun a_2 a_3 =>
PSigma.casesOn a_3 fun a_4 a_5 =>
match a, a_2, a_4, a_5 with
| l₁.succ, k₁, l₂, k₂ => Lean.Level.normLtAux._unary ⟨l₁,... | null | false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix.noConfusionType | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | Sort u →
{n m : ℕ} →
Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix n m →
{n' m' : ℕ} → Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix n' m' → Sort u | null | false |
_private.Mathlib.Analysis.Analytic.Within.0.analyticWithinAt_of_singleton_mem._simp_1_3 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn.eq_1 | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] (f : α → β) (y : α) (ys : List α)
(h_2 : y :: ys ≠ []), List.minIdxOn f (y :: ys) h_2 = List.minIdxOn.go✝ f y 0 1 ys | null | true |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_4} {D : Type u_3} [inst : CategoryTheory.Category.{u_5, u_4} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
{X Y : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} (f : X ⟶ Y)
(X' : PresheafOf... | null | false |
Std.Http.Protocol.H1.Reader.State.ctorElim | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} →
{motive : Std.Http.Protocol.H1.Reader.State dir → Sort u} →
(ctorIdx : ℕ) →
(t : Std.Http.Protocol.H1.Reader.State dir) →
ctorIdx = t.ctorIdx → Std.Http.Protocol.H1.Reader.State.ctorElimType ctorIdx → motive t | null | false |
CategoryTheory.StructuredArrow.pre_obj_hom | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{B : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} B] (S : D) (F : CategoryTheory.Functor B C)
(G : CategoryTheory.Functor C D) (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S)... | null | true |
continuous_of_isClosed_graph | Mathlib.Topology.Maps.Proper.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} [CompactSpace Y],
IsClosed (Function.graph f) → Continuous f | A function into a compact space with a closed graph is continuous.
For the closed graph theorem of functional analysis, about linear maps between Banach spaces, see
`LinearMap.continuous_of_isClosed_graph`. | true |
Group.IsFinitelyPresented.instMultiplicativeInt | Mathlib.GroupTheory.FinitelyPresentedGroup | Group.IsFinitelyPresented (Multiplicative ℤ) | `Multiplicative ℤ` is finitely presented. | true |
_private.Mathlib.Topology.DiscreteSubset.0.discreteTopology_iUnion_finite._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X}, DiscreteTopology ↑s = IsDiscrete s | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting___macroRules__private_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting_0_CategoryTheory_Limits_termI₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.Macro | null | false |
Prod.Lex.uniqueProd | Mathlib.Order.Hom.Lex | (α : Type u_2) → (β : Type u_3) → [inst : Preorder α] → [Unique α] → [inst_2 : LE β] → Lex (α × β) ≃o β | Lexicographic product type with `Unique` type on the left is `OrderIso` to the right. | true |
AnalyticOn.contDiff | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : WithTop ℕ∞}, AnalyticOn 𝕜 f Set.univ → ContDiff 𝕜 n f | null | true |
AlgebraicIndependent.matroid.congr_simp | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ (R : Type u_1) (A : Type w) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : NoZeroDivisors A],
AlgebraicIndependent.matroid R A = AlgebraicIndependent.matroid R A | null | true |
CategoryTheory.Functor.additive_of_comp_faithful | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.Preadditive C] [inst_4 : CategoryTheory.Preadditive D]
[inst_5 : CategoryTheory.Preadditive E] (F : ... | null | true |
WithLp.prodContinuousLinearEquiv_symm_apply_ofLp | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : Semiring 𝕜] [inst_3 : AddCommGroup α] [inst_4 : AddCommGroup β] [inst_5 : Module 𝕜 α] [inst_6 : Module 𝕜 β]
(a : α × β), ((WithLp.prodContinuousLinearEquiv p 𝕜 α β).symm a).ofLp = a | null | true |
_private.Mathlib.LinearAlgebra.SymplecticGroup.0.SymplecticGroup.fromBlocks_mem_iff._simp_1_6 | Mathlib.LinearAlgebra.SymplecticGroup | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Algebra.intNorm_eq_of_isLocalization | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ {A : Type u_1} {B : Type u_6} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {Aₘ : Type u_9}
{Bₘ : Type u_10} [inst_3 : CommRing Aₘ] [inst_4 : CommRing Bₘ] [inst_5 : Algebra Aₘ Bₘ] [inst_6 : Algebra A Aₘ]
[inst_7 : Algebra B Bₘ] [inst_8 : Algebra A Bₘ] [IsScalarTower A Aₘ Bₘ] [IsScalarTower A B ... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.