name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
eq_empty_or_univ_of_vadd_invariant_closed | Mathlib.Dynamics.Minimal | ∀ (M : Type u_1) {α : Type u_3} [inst : AddMonoid M] [inst_1 : TopologicalSpace α] [inst_2 : AddAction M α]
[AddAction.IsMinimal M α] {s : Set α}, IsClosed s → (∀ (c : M), c +ᵥ s ⊆ s) → s = ∅ ∨ s = Set.univ | null | true |
Nat.dfold_congr._proof_11 | Init.Data.Nat.Fold | ∀ {n m : ℕ} (w : n = m) {α : (i : ℕ) → autoParam (i ≤ n) Nat.dfold_congr._auto_1 → Type u_1}
(f : (i : ℕ) → (h : i < n) → α i ⋯ → α (i + 1) ⋯) (init : α 0 ⋯), α m ⋯ = α n ⋯ | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.parser.go.match_1 | Std.Time.Format.Basic | (motive : Option Std.Time.DateTime → Sort u_1) →
(x : Option Std.Time.DateTime) → ((res : Std.Time.DateTime) → motive (some res)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.EpiMono.0.CategoryTheory.Abelian.SpectralObject.isIso_mapFourδ₂Toδ₁'._proof_1_4 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | 1 < 1 + 1 | null | false |
Set.instIsLeftCancelVAdd | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] [IsLeftCancelVAdd α β], IsLeftCancelVAdd α (Set β) | null | true |
BitVec.sshiftRightRec_succ_eq | Init.Data.BitVec.Bitblast | ∀ {w₁ w₂ : ℕ} (x : BitVec w₁) (y : BitVec w₂) (n : ℕ),
x.sshiftRightRec y (n + 1) = (x.sshiftRightRec y n).sshiftRight' (y &&& BitVec.twoPow w₂ (n + 1)) | null | true |
Std.TreeSet.Raw.getD_erase | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF →
∀ {k a fallback : α}, (t.erase k).getD a fallback = if cmp k a = Ordering.eq then fallback else t.getD a fallback | null | true |
Manifold.IsImmersionAtOfComplement.congr_F | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {E'' : Type u} {F : Type u_5} {F' : Type u_6}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'']
[inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F]
[inst_7 : Norme... | Being an immersion at `x` w.r.t. `F` is stable under replacing `F` by an isomorphic copy. | true |
UInt16.toNat_sub_of_le | Init.Data.UInt.Lemmas | ∀ (a b : UInt16), b ≤ a → (a - b).toNat = a.toNat - b.toNat | null | true |
Mathlib.Elab.FastInstance.fastInstance | Mathlib.Tactic.FastInstance | Lean.ParserDescr | `fast_instance% inst` takes an expression for a typeclass instance `inst`, and unfolds it into
constructor applications that leverage existing instances. It uses the expected type to fill in
the constructor applications and lambda binders of data fields.
For instance, when used as
```lean
instance instSemiring : Semir... | true |
RingEquiv.toNonUnitalRingHom_comp_symm_toNonUnitalRingHom | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(e : R ≃+* S), e.toNonUnitalRingHom.comp e.symm.toNonUnitalRingHom = NonUnitalRingHom.id S | null | true |
Lean.Meta.caseValues | Lean.Meta.Match.CaseValues | Lean.MVarId →
Lean.FVarId →
Array Lean.Expr → optParam Lean.Name `h → optParam Bool true → Lean.MetaM (Array Lean.Meta.CaseValuesSubgoal) | Split goal `... |- C x`, where `fvarId` is `x`s id, into `values.size + 1` subgoals
1) `..., (h_1 : x = value[0]) |- C value[0]`
...
n) `..., (h_n : x = value[n - 1]) |- C value[n - 1]`
n+1) `..., (h_1 : x != value[0]) ... (h_n : x != value[n-1]) |- C x`
where `n = values.size`
The type of `x` must have decid... | true |
DirectSum.GCommRing.mk | Mathlib.Algebra.DirectSum.Ring | {ι : Type u_1} →
{A : ι → Type u_2} →
[inst : AddCommMonoid ι] →
[inst_1 : (i : ι) → AddCommGroup (A i)] →
[toGRing : DirectSum.GRing A] → (∀ (a b : GradedMonoid A), a * b = b * a) → DirectSum.GCommRing A | null | true |
ModularGroup.tendsto_normSq_coprime_pair | Mathlib.NumberTheory.Modular | ∀ (z : UpperHalfPlane), Filter.Tendsto (fun p => Complex.normSq (↑(p 0) * ↑z + ↑(p 1))) Filter.cofinite Filter.atTop | The function `(c,d) → |cz+d|^2` is proper, that is, preimages of bounded-above sets are finite.
| true |
SimpleGraph.Walk.not_nil_cons | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} {h : G.Adj u v} {p : G.Walk v w}, ¬(SimpleGraph.Walk.cons h p).Nil | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.foldM_filterMapWithPostcondition.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {γ : Type u_1} (motive : Option γ → Sort u_2) (c : γ) (h_1 : (c : γ) → motive (some c))
(h_2 : (x : Option γ) → motive x),
(match some c with
| some c => h_1 c
| x => h_2 x) =
h_1 c | null | true |
CategoryTheory.ShortComplex.instPreservesLimitsOfShapeπ₃ | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.PreservesLimitsOfShape J CategoryTheory.ShortComplex.π₃ | null | true |
instWellFoundedLTENat | Mathlib.Data.ENat.Basic | WellFoundedLT ℕ∞ | null | true |
Std.DHashMap.Raw.Const.ofList_singleton | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {k : α} {v : β},
Std.DHashMap.Raw.Const.ofList [(k, v)] = ∅.insert k v | null | true |
CategoryTheory.IsFiltered.toSup.congr_simp | Mathlib.CategoryTheory.Limits.ConcreteCategory.WithAlgebraicStructures | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsFiltered C] (O : Finset C)
(H : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y))) {X : C} (m : X ∈ O),
CategoryTheory.IsFiltered.toSup O H m = CategoryTheory.IsFiltered.toSup O H m | null | true |
MeasureTheory.setLIntegral_eq_top_of_measure_eq_top_ne_zero | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal} {s : Set α},
AEMeasurable f (μ.restrict s) → μ {x | x ∈ s ∧ f x = ⊤} ≠ 0 → ∫⁻ (x : α) in s, f x ∂μ = ⊤ | null | true |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData._sizeOf_inst | Mathlib.AlgebraicGeometry.ColimitsOver | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{inst : P.IsStableUnderBaseChange} →
{S : AlgebraicGeometry.Scheme} →
{J : Type u_1} →
{inst_1 : CategoryTheory.Category.{v_1, u_1} J} →
(D : CategoryTheory.Functor J (P.Over ⊤ S)) →
(𝒰 : S.OpenCover) →
... | null | false |
CategoryTheory.Idempotents.DoldKan.η_hom_app_f | Mathlib.AlgebraicTopology.DoldKan.EquivalencePseudoabelian | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.IsIdempotentComplete C] [inst_3 : CategoryTheory.Limits.HasFiniteCoproducts C]
(X : ChainComplex C ℕ) (i : ℕ),
(CategoryTheory.Idempotents.DoldKan.η.hom.app X).f i =
CategoryTheory.C... | null | true |
CategoryTheory.Limits.hasProductsOfShape_of_small | Mathlib.CategoryTheory.Limits.EssentiallySmall | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (β : Type w₂) [Small.{w₁, w₂} β]
[CategoryTheory.Limits.HasProducts C], CategoryTheory.Limits.HasProductsOfShape β C | null | true |
_private.Mathlib.Algebra.Polynomial.Degree.Lemmas.0.Polynomial.degree_map_eq_of_injective._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u_10} {S : Type u_11} {F : Type u_12} [inst : Zero R] [inst_1 : Zero S] [inst_2 : FunLike F R S]
[ZeroHomClass F R S] (f : F), Function.Injective ⇑f → ∀ {x : R}, (f x ≠ 0) = (x ≠ 0) | null | false |
AlgebraicGeometry.instCanonicallyOverFiber | Mathlib.AlgebraicGeometry.Fiber | {X Y : AlgebraicGeometry.Scheme} → (f : X ⟶ Y) → (y : ↥Y) → (AlgebraicGeometry.Scheme.Hom.fiber f y).CanonicallyOver X | null | true |
Rep.standardComplex.εToSingle₀ | Mathlib.RepresentationTheory.Homological.Resolution | (k G : Type u) →
[inst : CommRing k] →
[inst_1 : Monoid G] → Rep.standardComplex k G ⟶ (ChainComplex.single₀ (Rep.{u, u, u} k G)).obj (Rep.trivial k G k) | The chain map from the standard resolution of `k` to `k[0]` given by `∑ nᵢgᵢ ↦ ∑ nᵢ` in
degree zero. | true |
_private.Lean.Meta.Tactic.UnifyEq.0.Lean.Meta.heqToEq' | Lean.Meta.Tactic.UnifyEq | Lean.MVarId → Lean.LocalDecl → Lean.MetaM Lean.MVarId | Convert heterogeneous equality into a homogeneous one | true |
add_neg_lt_iff_lt_add._simp_1 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, (a + -b < c) = (a < c + b) | null | false |
ContinuousAlternatingMap.analyticOn | Mathlib.Analysis.Analytic.CPolynomial | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {ι : Type u_5}
[inst_5 : Fintype ι] (f : E [⋀^ι]→L[𝕜] F) {s : Set (ι → E)}, AnalyticOn 𝕜 (⇑f) s | null | true |
Lean.Parser.Category.attr | Init.Notation | Lean.Parser.Category | `attr` is a builtin syntax category for attributes.
Declarations can be annotated with attributes using the `@[...]` notation. | true |
Std.HashMap.contains_union | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, (m₁ ∪ m₂).contains k = (m₁.contains k || m₂.contains k) | null | true |
iInf_range' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : InfSet α] (g : β → α) (f : ι → β), ⨅ b, g ↑b = ⨅ i, g (f i) | null | true |
Con._sizeOf_inst | Mathlib.GroupTheory.Congruence.Defs | (M : Type u_1) → {inst : Mul M} → [SizeOf M] → SizeOf (Con M) | null | false |
ByteArray.toList_data_append | Init.Data.ByteArray.Lemmas | ∀ {l l' : ByteArray}, (l ++ l').data.toList = l.data.toList ++ l'.data.toList | null | true |
SimpleGraph.addCayley_mono | Mathlib.Combinatorics.SimpleGraph.Cayley | ∀ {M : Type u_1} [inst : Add M] {U V : Set M}, U ⊆ V → SimpleGraph.addCayley U ≤ SimpleGraph.addCayley V | null | true |
_private.Mathlib.Tactic.NormNum.IsSquare.0.Mathlib.Meta.NormNum.evalIsSquareRat.match_93 | Mathlib.Tactic.NormNum.IsSquare | (n d : Q(ℕ)) →
(motive : (ed : Q(ℕ)) × Q(«$n».gcd «$d» = «$ed») → Sort u_1) →
(x : (ed : Q(ℕ)) × Q(«$n».gcd «$d» = «$ed»)) →
((e : Q(ℕ)) → (he : Q(«$n».gcd «$d» = «$e»)) → motive ⟨e, he⟩) → motive x | null | false |
CategoryTheory.Limits.MulticospanIndex._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{C : Type u} → {inst : CategoryTheory.Category.{v, u} C} → [SizeOf C] → CategoryTheory.Limits.MulticospanIndex J C → ℕ | null | false |
Derivation.map_one_eq_zero' | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
(self : Derivation R A M), ↑self 1 = 0 | null | true |
Abelianization.lift.congr_simp | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {G : Type u} [inst : Group G] {A : Type v} [inst_1 : Group A] [inst_2 : IsMulCommutative A],
Abelianization.lift = Abelianization.lift | null | true |
DiffeologicalSpace.ext_iff | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_4} {d₁ d₂ : DiffeologicalSpace X}, d₁ = d₂ ↔ @Diffeology.IsPlot X d₁ = @Diffeology.IsPlot X d₂ | null | true |
LieRinehartAlgebra.Hom.instCoeFunForall | Mathlib.Algebra.LieRinehartAlgebra.Defs | {R : Type u_1} →
{A₁ : Type u_2} →
{L₁ : Type u_3} →
{A₂ : Type u_4} →
{L₂ : Type u_5} →
[inst : CommRing R] →
[inst_1 : CommRing A₁] →
[inst_2 : LieRing L₁] →
[inst_3 : Module A₁ L₁] →
[inst_4 : LieRingModule L₁ A₁] →
... | null | true |
CategoryTheory.Bicategory.LeftLift.whiskerHom | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f : b ⟶ a} →
{g : c ⟶ a} →
{s t : CategoryTheory.Bicategory.LeftLift f g} → (s ⟶ t) → {x : B} → (h : x ⟶ c) → s.whisker h ⟶ t.whisker h | Construct a morphism between whiskered lifts. | true |
Std.DTreeMap.Raw.instCoeWFWFInner | Std.Data.DTreeMap.Raw.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → {t : Std.DTreeMap.Raw α β cmp} → Coe t.WF t.inner.WF | null | true |
Lean.PrettyPrinter.combinatorFormatterAttribute | Lean.PrettyPrinter.Formatter | Lean.ParserCompiler.CombinatorAttribute | Registers a formatter for a parser combinator.
`@[combinator_formatter c]` registers a declaration of type `Lean.PrettyPrinter.Formatter` for the
`Parser` declaration `c`. Note that, unlike with `@[formatter]`, this is not a node kind since
combinators usually do not introduce their own node kinds. The tagged declarat... | true |
UInt16.lt_or_le | Init.Data.UInt.Lemmas | ∀ (a b : UInt16), a < b ∨ b ≤ a | null | true |
FloorRing.mk.noConfusion | Mathlib.Algebra.Order.Floor.Defs | {α : Type u_3} →
{inst : Ring α} →
{inst_1 : LinearOrder α} →
{P : Sort u} →
{floor ceil : α → ℤ} →
{gc_coe_floor : GaloisConnection Int.cast floor} →
{gc_ceil_coe : GaloisConnection ceil Int.cast} →
{floor' ceil' : α → ℤ} →
{gc_coe_floor' : Galois... | null | false |
CategoryTheory.Limits.Cotrident.ext._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {s t : CategoryTheory.Limits.Cotrident f} (i : s.pt ≅ t.pt)
(w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cotrident.... | null | false |
SSet.Subcomplex.Pairing.inter | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | ∀ {X : SSet} {A : X.Subcomplex} (self : A.Pairing), self.I ∩ self.II = ∅ | null | true |
TypeCat.ofHom_apply | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} (f : X → Y) (x : X), (CategoryTheory.ConcreteCategory.hom (TypeCat.ofHom f)) x = f x | null | true |
Std.Rcc._sizeOf_inst | Init.Data.Range.Polymorphic.PRange | (α : Type u) → [SizeOf α] → SizeOf (Std.Rcc α) | null | false |
Multiset.inter_eq_zero_iff_disjoint | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, s ∩ t = 0 ↔ Disjoint s t | null | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.mem_closure_range_iff._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {a : α}, (a ∈ closure s) = ∀ ε > 0, ∃ b ∈ s, dist a b < ε | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt8.reduceBNe._regBuiltin.UInt8.reduceBNe.declare_2._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2231631932._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.collectSingletons.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.Expr × List Lean.HeadIndex → Sort u_1) →
(x : Lean.Expr × List Lean.HeadIndex) → ((p' : Lean.Expr) → (snd : List Lean.HeadIndex) → motive (p', snd)) → motive x | null | false |
Trans.trans.congr_simp | Mathlib.CategoryTheory.Limits.Preserves.Grothendieck | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {r : α → β → Sort u} {s : β → γ → Sort v} {t : α → γ → Sort w}
[self : Trans r s t] {a : α} {b : β} {c : γ} (a_1 a_2 : r a b),
a_1 = a_2 → ∀ (a_3 a_4 : s b c), a_3 = a_4 → Trans.trans a_1 a_3 = Trans.trans a_2 a_4 | null | true |
_private.Mathlib.Order.Filter.Map.0.Filter.map_eq_map_iff_of_injOn._simp_1_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) | null | false |
CategoryTheory.MonoidalCategory.noConfusion | Mathlib.CategoryTheory.Monoidal.Category | {P : Sort u_1} →
{C : Type u} →
{𝒞 : CategoryTheory.Category.{v, u} C} →
{t : CategoryTheory.MonoidalCategory C} →
{C' : Type u} →
{𝒞' : CategoryTheory.Category.{v, u} C'} →
{t' : CategoryTheory.MonoidalCategory C'} →
C = C' → 𝒞 ≍ 𝒞' → t ≍ t' → CategoryTheory.... | null | false |
Mathlib.Tactic.LibraryRewrite.renderRewrites | Mathlib.Tactic.Widget.LibraryRewrite | Lean.Expr →
Array (Array Mathlib.Tactic.LibraryRewrite.RewriteInterface × Mathlib.Tactic.LibraryRewrite.Kind) →
Lean.Lsp.Range → Lean.Server.FileWorker.EditableDocument → Bool → Lean.MetaM ProofWidgets.Html | Render the given rewrite results. | true |
TopCat.isLimitConeOfForget._proof_3 | Mathlib.Topology.Category.TopCat.Limits.Basic | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {F : CategoryTheory.Functor J TopCat}
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.forget TopCat))) (hc : CategoryTheory.Limits.IsLimit c)
(x : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget TopCat).map
(TopCat.ofHom
{ ... | null | false |
CommMonCat.forget₂Mon_preservesLimitsOfSize | Mathlib.Algebra.Category.MonCat.Limits | ∀ [UnivLE.{v, u}],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ CommMonCat MonCat) | The forgetful functor from commutative monoids to monoids preserves all limits.
This means the underlying type of a limit can be computed as a limit in the category of monoids. | true |
Stream'.Seq.all_of_get | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {p : α → Prop} {s : Stream'.Seq α}, (∀ (n : ℕ) (x : α), s.get? n = some x → p x) → ∀ x ∈ s, p x | null | true |
spectrum.nonempty_of_isAlgClosed_of_finiteDimensional | Mathlib.FieldTheory.IsAlgClosed.Spectrum | ∀ (𝕜 : Type u) {A : Type v} [inst : Field 𝕜] [inst_1 : Ring A] [inst_2 : Algebra 𝕜 A] [IsAlgClosed 𝕜] [Nontrivial A]
[I : FiniteDimensional 𝕜 A] (a : A), (spectrum 𝕜 a).Nonempty | Every element `a` in a nontrivial finite-dimensional algebra `A`
over an algebraically closed field `𝕜` has non-empty spectrum. | true |
MeasureTheory.StronglyMeasurable.separableSpace_range_union_singleton | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x : MeasurableSpace α} [inst : TopologicalSpace β]
[TopologicalSpace.PseudoMetrizableSpace β],
MeasureTheory.StronglyMeasurable f → ∀ {b : β}, TopologicalSpace.SeparableSpace ↑(Set.range f ∪ {b}) | null | true |
CategoryTheory.Discrete.equivalence._proof_2 | Mathlib.CategoryTheory.Discrete.Basic | ∀ {I : Type u_2} {J : Type u_1} (e : I ≃ J) (j : CategoryTheory.Discrete J),
((CategoryTheory.Discrete.functor (CategoryTheory.Discrete.mk ∘ ⇑e.symm)).comp
(CategoryTheory.Discrete.functor (CategoryTheory.Discrete.mk ∘ ⇑e))).obj
j =
(CategoryTheory.Functor.id (CategoryTheory.Discrete J)).obj j | null | false |
_private.Mathlib.Topology.Ultrafilter.0.isClosed_iff_ultrafilter._simp_1_1 | Mathlib.Topology.Ultrafilter | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClosed s = ∀ (a : X), ClusterPt a (Filter.principal s) → a ∈ s | null | false |
MeasureTheory.Measure.dirac_conv_dirac | Mathlib.MeasureTheory.Group.Convolution | ∀ {M : Type u_1} [inst : AddMonoid M] [inst_1 : MeasurableSpace M] [MeasurableAdd₂ M] (x y : M),
(MeasureTheory.Measure.dirac x).conv (MeasureTheory.Measure.dirac y) = MeasureTheory.Measure.dirac (x + y) | null | true |
Complex.zero_im | Mathlib.Basic.Complex.Basic | Complex.im 0 = 0 | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Clique.0.SimpleGraph.isMaximalClique_compl._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} {G : SimpleGraph α} {s : Set α},
Maximal G.IsIndepSet s = (G.IsIndepSet s ∧ ∀ (t : Set α), G.IsIndepSet t → s ⊆ t → t ⊆ s) | null | false |
_private.Mathlib.Topology.UniformSpace.Path.0.Path.uniformContinuous_trans.match_1_5 | Mathlib.Topology.UniformSpace.Path | ∀ {X : Type u_1} [inst : UniformSpace X] {x y z : X} (U : Set (X × X)) (x_1 : Path x y × Path y z)
(motive :
(x_2 : Path x y × Path y z) →
(x_2, x_1) ∈
entourageProd {γ | ∀ (t : ↑unitInterval), (γ.1 t, γ.2 t) ∈ (U, U).1}
{γ | ∀ (t : ↑unitInterval), (γ.1 t, γ.2 t) ∈ (U, U).2} →
... | null | false |
CategoryTheory.Grothendieck.faithful_ι | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat} (c : C),
(CategoryTheory.Grothendieck.ι F c).Faithful | null | true |
toDual_one | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : One α], OrderDual.toDual 1 = 1 | null | true |
continuousOn_prod_of_discrete_right | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [DiscreteTopology β] {f : α × β → γ} {s : Set (α × β)},
ContinuousOn f s ↔ ∀ (b : β), ContinuousOn (fun x => f (x, b)) {a | (a, b) ∈ s} | null | true |
_private.Mathlib.NumberTheory.Height.Basic.0.Height.max_eq_iSup._simp_1_2 | Mathlib.NumberTheory.Height.Basic | ∀ {p : Fin 2 → Prop}, (∀ (i : Fin 2), p i) = (p 0 ∧ p 1) | null | false |
Representation.Equiv.right_inv | 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} (self : ρ.Equiv σ),
Function.RightInverse self.invFun (↑self... | null | true |
Lean.Grind.Ring.OfSemiring.mul | Init.Grind.Ring.Envelope | {α : Type u} →
[inst : Lean.Grind.Semiring α] →
Lean.Grind.Ring.OfSemiring.Q α → Lean.Grind.Ring.OfSemiring.Q α → Lean.Grind.Ring.OfSemiring.Q α | null | true |
isEmpty_pprod._simp_1 | Mathlib.Basic.IsEmpty.Basic | ∀ {α : Sort u_1} {β : Sort u_2}, IsEmpty (α ×' β) = (IsEmpty α ∨ IsEmpty β) | null | false |
CategoryTheory.Limits.WidePushoutShape.Hom.id.elim | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{motive : (a a_1 : CategoryTheory.Limits.WidePushoutShape J) → a.Hom a_1 → Sort u} →
{a a_1 : CategoryTheory.Limits.WidePushoutShape J} →
(t : a.Hom a_1) →
t.ctorIdx = 0 →
((X : CategoryTheory.Limits.WidePushoutShape J) →
motive X X (CategoryTheory.Limits.WideP... | null | false |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.eval._sparseCasesOn_1 | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {motive : Mathlib.Tactic.BicategoryLike.Mor₂Iso → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
((α : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
motive (Mathlib.Tactic.BicategoryLike.Mor₂Iso.structuralAtom α)) →
((η : Mathlib.Tactic.BicategoryLike.AtomIso) → motive (Mathlib.Tactic.Bic... | null | false |
CommRing.Pic.instAddCommGroupAsModule | Mathlib.RingTheory.PicardGroup | (R : Type u_5) → [inst : CommRing R] → (M : CommRing.Pic R) → AddCommGroup M.AsModule | null | true |
CategoryTheory.Mon.instHasInitial | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.Limits.HasInitial (CategoryTheory.Mon C) | null | true |
Aesop.RuleApplication.mk.inj | Aesop.RuleTac.Basic | ∀ {goals : Array Aesop.Subgoal} {postState : Lean.Meta.SavedState} {scriptSteps? : Option (Array Aesop.Script.LazyStep)}
{successProbability? : Option Aesop.Percent} {goals_1 : Array Aesop.Subgoal} {postState_1 : Lean.Meta.SavedState}
{scriptSteps?_1 : Option (Array Aesop.Script.LazyStep)} {successProbability?_1 : ... | null | true |
_private.Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy.0.CategoryTheory.MorphismProperty.IsInvertedBy.map_iff._simp_1_1 | Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(W : CategoryTheory.MorphismProperty C) (F : CategoryTheory.Functor C D),
W.IsInvertedBy F = (W.map F ≤ CategoryTheory.MorphismProperty.isomorphisms D) | null | false |
ComplexShape.Embedding.boundaryGE | Mathlib.Algebra.Homology.Embedding.Boundary | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') {i' : ι'} {j : ι},
c'.Rel i' (e.f j) → (∀ (i : ι), e.f i ≠ i') → e.BoundaryGE j | null | true |
LieModuleHom.instAddCommGroup._proof_6 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : LieRingModule L M] [inst_7 : LieRingModule L N],
autoParam (∀ (a b : M →ₗ⁅R,L⁆ N), a - b = a + -b) SubNeg... | null | false |
Finsupp.unique_single_eq_iff | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {a a' : α} {b : M} [Unique α] {b' : M},
((fun₀ | a => b) = fun₀ | a' => b') ↔ b = b' | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.good_vertices_triangle_card | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} (G : SimpleGraph α) [inst : DecidableRel G.Adj] {ε : ℝ} {s t u : Finset α} [inst_1 : DecidableEq α],
2 * ε ≤ ↑(G.edgeDensity s t) →
2 * ε ≤ ↑(G.edgeDensity s u) →
2 * ε ≤ ↑(G.edgeDensity t u) →
G.IsUniform ε t u →
∀ x ∈ s \ (SimpleGraph.badVertices✝ G ε s t ∪ SimpleGraph.b... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.reduceSub._regBuiltin.Nat.reduceSub.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.121904536._hygCtx._hyg.30 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | null | false |
CategoryTheory.ShortComplex.RightHomologyData.unop_i | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex Cᵒᵖ} (h : S.RightHomologyData), h.unop.i = h.p.unop | null | true |
Std.OppositeOrderInstances.instDecidableLEOpposite | Init.Data.Order.Opposite | {α : Type u_1} → {i : LE α} → [id : DecidableLE α] → DecidableLE α | null | true |
MvPolynomial.C._proof_4 | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u_2} {σ : Type u_1} [inst : CommSemiring R] (x y : R),
(↑↑AddMonoidAlgebra.singleZeroRingHom).toFun (x + y) =
(↑↑AddMonoidAlgebra.singleZeroRingHom).toFun x + (↑↑AddMonoidAlgebra.singleZeroRingHom).toFun y | null | false |
_private.Std.Sync.Barrier.0.Std.BarrierState._sizeOf_inst | Std.Sync.Barrier | SizeOf Std.BarrierState✝ | null | false |
ModuleCat.imageIsoRange_hom_subtype_apply | Mathlib.Algebra.Category.ModuleCat.Images | ∀ {R : Type u} [inst : Ring R] {G H : ModuleCat R} (f : G ⟶ H) (x : ↑(CategoryTheory.Limits.image f)),
↑((CategoryTheory.ConcreteCategory.hom (ModuleCat.imageIsoRange f).hom) x) =
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.image.ι f)) x | null | true |
Lean.Grind.OrderConfig.locals._inherited_default | Init.Grind.Config | Bool | null | false |
Lean.Order.prod_sup_is_sup | Init.Internal.Order.Basic | ∀ {α : Sort u} {β : Sort v} [inst : Lean.Order.CompleteLattice α] [inst_1 : Lean.Order.CompleteLattice β]
(c : α ×' β → Prop), Lean.Order.is_sup c (Lean.Order.prod_sup c) | null | true |
_private.Std.Do.WP.Monad.0.ExceptT.run_bind.match_1.splitter | Std.Do.WP.Monad | {ε α : Type u_1} →
(motive : Except ε α → Sort u_2) →
(x : Except ε α) → ((x : α) → motive (Except.ok x)) → ((e : ε) → motive (Except.error e)) → motive x | null | true |
Colex.instCancelMonoid.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : CancelMonoid α],
Colex.instCancelMonoid = { toLeftCancelMonoid := Colex.instLeftCancelMonoid, toIsRightCancelMul := ⋯ } | null | true |
List.getElem_replace._proof_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {a b : α} {l : List α} {i : ℕ}, i < l.length → i < (l.replace a b).length | null | false |
DirectSum.toSemiring_of | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] {A : ι → Type u_2} {R : Type u_3} [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GSemiring A] [inst_4 : Semiring R] (f : (i : ι) → A i →+ R)
(hone : (f 0) GradedMonoid.GOne.one = 1)
(hmul : ∀ {i j : ι} (ai : A i) (aj : A j), (f (i + j)) ... | null | true |
_private.Lean.Parser.Basic.0.Lean.Parser.sepByFnAux.parse._unsafe_rec | Lean.Parser.Basic | Lean.Parser.ParserFn →
Lean.Parser.ParserFn → Bool → ℕ → Bool → Lean.Parser.ParserContext → Lean.Parser.ParserState → Lean.Parser.ParserState | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.