name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.MorphismProperty.Comma.forget._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
(L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) (P : CategoryTheory.MorphismProperty T)
(Q : CategoryTheory... | false |
MeasureTheory.IsAddFundamentalDomain.aestronglyMeasurable_on_iff | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s t : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α] [MeasureTheory.VAddInvariantMeasure G α μ] [Countable G]
{β : Type u_6} [inst_6 : TopologicalSpace β] [TopologicalSpace.PseudoMetrizableSpac... | true |
_private.Mathlib.Analysis.Convex.Between.0.wbtw_iff_sameRay_vsub._simp_1_1 | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (r s : R) (x : M),
r • x + s • x = (r + s) • x | false |
Lean.Meta.Grind.SavedState.noConfusionType | Lean.Meta.Tactic.Grind.Types | Sort u → Lean.Meta.Grind.SavedState → Lean.Meta.Grind.SavedState → Sort u | false |
AddUnits.embedProduct_injective | Mathlib.Algebra.Group.Prod | ∀ (α : Type u_6) [inst : AddMonoid α], Function.Injective ⇑(AddUnits.embedProduct α) | true |
_private.Lean.Elab.DocString.0.Lean.Doc.elabBlocks'.match_1 | Lean.Elab.DocString | (motive :
Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) × Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty) →
Sort u_1) →
(__discr :
Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) ×
Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)) →
((content : Array (Lea... | false |
CategoryTheory.MorphismProperty.pushouts | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.MorphismProperty C → CategoryTheory.MorphismProperty C | true |
FreeGroup.Red.reduce_right | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} {L₁ L₂ : List (α × Bool)} [inst : DecidableEq α],
FreeGroup.Red L₁ L₂ → FreeGroup.Red L₁ (FreeGroup.reduce L₂) | true |
ProbabilityTheory.Kernel.HasSubgaussianMGF.of_map | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {Ω' : Type u_2} {mΩ : MeasurableSpace Ω} {mΩ' : MeasurableSpace Ω'} {ν : MeasureTheory.Measure Ω'}
{c : NNReal} {Ω'' : Type u_3} {mΩ'' : MeasurableSpace Ω''} {κ : ProbabilityTheory.Kernel Ω' Ω''} {Y : Ω'' → Ω}
{X : Ω → ℝ},
Measurable Y →
ProbabilityTheory.Kernel.HasSubgaussianMGF X c (κ.map Y... | true |
String.Internal.length | Init.Data.String.Bootstrap | String → ℕ | true |
_private.Lean.Widget.InteractiveGoal.0.Lean.Widget.goalToInteractive._sparseCasesOn_5 | Lean.Widget.InteractiveGoal | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.NumberTheory.ArithmeticFunction.VonMangoldt.0.ArithmeticFunction.sum_moebius_mul_log_eq._simp_1_3 | Mathlib.NumberTheory.ArithmeticFunction.VonMangoldt | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
BoolAlg.of.injEq | Mathlib.Order.Category.BoolAlg | ∀ (carrier : Type u_1) [str : BooleanAlgebra carrier] (carrier_1 : Type u_1) (str_1 : BooleanAlgebra carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_529 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
Monoid.IsTorsion.torsionMulEquiv.eq_1 | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : CommMonoid G] (tG : Monoid.IsTorsion G),
tG.torsionMulEquiv = (MulEquiv.submonoidCongr ⋯).trans Submonoid.topEquiv | true |
List.Cursor.rec | Std.Do.Triple.SpecLemmas | {α : Type u} →
{l : List α} →
{motive : l.Cursor → Sort u_1} →
((«prefix» suffix : List α) →
(property : «prefix» ++ suffix = l) →
motive { «prefix» := «prefix», suffix := suffix, property := property }) →
(t : l.Cursor) → motive t | false |
_private.Mathlib.Topology.Sober.0.isGenericPoint_iff_forall_closed._simp_1_3 | Mathlib.Topology.Sober | ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, (t ⊆ ⋂₀ S) = ∀ t' ∈ S, t ⊆ t' | false |
CategoryTheory.Limits.biproduct.mapBiproduct_hom_desc | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] {J : Type w₁} (f : J → ... | true |
Std.LawfulCmp.toTransCmp | Batteries.Classes.Order | ∀ {α : Type u_1} {inst : LE α} {inst_1 : LT α} {cmp : α → α → Ordering} [self : Std.LawfulCmp cmp], Std.TransCmp cmp | true |
_private.Mathlib.Combinatorics.Enumerative.Partition.Glaisher.0.Nat.Partition.aux_mul_one_sub_X_pow | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | ∀ (R : Type u_1) [inst : TopologicalSpace R] [T2Space R] [inst_2 : CommRing R] [NoZeroDivisors R] [IsTopologicalRing R]
{m : ℕ},
0 < m →
(∏' (i : ℕ), if ¬m ∣ i + 1 then ∑' (j : ℕ), PowerSeries.X ^ ((i + 1) * j) else 1) *
∏' (i : ℕ), (1 - PowerSeries.X ^ (i + 1)) =
∏' (i : ℕ), (1 - PowerSeries.X ^ ... | true |
eventually_nhds_subtype_iff | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : Set α) (a : ↑s) (P : α → Prop),
(∀ᶠ (x : ↑s) in nhds a, P ↑x) ↔ ∀ᶠ (x : α) in nhdsWithin (↑a) s, P x | true |
Set.ofNat_mem_center | Mathlib.Algebra.Ring.Center | ∀ (M : Type u_1) [inst : NonAssocSemiring M] (n : ℕ) [inst_1 : n.AtLeastTwo], OfNat.ofNat n ∈ Set.center M | true |
OmegaCompletePartialOrder.Chain.mem_map_iff | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (c : OmegaCompletePartialOrder.Chain α)
{f : α →o β} {b : β}, b ∈ c.map f ↔ ∃ a ∈ c, f a = b | true |
InfHom.symm_dual_id | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} [inst : Min α], InfHom.dual.symm (SupHom.id αᵒᵈ) = InfHom.id α | true |
CategoryTheory.FreeBicategory.inclusion._proof_10 | Mathlib.CategoryTheory.Bicategory.Coherence | ∀ (B : Type u_1) [inst : Quiver B] {a b : CategoryTheory.LocallyDiscrete (CategoryTheory.Paths B)} (f : a ⟶ b),
(CategoryTheory.FreeBicategory.preinclusion B).map₂ (CategoryTheory.Bicategory.rightUnitor f).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.FreeBicategory.inclusionMapCompAux f.as (Cate... | false |
Continuous.cfcₙ_of_mem_nhdsSet._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | false |
Lean.Lsp.SemanticTokensOptions.legend | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SemanticTokensOptions → Lean.Lsp.SemanticTokensLegend | true |
UniformContinuousConstSMul.op | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : SMul M X] [inst_2 : SMul Mᵐᵒᵖ X] [IsCentralScalar M X]
[UniformContinuousConstSMul M X], UniformContinuousConstSMul Mᵐᵒᵖ X | true |
HasFDerivAt.star | Mathlib.Analysis.Calculus.FDeriv.Star | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : StarRing 𝕜] {E : Type u_2} [inst_2 : NormedAddCommGroup E]
[inst_3 : NormedSpace 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : StarAddMonoid F]
[inst_6 : NormedSpace 𝕜 F] [inst_7 : StarModule 𝕜 F] [inst_8 : ContinuousStar F] {f : E ... | true |
CategoryTheory.GrothendieckTopology.Point.mk.sizeOf_spec | Mathlib.CategoryTheory.Sites.Point.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} [inst_1 : SizeOf C]
(fiber : CategoryTheory.Functor C (Type w))
(isCofiltered :
autoParam (CategoryTheory.IsCofiltered fiber.Elements)
CategoryTheory.GrothendieckTopology.Point.isCofiltered._autoParam)
(... | true |
Lean.SourceInfo._sizeOf_1 | Init.SizeOf | Lean.SourceInfo → ℕ | false |
Lean.Parser.ParserContextCore.ctorIdx | Lean.Parser.Types | Lean.Parser.ParserContextCore → ℕ | false |
Std.DHashMap.Internal.Raw₀.reinsertAux | Std.Data.DHashMap.Internal.Defs | {α : Type u} → {β : α → Type v} → (α → UInt64) → { d // 0 < d.size } → (a : α) → β a → { d // 0 < d.size } | true |
Diffeology.DSmooth.continuous | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : DiffeologicalSpace X] [inst_1 : DiffeologicalSpace Y] {f : X → Y},
Diffeology.DSmooth f → Continuous f | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getMsbD_neg._simp_1_4 | Init.Data.BitVec.Bitblast | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | false |
_private.Init.Data.Option.Lemmas.0.Option.isSome.match_1.eq_2 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (val : α) → motive (some val)) (h_2 : Unit → motive none),
(match none with
| some val => h_1 val
| none => h_2 ()) =
h_2 () | true |
_private.Mathlib.RingTheory.Ideal.Span.0.Ideal.span_range_eq_span_range_support.match_1_6 | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u_2} [inst : Semiring α] {ι : Type u_1} (x : ι → α) (a : α) (motive : (∃ y, x ↑y = a) → Prop)
(x_1 : ∃ y, x ↑y = a), (∀ (j : ↑{x_2 | x x_2 ≠ 0}) (hj : x ↑j = a), motive ⋯) → motive x_1 | false |
CategoryTheory.Adjunction.toMonad_η | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (h : L ⊣ R), h.toMonad.η = h.unit | true |
Std.DHashMap.Internal.IsHashSelf | Std.Data.DHashMap.Internal.Defs | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → Array (Std.DHashMap.Internal.AssocList α β) → Prop | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Proof.0.Lean.Meta.Grind.Arith.Linear.mkFieldChar0ThmPrefix | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | Lean.Name → Lean.Meta.Grind.Arith.Linear.ProofM Lean.Expr | true |
Mathlib.Meta.NormNum.IsNat.to_eq | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u} [inst : AddMonoidWithOne α] {n : ℕ} {a a' : α}, Mathlib.Meta.NormNum.IsNat a n → ↑n = a' → a = a' | true |
Std.PRange.UpwardEnumerable.Map.PreservesLT.mk | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.UpwardEnumerable β]
[inst_2 : LT α] [inst_3 : LT β] {f : Std.PRange.UpwardEnumerable.Map α β},
(∀ {a b : α}, a < b ↔ f.toFun a < f.toFun b) → f.PreservesLT | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.Const.minEntry.match_1.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → Sort u_3)
(size : ℕ) (k : α) (v : β) (size_1 : ℕ) (k_1 : α) (v_1 : β) (l r r_1 : Std.DTreeMap.Internal.Impl α fun x => β)
(h :
(Std.DTreeMap.Internal.Impl.inner size k v (Std.DTreeMap.Internal.Impl.inne... | true |
CategoryTheory.AddMon.mkIso'.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N : C}
[inst_2 : CategoryTheory.AddMonObj M] [inst_3 : CategoryTheory.AddMonObj N] (e : M ≅ N)
[inst_4 : CategoryTheory.IsAddMonHom e.hom],
CategoryTheory.AddMon.mkIso' e =
{ hom := { hom := e.hom, isAd... | true |
_private.Mathlib.Algebra.Group.Subgroup.Basic.0.Group.mem_conjugatesOfSet_iff._simp_1_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {α : Type u} [inst : Group α] {a b : α}, IsConj a b = ∃ c, c * a * c⁻¹ = b | false |
Valuation.toAddValuation_apply | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_5} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
(r : R), (Valuation.toAddValuation v) r = OrderDual.toDual (Additive.ofMul (v r)) | true |
_private.Mathlib.LinearAlgebra.Matrix.WithConv.0.Matrix.WithConv.IsIdempotentElem.isSelfAdjoint._simp_1_3 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {M : Type u_1} [inst : Mul M] {a : M}, (a * a = a) = IsIdempotentElem a | false |
not_isMax_iff | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, ¬IsMax a ↔ ∃ b, a < b | true |
AlgebraicGeometry.Scheme.Hom.appIso_inv_appLE_assoc | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f] {U V : X.Opens}
(e : V ≤ (TopologicalSpace.Opens.map f.base).obj ((AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U))
{Z : CommRingCat} (h : X.presheaf.obj (Opposite.op V) ⟶ Z),
CategoryTheory.CategoryStruct.comp (Algebr... | true |
Lean.MonadError.recOn | Lean.Exception | {m : Type → Type} →
{motive : Lean.MonadError m → Sort u} →
(t : Lean.MonadError m) →
([toMonadExceptOf : MonadExceptOf Lean.Exception m] →
[toMonadRef : Lean.MonadRef m] →
[toAddErrorMessageContext : Lean.AddErrorMessageContext m] →
motive
{ toMonadExcept... | false |
Std.Time.DateTime.withHours | Std.Time.Zoned.DateTime | {tz : Std.Time.TimeZone} → Std.Time.DateTime tz → Std.Time.Hour.Ordinal → Std.Time.DateTime tz | true |
Std.DTreeMap.Internal.Impl.getEntryGT!_eq_get!_getEntryGT? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α β} {k : α}
[inst_1 : Inhabited ((a : α) × β a)],
Std.DTreeMap.Internal.Impl.getEntryGT! k t = (Std.DTreeMap.Internal.Impl.getEntryGT? k t).get! | true |
instReprContextFreeRule | Mathlib.Computability.ContextFreeGrammar | {T : Type u_1} → {N : Type u_2} → [Repr T] → [Repr N] → Repr (ContextFreeRule T N) | true |
Continuous.zpow | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous f → ∀ (z : ℤ), Continuous fun b => f b ^ z | true |
OrderBot | Mathlib.Order.BoundedOrder.Basic | (α : Type u) → [LE α] → Type u | true |
instDecidableLeBitVec._proof_1 | Init.Prelude | ∀ {w : ℕ} (x y : BitVec w), x.toNat.ble y.toNat = true → x.toNat ≤ y.toNat | false |
Lean.Server.Watchdog.handleRequest | Lean.Server.Watchdog | Lean.JsonRpc.RequestID → String → Lean.Json → Lean.Server.Watchdog.ServerM Unit | true |
SeparatedNhds.empty_left | Mathlib.Topology.Separation.SeparatedNhds | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : Set X), SeparatedNhds ∅ s | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rii.forIn'_congr._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) = (f = g) | false |
WithBot.exists_coe_lt | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : Preorder α] {p : WithBot α → Prop}, (∃ x, ↑a < x ∧ p x) ↔ ∃ b, a < b ∧ p ↑b | true |
Lean.Grind.CommRing.Expr.mul.injEq | Init.Grind.Ring.CommSolver | ∀ (a b a_1 b_1 : Lean.Grind.CommRing.Expr), (a.mul b = a_1.mul b_1) = (a = a_1 ∧ b = b_1) | true |
Lean.TSyntax.instCoeNumLitPrio | Init.Meta.Defs | Coe Lean.NumLit Lean.Prio | true |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn.match_3.eq_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} (motive : (xs : List α) → xs ≠ [] → Sort u_2) (y : α) (ys : List α) (h : y :: ys ≠ [])
(h_1 : (y : α) → (ys : List α) → (h : y :: ys ≠ []) → motive (y :: ys) h),
(match y :: ys, h with
| y :: ys, h => h_1 y ys h) =
h_1 y ys h | true |
CategoryTheory.instMonoId | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
CategoryTheory.Mono (CategoryTheory.CategoryStruct.id X) | true |
TemperedDistribution.lineDeriv_eq_fourierMultiplierCLM | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {E : Type u_3} {F : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : NormedSpace ℂ F] [inst_4 : FiniteDimensional ℝ E]
[inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E] (m : E) (f : TemperedDistribution E F),
LineDeriv.lineDerivOp m f =
(2... | true |
Std.Internal.IO.Process.PId.mk.noConfusion | Std.Internal.Async.Process | {P : Sort u} →
{toUInt64 toUInt64' : UInt64} → { toUInt64 := toUInt64 } = { toUInt64 := toUInt64' } → (toUInt64 = toUInt64' → P) → P | false |
CategoryTheory.MonoidalCategory.triangle_assoc_comp_right | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) Y).inv
(CategoryTheory.MonoidalCategoryStruct.whisker... | true |
CommRingCat.HomTopology.mvPolynomialHomeomorph.congr_simp | Mathlib.Algebra.Category.Ring.Topology | ∀ (σ : Type v) (R A : CommRingCat) [inst : TopologicalSpace ↑R] [inst_1 : IsTopologicalRing ↑R],
CommRingCat.HomTopology.mvPolynomialHomeomorph σ R A = CommRingCat.HomTopology.mvPolynomialHomeomorph σ R A | true |
_private.Mathlib.Analysis.Normed.Operator.LinearIsometry.0.LinearIsometry.toLinearMap_injective.match_1_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_3} {E₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
[inst_5 : Module R₂ E₂] (motive : (x x_1 : E →ₛₗᵢ[σ₁₂] E₂) → x.toLinearMap = x_1.toLinearMap → Pr... | false |
Profinite.Extend.functorOp | Mathlib.Topology.Category.Profinite.Extend | {I : Type u} →
[inst : CategoryTheory.SmallCategory I] →
{F : CategoryTheory.Functor I FintypeCat} →
(c : CategoryTheory.Limits.Cone (F.comp FintypeCat.toProfinite)) →
CategoryTheory.Functor Iᵒᵖ (CategoryTheory.CostructuredArrow FintypeCat.toProfinite.op (Opposite.op c.pt)) | true |
Int.toList_rcc_eq_nil_iff | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, (m...=n).toList = [] ↔ n < m | true |
Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.1210529748._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | false |
CategoryTheory.normalOfIsPushoutSndOfNormal | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q R S : C} →
{f : P ⟶ Q} →
{g : P ⟶ R} →
{h : Q ⟶ S} →
{k : R ⟶ S} →
[gn : CategoryTheory.NormalEpi g] →
(comm ... | true |
CategoryTheory.SimplicialThickening.hom_ext | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} [inst : LinearOrder J] (i j : CategoryTheory.SimplicialThickening J) (x y : i ⟶ j),
(∀ (t : J), t ∈ x.I ↔ t ∈ y.I) → x = y | true |
AlgebraicGeometry.isOpenImmersion_sigmaDesc | Mathlib.AlgebraicGeometry.Limits | ∀ {σ : Type v} (g : σ → AlgebraicGeometry.Scheme) [inst : Small.{u, v} σ] {X : AlgebraicGeometry.Scheme}
(α : (i : σ) → g i ⟶ X) [∀ (i : σ), AlgebraicGeometry.IsOpenImmersion (α i)],
Pairwise (Function.onFun Disjoint fun x => Set.range ⇑(α x)) →
AlgebraicGeometry.IsOpenImmersion (CategoryTheory.Limits.Sigma.des... | true |
ComputeAsymptotics.MultiseriesExpansion.Multiseries.destruct | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {basis_hd : ℝ → ℝ} →
{basis_tl : ComputeAsymptotics.Basis} →
ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl →
Option
(ℝ ×
ComputeAsymptotics.MultiseriesExpansion basis_tl ×
ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl) | true |
PowerSeries.X_pow_mul_inj | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] {k : ℕ} {φ ψ : PowerSeries R},
PowerSeries.X ^ k * φ = PowerSeries.X ^ k * ψ ↔ φ = ψ | true |
IsLocalization.away_of_isUnit_of_bijective | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_4} (S : Type u_5) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {r : R},
IsUnit r → Function.Bijective ⇑(algebraMap R S) → IsLocalization.Away r S | true |
Std.Time.ZonedDateTime.addMilliseconds | Std.Time.Zoned.ZonedDateTime | Std.Time.ZonedDateTime → Std.Time.Millisecond.Offset → Std.Time.ZonedDateTime | true |
_private.Aesop.RuleTac.Forward.0.Aesop.RuleTac.makeForwardHypProofs.isRedundant | Aesop.RuleTac.Forward | Lean.Expr → Aesop.RuleTac.ForwardM Bool | true |
_private.Mathlib.GroupTheory.Submonoid.Center.0.MulOpposite.op_mem_center_iff._simp_1_4 | Mathlib.GroupTheory.Submonoid.Center | ∀ {α : Type u_1} [inst : Mul α] (x y : α), MulOpposite.op y * MulOpposite.op x = MulOpposite.op (x * y) | false |
Subsemiring.center.commSemiring._proof_5 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R] (a b c : ↥(Submonoid.center R)), a * b * c = a * (b * c) | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.propagateNonlinearMul.go._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | Lean.Expr → StateT Lean.Meta.Grind.Arith.Cutsat.PropagateMul.State Lean.Meta.Grind.GoalM Unit | false |
AddMonoidHom.single | Mathlib.Algebra.Group.Pi.Lemmas | {I : Type u} →
(f : I → Type v) → [DecidableEq I] → [inst : (i : I) → AddZeroClass (f i)] → (i : I) → f i →+ (i : I) → f i | true |
CategoryTheory.Limits.FormalCoproduct.isLimitEvalMapConeCofanOp._proof_5 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_5, u_4} C] {A : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} A] [CategoryTheory.Limits.HasProducts A] (J : Type u_1)
(f : J → CategoryTheory.Limits.FormalCoproduct C) (F : CategoryTheory.Functor Cᵒᵖ A) (i : CategoryTheory.Discrete J),
CategoryTheory.Li... | false |
Cardinal.instCommMonoidWithZero._proof_4 | Mathlib.SetTheory.Cardinal.Order | ∀ (x : Cardinal.{u_1}), Semiring.npow 0 x = 1 | false |
Lean.Meta.Grind.mkExtension | Lean.Meta.Tactic.Grind.Extension | autoParam Lean.Name Lean.Meta.Grind.mkExtension._auto_1 → IO Lean.Meta.Grind.Extension | true |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular.0.Matrix.fromRows_one_isTotallyUnimodular_iff._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
Mathlib.Tactic.Order.Graph.TarjanState.noConfusion | Mathlib.Tactic.Order.Graph.Tarjan | {P : Sort u} →
{t t' : Mathlib.Tactic.Order.Graph.TarjanState} →
t = t' → Mathlib.Tactic.Order.Graph.TarjanState.noConfusionType P t t' | false |
div_le_of_mabs_div_le_right | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b c : G}, |a / b|ₘ ≤ c → a / c ≤ b | true |
Int32.xor_not | Init.Data.SInt.Bitwise | ∀ {a b : Int32}, a ^^^ ~~~b = ~~~(a ^^^ b) | true |
Std.DTreeMap.Internal.Impl.Const.IteratedSlowUnitInsertionInto | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → [Ord α] → (Std.DTreeMap.Internal.Impl α fun x => Unit) → Type (max 0 u) | true |
IsRetrocompact.inter_isOpen | Mathlib.Topology.Constructible | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s t : Set X},
IsRetrocompact s → IsRetrocompact t → IsOpen t → IsRetrocompact (s ∩ t) | true |
CategoryTheory._aux_Mathlib_CategoryTheory_Equivalence___unexpand_CategoryTheory_Equivalence_1 | Mathlib.CategoryTheory.Equivalence | Lean.PrettyPrinter.Unexpander | false |
CategoryTheory.Limits.hasLimit_equivalence_comp | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor J C} (e : K ≌ J)
[CategoryTheory.Limits.HasLimit F], CategoryTheory.Limits.HasLimit (e.functor.comp F) | true |
Real.log_le_log_iff | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ {x y : ℝ}, 0 < x → 0 < y → (Real.log x ≤ Real.log y ↔ x ≤ y) | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.balRight.match_1.congr_eq_1._sparseCasesOn_4 | Batteries.Data.RBMap.WF | {motive : Batteries.RBColor → Sort u} →
(t : Batteries.RBColor) → motive Batteries.RBColor.black → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
instCommSemiringNNRat._proof_7 | Mathlib.Data.NNRat.Defs | ∀ (a : ℚ≥0), a + 0 = a | false |
Real.Angle.sin_sub_pi_div_two | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (θ : Real.Angle), (θ - ↑(Real.pi / 2)).sin = -θ.cos | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.0.Lean.Elab.Tactic.BVDecide.Frontend.reconstructCounterExample.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide | (motive : ℕ × Lean.Expr × Bool → Sort u_1) →
(x : ℕ × Lean.Expr × Bool) →
((fst : ℕ) → (fst_1 : Lean.Expr) → (synthetic : Bool) → motive (fst, fst_1, synthetic)) → motive x | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.