name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Probability.Process.Predictable.0.MeasureTheory.IsPredictable.measurableSet_prodMk_add_one_of_predictable._simp_1_3 | Mathlib.Probability.Process.Predictable | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | false |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.withAlts | Lean.Meta.Match.Match | {α : Type} →
Lean.Expr →
Array Lean.Expr →
Array Lean.Meta.Match.DiscrInfo →
List Lean.Meta.Match.AltLHS →
Option Lean.Meta.Match.Overlaps →
(List Lean.Meta.Match.Alt → Array Lean.Expr → Array Lean.Meta.Match.AltParamInfo → Lean.MetaM α) →
Lean.MetaM α | true |
Std.Rii.pairwise_toList_ne | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rii α} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_4 : Std.Rxi.IsAlwaysFinite α], List.Pairwise (fun a b => a ≠ b) r.toList | true |
CategoryTheory.PresheafOfGroups.OneCocycle.mk | Mathlib.CategoryTheory.Sites.NonabelianCohomology.H1 | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{G : CategoryTheory.Functor Cᵒᵖ GrpCat} →
{I : Type w'} →
{U : I → C} →
(toOneCochain : CategoryTheory.PresheafOfGroups.OneCochain G U) →
autoParam
(∀ (i j k : I) ⦃T : C⦄ (a : T ⟶ U i) (b : T ⟶ U j) (c :... | true |
CategoryTheory.MonoidalCategory.«term_◁ᵢ_» | Mathlib.CategoryTheory.Monoidal.Category | Lean.TrailingParserDescr | true |
hasFDerivAt_apply | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {ι : Type u_6} {F' : ι → Type u_7}
[inst_1 : (i : ι) → NormedAddCommGroup (F' i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (F' i)] (i : ι) (f : (i : ι) → F' i),
HasFDerivAt (fun f => f i) (ContinuousLinearMap.proj i) f | true |
Filter.le_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {f : Filter (α × β)} {g : Filter α} {g' : Filter β},
f ≤ g ×ˢ g' ↔ Filter.Tendsto Prod.fst f g ∧ Filter.Tendsto Prod.snd f g' | true |
Multiset.union_comm | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ∪ t = t ∪ s | true |
skewAdjoint.instSMulSubtypeMemAddSubgroupOfStarModule | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} →
{A : Type u_2} →
[inst : Star R] →
[TrivialStar R] →
[inst_2 : AddCommGroup A] →
[inst_3 : StarAddMonoid A] →
[inst_4 : Monoid R] → [inst_5 : DistribMulAction R A] → [StarModule R A] → SMul R ↥(skewAdjoint A) | true |
Lean.Lsp.TextDocumentChangeRegistrationOptions.mk._flat_ctor | Lean.Data.Lsp.TextSync | Option Lean.Lsp.DocumentSelector → Lean.Lsp.TextDocumentSyncKind → Lean.Lsp.TextDocumentChangeRegistrationOptions | false |
_private.Qq.ForLean.Do.0.Lean.Elab.Term.extractBind.match_1 | Qq.ForLean.Do | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((m returnType : Lean.Expr) → motive (m.app returnType)) → ((x : Lean.Expr) → motive x) → motive type | false |
Rat.mul_eq_mkRat | Mathlib.Data.Rat.Defs | ∀ (q r : ℚ), q * r = mkRat (q.num * r.num) (q.den * r.den) | true |
CategoryTheory.Localization.SmallShiftedHom.equiv | Mathlib.CategoryTheory.Localization.SmallShiftedHom | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(W : CategoryTheory.MorphismProperty C) →
{M : Type w'} →
[inst_2 : AddMonoid M] →
[inst_3 : CategoryTheory.HasShift C M] →
... | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rcc_ne_empty_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m.succ ≤ n) = (m < n) | false |
CategoryTheory.Limits.isColimitOfConeUnopOfCocone | Mathlib.CategoryTheory.Limits.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] →
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) →
{c : CategoryTheory.Limits.Cocone F} →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneUnopOfCocone c) →... | true |
Lean.Lsp.Hover.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {contents : Lean.Lsp.MarkupContent} {range? : Option Lean.Lsp.Range} {contents_1 : Lean.Lsp.MarkupContent}
{range?_1 : Option Lean.Lsp.Range},
{ contents := contents, range? := range? } = { contents := contents_1, range? := range?_1 } →
contents = contents_1 ∧ range? = range?_1 | true |
Int.neg_neg | Init.Data.Int.Lemmas | ∀ (a : ℤ), - -a = a | true |
CategoryTheory.ShortComplex.leftRightHomologyComparison'_fac | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h₁ : S.LeftHomologyData) (h₂ : S.RightHomologyData) [inst_2 : S.HasHomology],
CategoryTheory.ShortComplex.leftRightHomologyComparison' h₁ h₂ =
CategoryTheory.Category... | true |
AffineEquiv.mk.inj | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_4} {V₂ : Type u_5} {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₂} {toEquiv : P₁ ≃ P₂} {linear : V₁ ≃ₗ[k] V₂}
{map_vadd' : ∀ (p : ... | true |
RootPairing.Base.cartanMatrix_apply_eq_zero_iff_symm | Mathlib.LinearAlgebra.RootSystem.CartanMatrix | ∀ {ι : 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] {P : RootPairing ι R M N} (b : P.Base)
[inst_5 : P.IsCrystallographic] [CharZero R] [IsDomain R] {i j : ↥b.support},
b.cartanMatrix i j ... | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.Result.mk.inj | Lean.Meta.LetToHave | ∀ {expr : Lean.Expr} {type? : Option Lean.Expr} {expr_1 : Lean.Expr} {type?_1 : Option Lean.Expr},
{ expr := expr, type? := type? } = { expr := expr_1, type? := type?_1 } → expr = expr_1 ∧ type? = type?_1 | true |
Mathlib.TacticAnalysis.Config.mk._flat_ctor | Mathlib.Tactic.TacticAnalysis | (Array Mathlib.TacticAnalysis.TacticNode → Lean.Elab.Command.CommandElabM Unit) → Mathlib.TacticAnalysis.Config | false |
_private.Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions.0.CategoryTheory.Localization.exists_leftFraction₂.match_1_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : L.IsLocalization W] {X Y : C} (f : L.obj X ⟶ L.obj Y)
(motive : (∃ φ, f = φ.map L ⋯) → Prop) (x : ∃ φ, f ... | false |
_private.Mathlib.Topology.ContinuousOn.0.continuousOn_prod_of_discrete_right._simp_1_3 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [DiscreteTopology β] {f : α × β → γ} {s : Set (α × β)} {x : α × β},
ContinuousWithinAt f s x = ContinuousWithinAt (fun x_1 => f (x_1, x.2)) {a | (a, x.2) ∈ s} x.1 | false |
Filter.commMonoid._proof_5 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : CommMonoid α] (a : Filter α), a * 1 = a | false |
_private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.fastJacobiSym._proof_6 | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (b : ℕ), ¬b = 0 → b / 2 < b | false |
Std.DTreeMap.Internal.RoiSliceData._sizeOf_inst | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) →
(β : α → Type v) →
{inst : Ord α} → [SizeOf α] → [(a : α) → SizeOf (β a)] → SizeOf (Std.DTreeMap.Internal.RoiSliceData α β) | false |
FractionalIdeal.spanFinset_coe | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ (R₁ : Type u_3) [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
[inst_3 : IsFractionRing R₁ K] {ι : Type u_5} (s : Finset ι) (f : ι → K),
↑(FractionalIdeal.spanFinset R₁ s f) = Submodule.span R₁ (f '' ↑s) | true |
SemiRingCat.limitπRingHom._proof_2 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} J] (F : CategoryTheory.Functor J SemiRingCat)
[Small.{u_1, max u_1 u_2} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections],
Small.{u_1, max u_1 u_2}
↑((F.comp
((CategoryTheory.forget₂ SemiRingCat AddCommMonCat).comp
(... | false |
WithTop.lt_untop_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {b : α} [inst : LT α] {x : WithTop α} (hx : x ≠ ⊤), b < x.untop hx ↔ ↑b < x | true |
AugmentedSimplexCategory.equivAugmentedSimplicialObject_inverse_obj_map | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : CategoryTheory.SimplicialObject.Augmented C)
{X_1 Y : (CategoryTheory.WithInitial SimplexCategory)ᵒᵖ} (f : X_1 ⟶ Y),
(AugmentedSimplexCategory.equivAugmentedSimplicialObject.inverse.obj X).map f =
match
match Opposite.unop X_1 with
... | true |
_private.Mathlib.Data.Finset.Update.0.Function.updateFinset_updateFinset._simp_1_3 | Mathlib.Data.Finset.Update | (¬False) = True | false |
_private.Mathlib.Data.Rat.Cast.Order.0.Mathlib.Meta.Positivity.evalRatCast._proof_5 | Mathlib.Data.Rat.Cast.Order | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | false |
Lean.Elab.Structural.IndGroupInst.recOn | Lean.Elab.PreDefinition.Structural.IndGroupInfo | {motive : Lean.Elab.Structural.IndGroupInst → Sort u} →
(t : Lean.Elab.Structural.IndGroupInst) →
((toIndGroupInfo : Lean.Elab.Structural.IndGroupInfo) →
(levels : List Lean.Level) →
(params : Array Lean.Expr) →
motive { toIndGroupInfo := toIndGroupInfo, levels := levels, params := p... | false |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.Submodule.le_linearEquiv_of_sSup_eq_top.match_1_5 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N m : Submodule R M)
(motive : (∃ S, Nonempty (↥N ≃ₗ[R] ↥S)) → Prop) (x : ∃ S, Nonempty (↥N ≃ₗ[R] ↥S)),
(∀ (S : Submodule R ↥m) (e : ↥N ≃ₗ[R] ↥S), motive ⋯) → motive x | false |
Lean.Elab.Term.applyResult | Lean.Elab.Term.TermElabM | {α : Type} → Lean.Elab.Term.TermElabResult α → Lean.Elab.TermElabM α | true |
CategoryTheory.Adjunction.unit | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} → (F ⊣ G) → (CategoryTheory.Functor.id C ⟶ F.comp G) | true |
FreeGroup.of | Mathlib.GroupTheory.FreeGroup.Basic | {α : Type u} → α → FreeGroup α | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.CompStruct.0._auto_80 | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | Lean.Syntax | false |
NumberField.ComplexEmbedding.conjugate_comp | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_1} [inst : Field K] {k : Type u_2} [inst_1 : Field k] (φ : K →+* ℂ) (σ : k →+* K),
(NumberField.ComplexEmbedding.conjugate φ).comp σ = NumberField.ComplexEmbedding.conjugate (φ.comp σ) | true |
normalizedGCDMonoidOfExistsLCM._proof_4 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
(h : ∀ (a b : α), ∃ c, ∀ (d : α), a ∣ d ∧ b ∣ d ↔ c ∣ d) (x x_1 : α),
normalize (normalize (Classical.choose ⋯)) = normalize (Classical.choose ⋯) | false |
UInt8.le_total | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), a ≤ b ∨ b ≤ a | true |
CategoryTheory.MorphismProperty.toSet_max | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W₁ W₂ : CategoryTheory.MorphismProperty C),
(W₁ ⊔ W₂).toSet = W₁.toSet ∪ W₂.toSet | true |
NonUnitalAlgHom.coe_comp | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} {T : Type u_1} [inst : Monoid R] [inst_1 : Monoid S] [inst_2 : Monoid T] {φ : R →* S}
{A : Type v} {B : Type w} {C : Type w₁} [inst_3 : NonUnitalNonAssocSemiring A] [inst_4 : DistribMulAction R A]
[inst_5 : NonUnitalNonAssocSemiring B] [inst_6 : DistribMulAction S B] [inst_7 : NonUnital... | true |
Std.DTreeMap.Internal.Impl.getKey?_insertMany_empty_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} [Std.TransOrd α] {l : List ((a : α) × β a)} {k k' : α},
compare k k' = Ordering.eq →
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l → (↑(Std.DTreeMap.Internal.Impl.empty.insertMany l ⋯)).getKey? k' = some k | true |
nonempty_orderEmbedding_of_finite_infinite | Mathlib.Data.Finset.Sort | ∀ (α : Type u_1) [inst : LinearOrder α] [hα : Finite α] (β : Type u_2) [inst_1 : LinearOrder β] [hβ : Infinite β],
Nonempty (α ↪o β) | true |
Filter.map_inr_inf_map_inl | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, Filter.map Sum.inr f ⊓ Filter.map Sum.inl g = ⊥ | true |
CategoryTheory.Subfunctor.Subpresheaf.toRange_app_val | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} (p : F' ⟶ F) {i : C}
(x : F'.obj i), ↑((CategoryTheory.Subfunctor.toRange p).app i x) = p.app i x | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageD._proof_9 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r : ℤ) (pq pq' : κ),
r₀ ≤ r → (c r).Rel pq pq' → data.deg pq + 1 = data.deg pq' | false |
Module.Basis.mk_coord_apply_ne | Mathlib.LinearAlgebra.Basis.Basic | ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : ι → M} {hli : LinearIndependent R v} {hsp : ⊤ ≤ Submodule.span R (Set.range v)} {i j : ι},
j ≠ i → ((Module.Basis.mk hli hsp).coord i) (v j) = 0 | true |
le_or_lt_of_mul_le_mul | Mathlib.Algebra.Order.Monoid.Unbundled.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Mul α] [MulLeftMono α] [MulRightStrictMono α] {a₁ a₂ b₁ b₂ : α},
a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂ | true |
CategoryTheory.PreGaloisCategory.instHasFiniteLimits | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.PreGaloisCategory C],
CategoryTheory.Limits.HasFiniteLimits C | true |
binomialSeries_eq_ordinaryHypergeometricSeries | Mathlib.Analysis.Analytic.Binomial | ∀ {𝕂 : Type u} [inst : Field 𝕂] [inst_1 : CharZero 𝕂] {𝔸 : Type v} [inst_2 : Ring 𝔸] [inst_3 : Algebra 𝕂 𝔸]
[inst_4 : TopologicalSpace 𝔸] [inst_5 : IsTopologicalRing 𝔸] {a b : 𝕂},
(∀ (k : ℕ), ↑k ≠ -b) →
binomialSeries 𝔸 a = (ordinaryHypergeometricSeries 𝔸 (-a) b b).compContinuousLinearMap (-Continuo... | true |
Lean.Elab.Term.ToDepElimPattern.TopSort.State._sizeOf_1 | Lean.Elab.Match | Lean.Elab.Term.ToDepElimPattern.TopSort.State → ℕ | false |
ODE.FunSpace.instMetricSpace | Mathlib.Analysis.ODE.PicardLindelof | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{tmin tmax : ℝ} → {t₀ : ↑(Set.Icc tmin tmax)} → {x₀ : E} → {r L : NNReal} → MetricSpace (ODE.FunSpace t₀ x₀ r L) | true |
_private.Mathlib.CategoryTheory.Sites.SheafCohomology.MayerVietoris.0.CategoryTheory.GrothendieckTopology.MayerVietorisSquare.fromBiprod_δ._proof_1_1 | Mathlib.CategoryTheory.Sites.SheafCohomology.MayerVietoris | ∀ (n₀ n₁ : ℕ), ¬1 + 2 ≤ 5 → False | false |
AEMeasurable.map_map_of_aemeasurable | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
[inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {g : β → γ} {f : α → β},
AEMeasurable g (MeasureTheory.Measure.map f μ) →
AEMeasurable f μ → MeasureTheory.Measure.map g (MeasureTheory.Measure.map f μ) =... | true |
CategoryTheory.FreeBicategory.Hom₂.associator_inv | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{a b c d : CategoryTheory.FreeBicategory B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
(h : c ⟶ d) →
CategoryTheory.FreeBicategory.Hom₂
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
(CategoryThe... | true |
Std.TreeMap.Raw.getElem?_eq_some_getD_of_contains | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α} {fallback : β}, t.contains a = true → t[a]? = some (t.getD a fallback) | true |
Lean.Elab.Term.Quotation.precheckAttribute._regBuiltin.Lean.Elab.Term.Quotation.precheckAttribute.declRange_3 | Lean.Elab.Quotation.Precheck | IO Unit | false |
Module.DirectLimit.lift_of'._proof_1 | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_3} [inst : Semiring R] {ι : Type u_1} [inst_1 : Preorder ι] {G : ι → Type u_2}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] (i j : ι) (hij : i ≤ j) (x : G i),
(Module.DirectLimit.of R ι G f j) ((f i j hi... | false |
Lean.Firefox.Profile.meta | Lean.Util.Profiler | Lean.Firefox.Profile → Lean.Firefox.ProfileMeta | true |
Rack.PreEnvelGroupRel'.trans.elim | Mathlib.Algebra.Quandle | {R : Type u} →
[inst : Rack R] →
{motive : (a a_1 : Rack.PreEnvelGroup R) → Rack.PreEnvelGroupRel' R a a_1 → Sort u_1} →
{a a_1 : Rack.PreEnvelGroup R} →
(t : Rack.PreEnvelGroupRel' R a a_1) →
t.ctorIdx = 2 →
({a b c : Rack.PreEnvelGroup R} →
(hab : Rack.PreEnve... | false |
Sublattice.le_prod_iff | Mathlib.Order.Sublattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] {L : Sublattice α} {M : Sublattice β}
{N : Sublattice (α × β)}, N ≤ L.prod M ↔ N ≤ Sublattice.comap LatticeHom.fst L ∧ N ≤ Sublattice.comap LatticeHom.snd M | true |
CategoryTheory.Functor.IsDenseSubsite.hasWeakSheafify_of_isEquivalence | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (J : CategoryTheory.GrothendieckTopology C)
(K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor C D) (A : Type u_4)
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] [ins... | true |
instPreservesFiniteProductsOppositeYonedaPresheafOfPreservesFiniteCoproductsTopCat | Mathlib.Condensed.TopComparison | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (G : CategoryTheory.Functor C TopCat) (X : Type w')
[inst_1 : TopologicalSpace X] [CategoryTheory.Limits.PreservesFiniteCoproducts G],
CategoryTheory.Limits.PreservesFiniteProducts (ContinuousMap.yonedaPresheaf G X) | true |
CategoryTheory.Limits.MonoFactorisation.copy_m | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
(F : CategoryTheory.Limits.MonoFactorisation f) (m : F.I ⟶ Y) (e : X ⟶ F.I)
(hm : autoParam (m = F.m) CategoryTheory.Limits.MonoFactorisation.copy._auto_1)
(he : autoParam (e = F.e) CategoryTheory.Limits.MonoFactorisation.copy._auto_3)... | true |
Filter.Germ.coeRingHom._proof_3 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {R : Type u_1} [inst : Semiring R] (l : Filter α), (↑(Filter.Germ.coeAddHom l)).toFun 0 = 0 | false |
_private.Mathlib.NumberTheory.PythagoreanTriples.0.circleEquivGen._simp_3 | Mathlib.NumberTheory.PythagoreanTriples | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
Std.TreeMap.minKeyD_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β}
{fallback : α}, (t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' | true |
ENNReal.limsup_const_mul | Mathlib.Order.Filter.ENNReal | ∀ {α : Type u_1} {f : Filter α} [CountableInterFilter f] {u : α → ENNReal} {a : ENNReal},
Filter.limsup (fun x => a * u x) f = a * Filter.limsup u f | true |
Encodable.decodeSum._sparseCasesOn_1.else_eq | Mathlib.Logic.Encodable.Basic | ∀ {motive : Bool → Sort u} (t : Bool) (false : motive false) («else» : Nat.hasNotBit 1 t.ctorIdx → motive t)
(h : Nat.hasNotBit 1 t.ctorIdx), Encodable.decodeSum._sparseCasesOn_1 t false «else» = «else» h | false |
_private.Mathlib.Algebra.Order.SuccPred.PartialSups.0.partialSups_add_one'._simp_1_1 | Mathlib.Algebra.Order.SuccPred.PartialSups | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Add α] [inst_2 : One α] [inst_3 : SuccAddOrder α] (x : α),
x + 1 = Order.succ x | false |
_private.Mathlib.Computability.EpsilonNFA.0.εNFA.mem_evalFrom_iff_exists_path._simp_1_3 | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u_1} (l : List (Option α)), (l.reduceOption = []) = ∃ n, l = List.replicate n none | false |
IsAtom.of_compl | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {a : α}, IsAtom aᶜ → IsCoatom a | true |
CategoryTheory.conjugateEquiv_adjunction_id_symm | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {L R : CategoryTheory.Functor C C} (adj : L ⊣ R)
(α : R ⟶ CategoryTheory.Functor.id C) (c : C),
((CategoryTheory.conjugateEquiv adj CategoryTheory.Adjunction.id).symm α).app c =
CategoryTheory.CategoryStruct.comp (adj.unit.app c) (α.app (L.obj c)) | true |
Lean.ParametricAttributeExtra.mk._flat_ctor | Batteries.Lean.AttributeExtra | {α : Type} → Lean.ParametricAttribute α → Std.HashMap Lean.Name α → Lean.ParametricAttributeExtra α | false |
_private.Mathlib.RingTheory.Etale.Pi.0.Algebra.FormallyEtale.pi_iff._simp_1_1 | Mathlib.RingTheory.Etale.Pi | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
Algebra.FormallyEtale R A = (Algebra.FormallyUnramified R A ∧ Algebra.FormallySmooth R A) | false |
Lists'.mem_of_subset | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : Lists α} {l₁ l₂ : Lists' α true}, l₁ ⊆ l₂ → a ∈ l₁ → a ∈ l₂ | true |
_private.Mathlib.Analysis.Complex.Arg.0.Complex.sameRay_iff._simp_1_6 | Mathlib.Analysis.Complex.Arg | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Mathlib.LinearAlgebra.Matrix.ToLinearEquiv.0.Matrix.det_ne_zero_of_sum_col_pos._simp_1_1 | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
(a < s.sup' H f) = ∃ b ∈ s, a < f b | false |
LocallyConstant.mapAddMonoidHom.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {Z : Type u_6} [inst_1 : AddZeroClass Y]
[inst_2 : AddZeroClass Z] (f : Y →+ Z),
LocallyConstant.mapAddMonoidHom f = { toFun := LocallyConstant.map ⇑f, map_zero' := ⋯, map_add' := ⋯ } | true |
Filter.comap_sup | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {g₁ g₂ : Filter β} {m : α → β},
Filter.comap m (g₁ ⊔ g₂) = Filter.comap m g₁ ⊔ Filter.comap m g₂ | true |
IsRelUpperSet.mem_of_le | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {s : Set α} {a b : α} {P : α → Prop} [inst : LE α], IsRelUpperSet s P → a ∈ s → a ≤ b → P b → b ∈ s | true |
Pell.yn_modEq_a_sub_one | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (n : ℕ), Pell.yn a1 n ≡ n [MOD a - 1] | true |
AddEquiv.prodAssoc.match_1 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_2} {N : Type u_1} {P : Type u_3} (motive : (M × N) × P → Prop) (x : (M × N) × P),
(∀ (fst : M × N) (snd : P), motive (fst, snd)) → motive x | false |
Ordinal.succ_iSup_eq_lsub_iff | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_4} (f : ι → Ordinal.{max u_5 u_4}), Order.succ (iSup f) = Ordinal.lsub f ↔ ∃ i, f i = iSup f | true |
UInt8.toUInt32_le._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a.toUInt32 ≤ b.toUInt32) = (a ≤ b) | false |
Std.ExtHashMap.getKey!_eq_of_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
[inst_1 : Inhabited α] {k : α}, k ∈ m → m.getKey! k = k | true |
AddMemClass.subtype._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} {A : Type u_2} [inst : Add M] [inst_1 : SetLike A M] [hA : AddMemClass A M] (S' : A) (x x_1 : ↥S'),
↑(x + x_1) = ↑(x + x_1) | false |
UInt32.recOn._@.Mathlib.Util.CompileInductive.3197476844._hygCtx._hyg.395 | Mathlib.Util.CompileInductive | {motive : UInt32 → Sort u} → (t : UInt32) → ((toBitVec : BitVec 32) → motive { toBitVec := toBitVec }) → motive t | false |
Lean.Elab.Do.Context._sizeOf_inst | Lean.Elab.Do.Basic | SizeOf Lean.Elab.Do.Context | false |
bernoulli'_zero | Mathlib.NumberTheory.Bernoulli | bernoulli' 0 = 1 | true |
lTensor.inverse._proof_1 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_3} {N : Type u_1} {P : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : AddCommGroup P]
[inst_3 : Module R N] [inst_4 : Module R P] {g : N →ₗ[R] P} (hg : Function.Surjective ⇑g),
Function.RightInverse (Function.surjInv hg) ⇑g | false |
Polynomial.trinomial_leading_coeff' | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {R : Type u_1} [inst : Semiring R] {k m n : ℕ} {u v w : R},
k < m → m < n → (Polynomial.trinomial k m n u v w).coeff n = w | true |
SemilatSupCat.of.sizeOf_spec | Mathlib.Order.Category.Semilat | ∀ (X : Type u) [isSemilatticeSup : SemilatticeSup X] [isOrderBot : OrderBot X],
sizeOf { X := X, isSemilatticeSup := isSemilatticeSup, isOrderBot := isOrderBot } =
1 + sizeOf X + sizeOf isSemilatticeSup + sizeOf isOrderBot | true |
AddGroupFilterBasis.instInhabited._proof_1 | Mathlib.Topology.Algebra.FilterBasis | ∀ {G : Type u_1} [inst : AddGroup G] {x y : Set G}, x ∈ {{0}} → y ∈ {{0}} → ∃ z ∈ {{0}}, z ⊆ x ∩ y | false |
_private.Lean.Elab.Command.0.Lean.Elab.Command.withScope.match_1 | Lean.Elab.Command | (motive : List Lean.Elab.Command.Scope → Sort u_1) →
(x : List Lean.Elab.Command.Scope) →
(Unit → motive []) →
((h : Lean.Elab.Command.Scope) → (t : List Lean.Elab.Command.Scope) → motive (h :: t)) → motive x | false |
Bool.not_rightInverse | Mathlib.Logic.Equiv.Bool | Function.RightInverse not not | true |
Polynomial.coeff_ofNat_mul | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {a k : ℕ} [inst_1 : a.AtLeastTwo],
(OfNat.ofNat a * p).coeff k = OfNat.ofNat a * p.coeff k | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.