name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
NNReal.enorm_eq | Mathlib.Analysis.Normed.Ring.Basic | ∀ (x : NNReal), ‖↑x‖ₑ = ↑x | null | true |
_private.Mathlib.Topology.UniformSpace.HeineCantor.0.Continuous.tendstoUniformly.match_1_1 | Mathlib.Topology.UniformSpace.HeineCantor | ∀ {α : Type u_1} [inst : UniformSpace α] (x : α) (motive : (∃ s, IsCompact s ∧ s ∈ nhds x) → Prop)
(x_1 : ∃ s, IsCompact s ∧ s ∈ nhds x), (∀ (K : Set α) (hK : IsCompact K) (hxK : K ∈ nhds x), motive ⋯) → motive x_1 | null | false |
Lean.Grind.CommRing.Power.denote_eq | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α) (p : Lean.Grind.CommRing.Power),
Lean.Grind.CommRing.Power.denote ctx p = Lean.Grind.CommRing.Var.denote ctx p.x ^ p.k | null | true |
CategoryTheory.Codiscrete.recOn | Mathlib.CategoryTheory.CodiscreteCategory | {α : Type u} →
{motive : CategoryTheory.Codiscrete α → Sort u_1} →
(t : CategoryTheory.Codiscrete α) → ((as : α) → motive { as := as }) → motive t | null | false |
_private.Mathlib.Algebra.Lie.Extension.0.LieAlgebra.Extension.twoCocycleAux._abel_2 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_2} {L : Type u_4} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing M] [inst_4 : LieAlgebra R M] (E : LieAlgebra.Extension R M L) {s : L →ₗ[R] E.L} (x y x_1 : L),
⁅s x, s x_1⁆ + ⁅s y, s x_1⁆ - (s ⁅x, x_1⁆ + s ⁅y, x_1⁆) = ⁅s x, s x_1⁆ - s ⁅x, x_1⁆ + (⁅s... | null | false |
ProbabilityTheory.Kernel.prodMkLeft_apply' | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (ca : γ × α) (s : Set β),
((ProbabilityTheory.Kernel.prodMkLeft γ κ) ca) s = (κ ca.2) s | null | true |
List.le_minIdxOn_of_apply_getElem_lt_apply_getElem._proof_2 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {xs : List α} {i : ℕ}, i < xs.length → ∀ j < i, j < xs.length | null | false |
_private.Mathlib.Algebra.Order.Algebra.0.Mathlib.Meta.Positivity.evalAlgebraMap._proof_5 | Mathlib.Algebra.Order.Algebra | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | null | false |
LinearIsometry.one_def | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {E : Type u_5} [inst : Semiring R] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module R E],
1 = LinearIsometry.id | null | true |
BitVec.reduceShiftLeftShiftLeft | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.Simproc | null | true |
UpperSet.mem_Ioi_iff._simp_2 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (b ∈ UpperSet.Ioi a) = (a < b) | null | false |
Lean.Meta.DefEqContext.localInstances | Lean.Meta.Basic | Lean.Meta.DefEqContext → Lean.LocalInstances | null | true |
AlgebraicGeometry.instLocallyOfFinitePresentationFstScheme | Mathlib.AlgebraicGeometry.Morphisms.FinitePresentation | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [AlgebraicGeometry.LocallyOfFinitePresentation g],
AlgebraicGeometry.LocallyOfFinitePresentation (CategoryTheory.Limits.pullback.fst f g) | null | true |
HomologicalComplex.extend.X.eq_2 | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {c : ComplexShape ι} {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), HomologicalComplex.extend.X K none = 0 | null | true |
Std.DHashMap.Raw.Const.getD_eq_getD | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : LawfulBEq α], m.WF → ∀ {a : α} {fallback : β}, Std.DHashMap.Raw.Const.getD m a fallback = m.getD a fallback | null | true |
_private.Mathlib.Topology.Order.WithTop.0.TopologicalSpace.instSecondCountableTopologyWithTop._proof_2 | Mathlib.Topology.Order.WithTop | ∀ {ι : Type u_1} [inst : Preorder ι], (∃ x, Set.Ioi x = ∅) → ∃ x, Set.Ioi x = ∅ | null | false |
Lean.Meta.letTelescope | Lean.Meta.Basic | {n : Type → Type u_1} →
[MonadControlT Lean.MetaM n] →
[Monad n] →
{α : Type} →
Lean.Expr →
(Array Lean.Expr → Lean.Expr → n α) → optParam Bool false → optParam Bool true → optParam Bool false → n α | Given `e` of the form `let x₁ := v₁; ...; let xₙ := vₙ; A`, executes `k xs A`,
where `xs` is an array of free variables for the binders.
The `let`s can also be `have`s.
- If `cleanupAnnotations` is `true`, applies `Expr.cleanupAnnotations` to each type in the telescope.
- If `preserveNondep` is `false`, all `have`s ar... | true |
_private.Mathlib.Order.Partition.Basic.0.Partition.instSemilatticeInf.match_15 | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} [inst : Order.Frame α] (s : α) (Q : Partition s) (a : α) (motive : (∃ y ∈ Q, a ≤ y) → Prop)
(x : ∃ y ∈ Q, a ≤ y), (∀ (q : α) (hq : q ∈ Q ∧ a ≤ q), motive ⋯) → motive x | null | false |
CategoryTheory.Limits.isColimitMapCoconeCoforkEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Equalizers | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor C D) {X Y Z : C} {f g : X ⟶ Y} {h : Y ⟶ Z}
(w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h),
CategoryTheory.CategoryStruct.... | null | false |
Lean.Meta.Grind.Arith.CommRing.NonCommSemiringM.Context.mk._flat_ctor | Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM | ℕ → Lean.Meta.Grind.Arith.CommRing.NonCommSemiringM.Context | null | false |
LinearMap.exact_zero_iff_injective._simp_1 | Mathlib.Algebra.Exact.Basic | ∀ {R : Type u_8} [inst : Ring R] {M : Type u_12} {N : Type u_13} (P : Type u_14) [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommMonoid P] [inst_4 : Module R N] [inst_5 : Module R M] [inst_6 : Module R P]
(f : M →ₗ[R] N), Function.Exact ⇑0 ⇑f = Function.Injective ⇑f | null | false |
Std.ExtDHashMap.contains_congr | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a b : α}, (a == b) = true → m.contains a = m.contains b | null | true |
Lean.Meta.Grind.Arith.Cutsat.State.dvds._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.PersistentArray (Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) | null | false |
AlgebraicGeometry.IsReduced.component_reduced | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme} [self : AlgebraicGeometry.IsReduced X] (U : X.Opens),
IsReduced ↑(X.presheaf.obj (Opposite.op U)) | null | true |
LieHom.quotKerEquivRange_invFun | Mathlib.Algebra.Lie.Quotient | ∀ {R : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (f : L →ₗ⁅R⁆ L') (a : ↥(↑f).range),
f.quotKerEquivRange.invFun a = (↑f).quotKerEquivRange.invFun a | null | true |
Ergodic | Mathlib.Dynamics.Ergodic.Ergodic | {α : Type u_1} → {m : MeasurableSpace α} → (α → α) → autoParam (MeasureTheory.Measure α) Ergodic._auto_1 → Prop | A map `f : α → α` is said to be ergodic with respect to a measure `μ` if it is measure
preserving and pre-ergodic. | true |
Filter.Tendsto.isCompact_insert_range_of_cocompact | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {y : Y},
Filter.Tendsto f (Filter.cocompact X) (nhds y) → Continuous f → IsCompact (insert y (Set.range f)) | null | true |
Batteries.Tactic.Lint.checkAllSimpTheoremInfos | Batteries.Tactic.Lint.Simp | Lean.Expr →
(Batteries.Tactic.Lint.SimpTheoremInfo → Lean.MetaM (Option Lean.MessageData)) → Lean.MetaM (Option Lean.MessageData) | Constructs a message from all the simp theorems encoded in the given type. | true |
Fin.rxiHasSize_eq | Init.Data.Range.Polymorphic.Fin | ∀ {n : ℕ}, Std.Rxi.HasSize.size = fun lo => n - ↑lo | null | true |
CategoryTheory.sum_whiskerRight | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C] {Q R : C} {J : Type u_2}
(s : Finset J) (g : J → (Q ⟶ R)) (P : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (∑ j ∈ s,... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_erase_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
IsOpen.isConnected_iff_isPathConnected | Mathlib.Topology.Connected.LocPathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] [LocPathConnectedSpace X] {U : Set X},
IsOpen U → (IsConnected U ↔ IsPathConnected U) | null | true |
Lean.Meta.Grind.Order.Cnstr | Lean.Meta.Tactic.Grind.Order.Types | Type → Type | A constraint of the form `u ≤ v + k` (`u < v + k` if `strict := true`)
Remark: If the order does not support offsets, then `k` is zero.
`h? := some h` if the Lean expression is not definitionally equal to the constraint,
but provably equal with proof `h`.
| true |
Std.Do.Spec.Iter.forIn_filterMap | Std.Do.Triple.SpecLemmas | ∀ {α β β₂ γ : Type w} [inst : Std.Iterator α Id β] {ps : Std.Do.PostShape} {n : Type w → Type u_1} [inst_1 : Monad n]
[LawfulMonad n] [inst_3 : Std.Do.WPMonad n ps] [Std.Iterators.Finite α Id] [inst_5 : Std.IteratorLoop α Id n]
[Std.LawfulIteratorLoop α Id n] {it : Std.Iter β} {f : β → Option β₂} {init : γ} {g : β₂... | null | true |
ULift.up_compare | Mathlib.Order.ULift | ∀ {α : Type u} [inst : Ord α] (a b : α), compare { down := a } { down := b } = compare a b | null | true |
Submodule.span | Mathlib.LinearAlgebra.Span.Defs | (R : Type u_1) →
{M : Type u_4} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Set M → Submodule R M | The span of a set `s ⊆ M` is the smallest submodule of M that contains `s`. | true |
FreeGroup.Red.decidableRel._proof_1 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1}, FreeGroup.Red [] [] | null | false |
CategoryTheory.ComposableArrows.homMkSucc_app_zero | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)}
(α : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) (β : F.δ₀ ⟶ G.δ₀)
(w :
autoParam
(CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheo... | null | true |
CategoryTheory.Limits.BinaryFan.associatorOfLimitCone | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(L : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) →
(X Y Z : C) → (L (L X Y).cone.pt Z).cone.pt ≅ (L X (L Y Z).cone.pt).cone.pt | Given a fixed family of limit data for every pair `X Y`, we obtain an associator. | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestRevMatchAt_iff_extract._simp_1_3 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
Std.Iterators.Types.StepSizeIterator.instIterator._proof_1 | Std.Data.Iterators.Combinators.Monadic.StepSize | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] (it : Std.IterM m β)
(s : Std.PlausibleIterStep (Std.IterM.IsPlausibleNthOutputStep it.internalState.nextIdx it.internalState.inner)),
Std.IterM.IsPlausibleNthOutputStep it.internalState.nextIdx it.internalState.inner
(Std.Ite... | null | false |
Int.fdiv_add_fmod | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.fdiv b + a.fmod b = a | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.map | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | {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.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
{S : CategoryTheory.ShortComplex C} →
... | When a left homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced left homology data `h.map F` for the short complex `S.map F`. | true |
SimpleGraph.Walk.IsPath.mk' | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, p.support.Nodup → p.IsPath | null | true |
Lean.Data.Trie.node1.elim | Lean.Data.Trie | {α : Type} →
{motive_1 : Lean.Data.Trie α → Sort u} →
(t : Lean.Data.Trie α) →
t.ctorIdx = 1 →
((a : Option α) → (a_1 : UInt8) → (a_2 : Lean.Data.Trie α) → motive_1 (Lean.Data.Trie.node1 a a_1 a_2)) →
motive_1 t | null | false |
Algebra.Generators.cotangentRestrict._proof_1 | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_2}
(P : Algebra.Generators R S ι), SMulCommClass R P.toExtension.Ring P.toExtension.Ring | null | false |
CategoryTheory.Functor.CommShift.ofComp | Mathlib.CategoryTheory.Shift.CommShift | {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] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D ... | Given an isomorphism `e : F ⋙ G ≅ H` where `G` is fully faithful,
the functor `F` commutes with shifts by `A` if `G` and `H` do. | true |
Lean.Meta.DiscrTree.fold | Lean.Meta.DiscrTree.Util | {σ : Type u_1} → {α : Type} → (σ → Array Lean.Meta.DiscrTree.Key → α → σ) → σ → Lean.Meta.DiscrTree α → σ | Fold over the keys and values stored in a `DiscrTree`
| true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceEIntProdNatCoreE₂CohomologicalNat._proof_10 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r : ℤ) (p q p' q' : ℕ), ↑q - 1 + r = ↑q' → ↑(p', q').2 + (r, 1 - r).2 = ↑(p, q).2 | null | false |
Lean.Doc.MarkdownM.InlineCtx.inLink._default | Lean.DocString.Markdown | Bool | null | false |
CategoryTheory.MorphismProperty.HasQuotient.recOn | Mathlib.CategoryTheory.MorphismProperty.Quotient | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{homRel : HomRel C} →
[inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel] →
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel] →
{motive : W.HasQuotien... | null | false |
CategoryTheory.Functor.OplaxMonoidal.ofBifunctor.secondMap₂_app_app_app | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D}
(δ : CategoryTheory.MonoidalCategory.curriedTensorPost F ⟶ Catego... | null | true |
SimpleGraph.between.eq_1 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_1} (s t : Set V) (G : SimpleGraph V),
SimpleGraph.between s t G =
{ Adj := fun v w => G.Adj v w ∧ (v ∈ s ∧ w ∈ t ∨ v ∈ t ∧ w ∈ s), symm := ⋯, loopless := ⋯ } | null | true |
CategoryTheory.Limits.ChosenPullback.LiftStruct.f_p₁ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S}
{h : CategoryTheory.Limits.ChosenPullback f₁ f₂} {Y : C} {g₁ : Y ⟶ X₁} {g₂ : Y ⟶ X₂} {b : Y ⟶ S}
(self : h.LiftStruct g₁ g₂ b), CategoryTheory.CategoryStruct.comp self.f h.p₁ = g₁ | null | true |
CategoryTheory.GradedObject.Monoidal.pentagon_inv_assoc | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ X₄ : CategoryTheory.GradedObject I C)
[inst_3 : X₁.HasTensor X₂] [inst_4 : X₂.HasTensor X₃] [inst_5 : X₃.HasTensor X₄]
[inst_6 : (CategoryTheory.GradedObject.Mo... | null | true |
StarAlgEquiv.ofInjective._proof_3 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : StarRing A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : StarRing B] (f : A →⋆ₐ[R] B)
(hf : Function.Injective ⇑f) (x y : A),
(AlgEquiv.ofInjective (↑f) hf).toFun (x * y) =
(... | null | false |
Nat.multinomial_pos | Mathlib.Data.Nat.Choose.Multinomial | ∀ {α : Type u_1} (s : Finset α) (f : α → ℕ), 0 < Nat.multinomial s f | null | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanrMFast.loop._unary._proof_9 | Batteries.Data.Vector.Basic | ∀ {n : ℕ} (n_usize : USize),
n_usize.toNat = n → ∀ (i : USize), i.toNat ≤ n → 0 < i.toNat → (i - 1).toNat = i.toNat - 1 → (i - 1).toNat < n | null | false |
WithLp.fstₗ._proof_2 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_3) (α : Type u_2) (β : Type u_1) [inst : Semiring 𝕜] [inst_1 : AddCommGroup α]
[inst_2 : AddCommGroup β] [inst_3 : Module 𝕜 α] [inst_4 : Module 𝕜 β] (x : 𝕜) (x_1 : WithLp p (α × β)),
(x • x_1).fst = (x • x_1).fst | null | false |
AlgebraicGeometry.instConnectedSpaceCarrierCarrierCommRingCatFiberOfGeometricallyConnected | Mathlib.AlgebraicGeometry.Geometrically.Connected | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (s : ↥S) [AlgebraicGeometry.GeometricallyConnected f],
ConnectedSpace ↥(AlgebraicGeometry.Scheme.Hom.fiber f s) | null | true |
LinearMap.isCompl_iSup_ker_pow_iInf_range_pow | Mathlib.RingTheory.Artinian.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsArtinian R M]
[IsNoetherian R M] (f : M →ₗ[R] M), IsCompl (⨆ n, (f ^ n).ker) (⨅ n, (f ^ n).range) | This is the Fitting decomposition of the module `M` with respect to the endomorphism `f`.
See also `LinearMap.eventually_isCompl_ker_pow_range_pow` for an alternative spelling. | true |
Lean.Elab.Tactic.Do.State.invariants | Lean.Elab.Tactic.Do.VCGen.Basic | Lean.Elab.Tactic.Do.State → Array Lean.MVarId | Holes of type `Invariant` that have been generated so far.
| true |
Ordinal.type_le_iff' | Mathlib.SetTheory.Ordinal.Basic | ∀ {α β : Type u_1} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s],
Ordinal.type r ≤ Ordinal.type s ↔ Nonempty (r ↪r s) | null | true |
_private.Mathlib.Algebra.Star.Pointwise.0.Set.star_mul._simp_1_1 | Mathlib.Algebra.Star.Pointwise | ∀ {α : Type u_1} {s : Set α} [inst : InvolutiveStar α], star s = star '' s | null | false |
CategoryTheory.NatTrans.Equifibered.op | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equifibered | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_3} C] {F G : CategoryTheory.Functor J C} {α : F ⟶ G},
CategoryTheory.NatTrans.Equifibered α → CategoryTheory.NatTrans.Coequifibered (CategoryTheory.NatTrans.op α) | null | true |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._proof_1_28 | Mathlib.Algebra.Lie.CartanExists | ∀ {K : Type u_2} {L : Type u_1} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L],
AddSubgroupClass (LieSubalgebra K L) L | null | false |
BoundedContinuousFunction.extend._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_3} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] {δ : Type u_1}
[inst_2 : TopologicalSpace δ] [DiscreteTopology δ] (f : α ↪ δ) (g : BoundedContinuousFunction α β)
(h : BoundedContinuousFunction δ β), Continuous (Function.extend ⇑f ⇑g ⇑h) | null | false |
_private.Mathlib.Computability.PartrecBasis.0.Nat.Partrec'.rfindOpt._simp_1_3 | Mathlib.Computability.PartrecBasis | ∀ {α : Type u_1} {β : Type u_2} {f : Part α} {g : α → Part β} {b : β}, (b ∈ f.bind g) = ∃ a ∈ f, b ∈ g a | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_44 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls : ℕ) (ll lr : Std.DTreeMap.Internal.Impl α β) (ls : ℕ)
(ll_1 lr_1 : Std.DTreeMap.Internal.Impl α β),
ll_1.Balanced ∧
lr_1.Balanced ∧
(ll_1.size + lr_1.size ≤ 1 ∨ ll_1.size ≤ 3 * lr_1.size ∧ lr_1.size ≤ 3 * ll_1.size) ∧
ls = ll_1.size + 1 + lr_1.size →
... | null | false |
RootPairing.GeckConstruction.basis._proof_7 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {ι : Type u_1} {K : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : DecidableEq ι]
[inst_2 : Field K] [inst_3 : CharZero K] [inst_4 : AddCommGroup M] [inst_5 : Module K M] [inst_6 : AddCommGroup N]
[inst_7 : Module K N] {P : RootPairing ι K M N} [P.IsReduced] [inst_9 : P.IsCrystallographic] (... | null | false |
Lean.SimpleScopedEnvExtension.Descr.mk.inj | Lean.ScopedEnvExtension | ∀ {α σ : Type} {name : autoParam Lean.Name Lean.SimpleScopedEnvExtension.Descr.name._autoParam} {addEntry : σ → α → σ}
{initial : σ} {finalizeImport : σ → σ} {exportEntry? : Lean.Environment → α → Lean.OLeanEntries (Option α)}
{name_1 : autoParam Lean.Name Lean.SimpleScopedEnvExtension.Descr.name._autoParam} {addEn... | null | true |
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.exists_cons_of_mem.match_1_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {a : α} (l : List α) (motive : (∃ s t, l = s ++ a :: t) → Prop) (x : ∃ s t, l = s ++ a :: t),
(∀ (l₁ l₂ : List α) (e : l = l₁ ++ a :: l₂), motive ⋯) → motive x | null | false |
Std.DTreeMap.Raw.getKey?_inter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, (t₁ ∩ t₂).getKey? k = if t₂.contains k = true then t₁.getKey? k else none | null | true |
CategoryTheory.Lax.OplaxTrans.Hom.ext | 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} {x y : CategoryTheory.Lax.OplaxTrans.Hom η θ}, x.as = y.as → x = y | null | true |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.foldUntil.eq_def | Init.Data.String.Iterator | ∀ {α : Type u_1} (it : String.Legacy.Iterator) (init : α) (f : α → Char → Option α),
it.foldUntil init f =
if it.atEnd = true then (init, it)
else
match f init it.curr with
| some a => it.next.foldUntil a f
| x => (init, it) | null | true |
Order.isPredPrelimit_iff_isMax | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : PredOrder α] [IsPredArchimedean α],
Order.IsPredPrelimit a ↔ IsMax a | null | true |
CategoryTheory.Limits.colimitLimitIso.congr_simp | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
[inst_4 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_5 : CategoryTheory.Li... | null | true |
_private.Mathlib.Data.Set.Image.0.Set.image_comp_image._proof_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {f : α → β} {g : β → γ}, Set.image g ∘ Set.image f = Set.image (g ∘ f) | null | false |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitWithAndAscendM._auto_3 | Mathlib.Tactic.DefEqAbuse | Lean.Syntax | null | false |
selfAdjoint.instIntCastSubtypeMemAddSubgroup | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} → [inst : Ring R] → [inst_1 : StarRing R] → IntCast ↥(selfAdjoint R) | null | true |
and_or_left._simp_2 | Mathlib.Tactic.Push | ∀ {a b c : Prop}, (a ∧ b ∨ a ∧ c) = (a ∧ (b ∨ c)) | null | false |
MeasureTheory.Measure.finiteSpanningSetsIn_volumeIoiPow_range_Iio | Mathlib.MeasureTheory.Constructions.HaarToSphere | (n : ℕ) → (MeasureTheory.Measure.volumeIoiPow n).FiniteSpanningSetsIn (Set.range Set.Iio) | The intervals `(0, k + 1)` have finite measure `MeasureTheory.Measure.volumeIoiPow _`
and cover the whole open ray `(0, +∞)`. | true |
StarMulEquiv.toMulEquiv_symm | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} {B : Type u_3} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Star A] [inst_3 : Star B] (f : A ≃⋆* B),
f.symm.toMulEquiv = f.symm | null | true |
IsTopologicalGroup.tendstoUniformlyOn_iff | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {ι : Type u_1} {α : Type u_2} {G : Type u_3} [inst : Group G] [u : UniformSpace G] [inst_1 : IsTopologicalGroup G]
(F : ι → α → G) (f : α → G) (p : Filter ι) (s : Set α),
IsTopologicalGroup.rightUniformSpace G = u →
(TendstoUniformlyOn F f p s ↔ ∀ u_1 ∈ nhds 1, ∀ᶠ (i : ι) in p, ∀ a ∈ s, F i a / f a ∈ u_1) | null | true |
SummationFilter.HasSupport | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | {β : Type u_2} → SummationFilter β → Prop | Typeclass asserting that the sets in `L.filter` are eventually contained in `L.support`. This
is a sufficient condition for `L`-summation to behave well on finitely-supported functions: every
finitely-supported `f` is `L`-summable with the sum `∑ᶠ x ∈ L.support, f x` (and similarly for
products). | true |
BooleanSubalgebra.map_le_iff_le_comap | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_3} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] {L : BooleanSubalgebra α}
{f : BoundedLatticeHom α β} {M : BooleanSubalgebra β}, BooleanSubalgebra.map f L ≤ M ↔ L ≤ BooleanSubalgebra.comap f M | null | true |
PowerSeries.IsWeierstrassFactorization.degree_eq_coe_lift_order_map | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] [inst_1 : IsLocalRing A] {g : PowerSeries A} {f : Polynomial A} {h : PowerSeries A}
(H : g.IsWeierstrassFactorization f h), f.degree = ↑(((PowerSeries.map (IsLocalRing.residue A)) g).order.lift ⋯) | null | true |
instMetricSpaceEmpty | Mathlib.Topology.MetricSpace.Defs | MetricSpace Empty | null | true |
Quaternion.expSeries_even_of_imaginary | Mathlib.Analysis.Normed.Algebra.QuaternionExponential | ∀ {q : Quaternion ℝ},
q.re = 0 →
∀ (n : ℕ),
((NormedSpace.expSeries ℝ (Quaternion ℝ) (2 * n)) fun x => q) = ↑((-1) ^ n * ‖q‖ ^ (2 * n) / ↑(2 * n).factorial) | The even terms of `expSeries` are real, and correspond to the series for $\cos ‖q‖$. | true |
CommRingCat.Under.instPreservesLimitsOfShapeUnderWalkingParallelPairTensorProdOfFlatCarrier | Mathlib.Algebra.Category.Ring.Under.Limits | ∀ {R S : CommRingCat} [inst : Algebra ↑R ↑S] [Module.Flat ↑R ↑S],
CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingParallelPair (R.tensorProd S) | null | true |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_39 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax | null | false |
Lean.OLeanLevel.exported | Lean.Environment | Lean.OLeanLevel | Information from exported contexts. | true |
Finset.singletonAddMonoidHom | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [inst : DecidableEq α] → [inst_1 : AddZeroClass α] → α →+ Finset α | The singleton operation as an `AddMonoidHom`. | true |
DFinsupp.instIsBotZeroClass | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} (α : ι → Type u_2) [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), IsBotZeroClass (α i)], IsBotZeroClass (Π₀ (i : ι), α i) | null | true |
FP.ofPosRatDn | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → ℕ+ → ℕ+ → FP.Float × Bool | null | true |
FreeAddGroup.freeAddGroupEmptyEquivAddUnit | Mathlib.GroupTheory.FreeGroup.Basic | FreeAddGroup Empty ≃ Unit | The bijection between the additive free group on the empty type,
and a type with one element. | true |
Set.inter_singleton_eq_empty._simp_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ∩ {a} = ∅) = (a ∉ s) | null | false |
IsRelUpperSet.sInter | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α] {S : Set (Set α)},
S.Nonempty → (∀ s ∈ S, IsRelUpperSet s P) → IsRelUpperSet (⋂₀ S) P | null | true |
Lean.mkFreshId | Init.Meta.Defs | {m : Type → Type} → [Monad m] → [Lean.MonadNameGenerator m] → m Lean.Name | Creates a globally unique `Name`, without any semantic interpretation.
The names are not intended to be user-visible.
With the default name generator, names use `_uniq` as a base and have a numeric suffix.
This is used for example by `Lean.mkFreshFVarId`, `Lean.mkFreshMVarId`, and `Lean.mkFreshLMVarId`.
To create fres... | true |
CategoryTheory.IsKernelPair.lift'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} {S : C}
(k : CategoryTheory.IsKernelPair f a b) (p q : S ⟶ X)
(w : CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp q f),
CategoryTheory.CategoryStruct.comp (k.lift p q w) a = p ∧ Catego... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.