name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ProofWidgets.ExprPresenter | ProofWidgets.Presentation.Expr | Type | true |
CategoryTheory.Subobject.widePullbackι.eq_1 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.LocallySmall.{w, v₁, u₁} C]
[inst_2 : CategoryTheory.WellPowered.{w, v₁, u₁} C] [inst_3 : CategoryTheory.Limits.HasWidePullbacks C] {A : C}
(s : Set (CategoryTheory.Subobject A)),
CategoryTheory.Subobject.widePullbackι s = Catego... | true |
Prefunctor.map_reverse | Mathlib.Combinatorics.Quiver.Symmetric | ∀ {U : Type u_1} {V : Type u_2} [inst : Quiver U] [inst_1 : Quiver V] [inst_2 : Quiver.HasReverse U]
[inst_3 : Quiver.HasReverse V] (φ : U ⥤q V) [φ.MapReverse] {u v : U} (e : u ⟶ v),
φ.map (Quiver.reverse e) = Quiver.reverse (φ.map e) | true |
MulActionSemiHomClass.rec | Mathlib.GroupTheory.GroupAction.Hom | {F : Type u_8} →
{M : Type u_9} →
{N : Type u_10} →
{φ : M → N} →
{X : Type u_11} →
{Y : Type u_12} →
[inst : SMul M X] →
[inst_1 : SMul N Y] →
[inst_2 : FunLike F X Y] →
{motive : MulActionSemiHomClass F φ X Y → Sort u} →
... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_alter_le_size._proof_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {t : Std.DTreeMap.Internal.Impl α fun x => β}, ¬t.size - 1 ≤ t.size + 1 → False | false |
Irrational.eventually_forall_le_dist_cast_rat_of_den_le | Mathlib.Topology.Instances.Irrational | ∀ {x : ℝ}, Irrational x → ∀ (n : ℕ), ∀ᶠ (ε : ℝ) in nhds 0, ∀ (r : ℚ), r.den ≤ n → ε ≤ dist x ↑r | true |
CategoryTheory.Limits.ColimitPresentation.isColimit | Mathlib.CategoryTheory.Limits.Presentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
(self : CategoryTheory.Limits.ColimitPresentation J X) →
CategoryTheory.Limits.IsColimit { pt := X, ι := self.ι } | true |
Order.sub_one_wcovBy._simp_1 | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Sub α] [inst_2 : One α] [PredSubOrder α] (x : α), (x - 1 ⩿ x) = True | false |
tprod_setElem_eq_tprod_setElem_diff | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} (s t : Set β),
(∀ b ∈ t, f b = 1) → ∏' (a : ↑s), f ↑a = ∏' (a : ↑(s \ t)), f ↑a | true |
Lean.Diff.Histogram.Entry | Lean.Util.Diff | Type u → ℕ → ℕ → Type | true |
RelEmbedding.symm | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ↪r s) [Std.Symm s], Std.Symm r | true |
Rack.EnvelGroup | Mathlib.Algebra.Quandle | (R : Type u_1) → [Rack R] → Type u_1 | true |
_private.Lean.Data.Lsp.LanguageFeatures.0.Lean.Lsp.instToJsonSemanticTokenModifier.toJson.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.SemanticTokenModifier → Sort u_1) →
(x : Lean.Lsp.SemanticTokenModifier) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.declaration) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.definition) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.readonly) →
(Unit → motive Le... | false |
SSet.stdSimplex.const | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | (n : ℕ) → Fin (n + 1) → (m : SimplexCategoryᵒᵖ) → (SSet.stdSimplex.obj (SimplexCategory.mk n)).obj m | true |
UpperHalfPlane.instAddActionReal._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ (x : ℝ) (z : UpperHalfPlane), 0 < (↑x + ↑z).im | false |
MeasureTheory.IsAddFundamentalDomain.mono | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α},
MeasureTheory.IsAddFundamentalDomain G s μ →
∀ {ν : MeasureTheory.Measure α}, ν.AbsolutelyContinuous μ → MeasureTheory.IsAddFundamentalDomain G s ν | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.delete.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {n : ℕ} (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
c.delete l = { clause := List.erase c.clause l, nodupkey := ⋯, nodup := ⋯ } | true |
CategoryTheory.Mon.braiding_hom_hom | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (M N : CategoryTheory.Mon C), (β_ M N).hom.hom = (β_ M.X N.X).hom | true |
CategoryTheory.BasedFunctor.w | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (self : CategoryTheory.BasedFunctor 𝒳 𝒴), self.comp 𝒴.p = 𝒳.p | true |
Equidecomp.refl | Mathlib.Algebra.Group.Action.Equidecomp | (X : Type u_1) → (G : Type u_2) → [inst : Monoid G] → [inst_1 : MulAction G X] → Equidecomp X G | true |
Std.HashMap.getElem!_ofList_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List (α × β)}
{k k' : α},
(k == k') = true →
∀ {v : β} [inst : Inhabited β],
List.Pairwise (fun a b => (a.1 == b.1) = false) l → (k, v) ∈ l → (Std.HashMap.ofList l)[k']! = v | true |
PrimeSpectrum.BasicConstructibleSetData.rec | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} →
{motive : PrimeSpectrum.BasicConstructibleSetData R → Sort u} →
((f : R) → (n : ℕ) → (g : Fin n → R) → motive { f := f, n := n, g := g }) →
(t : PrimeSpectrum.BasicConstructibleSetData R) → motive t | false |
Quot.lift.decidablePred | Mathlib.Data.Quot | {α : Sort u_1} →
(r : α → α → Prop) →
(f : α → Prop) → (h : ∀ (a b : α), r a b → f a = f b) → [hf : DecidablePred f] → DecidablePred (Quot.lift f h) | true |
SaturatedAddSubmonoid.ext_iff | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {s₁ s₂ : SaturatedAddSubmonoid M},
s₁ = s₂ ↔ s₁.toAddSubmonoid = s₂.toAddSubmonoid | true |
Lean.Meta.RecursorUnivLevelPos._sizeOf_inst | Lean.Meta.RecursorInfo | SizeOf Lean.Meta.RecursorUnivLevelPos | false |
Mathlib.Tactic.BicategoryLike.IsoLift._sizeOf_1 | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.IsoLift → ℕ | false |
String.Slice.Pattern.Model.isMatch_iff | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.ForwardPatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsMatch pat pos ↔
String.Slice.Pattern.Model.ForwardPatternModel.Matches pat (s.sliceTo pos).copy | true |
Equiv.Perm.one_lt_card_support_of_ne_one | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α}, f ≠ 1 → 1 < f.support.card | true |
Representation.char_dual | Mathlib.RepresentationTheory.Character | ∀ {G : Type u_1} {k : Type u_2} {V : Type u_3} [inst : Group G] [inst_1 : Field k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [FiniteDimensional k V] (ρ : Representation k G V) (g : G), ρ.dual.character g = ρ.character g⁻¹ | true |
_private.Mathlib.Algebra.Ring.Subsemiring.Basic.0.Subsemiring.prod_top._simp_1_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {s : Subsemiring R}
{t : Subsemiring S} {p : R × S}, (p ∈ s.prod t) = (p.1 ∈ s ∧ p.2 ∈ t) | false |
IsSimpleOrder.equivBool.congr_simp | Mathlib.Order.Atoms | ∀ {α : Type u_4} [inst : DecidableEq α] [inst_1 : LE α] [inst_2 : BoundedOrder α] [inst_3 : IsSimpleOrder α],
IsSimpleOrder.equivBool = IsSimpleOrder.equivBool | true |
RatCast.mk._flat_ctor | Batteries.Classes.RatCast | {K : Type u} → (ℚ → K) → RatCast K | false |
SemiRingCat.instCategory._proof_3 | Mathlib.Algebra.Category.Ring.Basic | ∀ {W X Y Z : SemiRingCat} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } | false |
Submodule.pointwiseNeg | Mathlib.Algebra.Module.Submodule.Pointwise | {R : Type u_2} →
{M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Neg (Submodule R M) | true |
_private.Lean.Elab.MacroRules.0.Lean.Elab.Command.elabMacroRulesAux.match_6 | Lean.Elab.MacroRules | (motive : Option (Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",") → Sort u_1) →
(attrs? : Option (Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",")) →
((attrs : Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",") → motive (some attrs)) →
(Unit → motive none) → motive attrs? | false |
_private.Mathlib.SetTheory.Lists.0.Lists'.ofList.match_1.eq_2 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} (motive : List (Lists α) → Sort u_2) (a : Lists α) (l : List (Lists α)) (h_1 : Unit → motive [])
(h_2 : (a : Lists α) → (l : List (Lists α)) → motive (a :: l)),
(match a :: l with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_2 a l | true |
CategoryTheory.Equivalence.ctorIdx | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} → {inst_1 : CategoryTheory.Category.{v₂, u₂} D} → (C ≌ D) → ℕ | false |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Translations.0.GenContFract.IntFractPair.exists_succ_nth_stream_of_fr_zero._simp_1_2 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
Nat.factoredNumbers.map_prime_pow_mul | Mathlib.NumberTheory.SmoothNumbers | ∀ {F : Type u_1} [inst : Mul F] {f : ℕ → F},
(∀ {m n : ℕ}, m.Coprime n → f (m * n) = f m * f n) →
∀ {s : Finset ℕ} {p : ℕ},
Nat.Prime p → p ∉ s → ∀ (e : ℕ) {m : ↑(Nat.factoredNumbers s)}, f (p ^ e * ↑m) = f (p ^ e) * f ↑m | true |
MeasureTheory.ComplexMeasure.singularPart._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ContinuousAdd ℝ | false |
EquivLike.comp_surjective | Mathlib.Data.FunLike.Equiv | ∀ {F : Sort u_2} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [inst : EquivLike F β γ] (f : α → β) (e : F),
Function.Surjective (⇑e ∘ f) ↔ Function.Surjective f | true |
FiniteArchimedeanClass.closedBall | Mathlib.Algebra.Order.Module.Archimedean | {M : Type u_1} →
[inst : AddCommGroup M] →
[inst_1 : LinearOrder M] →
[inst_2 : IsOrderedAddMonoid M] →
(K : Type u_2) →
[inst_3 : Ring K] →
[inst_4 : LinearOrder K] →
[IsOrderedRing K] →
[Archimedean K] → [inst_7 : Module K M] → [PosSMulMono K M] ... | true |
Submodule.piQuotientLift._proof_1 | Mathlib.LinearAlgebra.Quotient.Pi | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
Int.Linear.Expr.denote.eq_7 | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (e : Int.Linear.Expr) (k : ℤ),
Int.Linear.Expr.denote ctx (e.mulR k) = Int.Linear.Expr.denote ctx e * k | true |
Batteries.Tactic.Lint.SimpTheoremInfo.noConfusionType | Batteries.Tactic.Lint.Simp | Sort u → Batteries.Tactic.Lint.SimpTheoremInfo → Batteries.Tactic.Lint.SimpTheoremInfo → Sort u | false |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.instBEqOp.beq | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op → Bool | true |
Lean.Grind.ToInt.Pow.toInt_pow | Init.Grind.ToInt | ∀ {α : Type u} {inst : HPow α ℕ α} {I : outParam Lean.Grind.IntInterval} {inst_1 : Lean.Grind.ToInt α I}
[self : Lean.Grind.ToInt.Pow α I] (x : α) (n : ℕ), ↑(x ^ n) = I.wrap (↑x ^ n) | true |
MvPolynomial.iterToSum_C_X | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) (S₂ : Type w) [inst : CommSemiring R] (c : S₂),
(MvPolynomial.iterToSum R S₁ S₂) (MvPolynomial.C (MvPolynomial.X c)) = MvPolynomial.X (Sum.inr c) | true |
_private.Mathlib.Order.Filter.AtTopBot.Group.0.Filter.tendsto_comp_inv_atBot_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), (fun x => f (g x)) = f ∘ g | false |
StarSubalgebra.topologicalClosure._proof_4 | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
[inst_7 : IsSemitopologicalSemiring A] (s : StarSubalgebra R A), 0 ∈ s.topologicalClosure.carrier | false |
UInt64.toBitVec_eq_of_eq | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a = b → a.toBitVec = b.toBitVec | true |
Complex.exp_ne_zero._simp_1 | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℂ), (Complex.exp x = 0) = False | false |
IsLocalExtr.deriv_eq_zero | Mathlib.Analysis.Calculus.LocalExtr.Basic | ∀ {f : ℝ → ℝ} {a : ℝ}, IsLocalExtr f a → deriv f a = 0 | true |
Function.HasTemperateGrowth.zero | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F], Function.HasTemperateGrowth fun x => 0 | true |
nhdsSet_Iic | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderClosedTopology α] {a : α},
nhdsSet (Set.Iic a) = nhds a ⊔ Filter.principal (Set.Iio a) | true |
QuaternionAlgebra.imJ | Mathlib.Algebra.Quaternion | {R : Type u_1} → {a b c : R} → QuaternionAlgebra R a b c → R | true |
Lean.Server.RequestHandler.mk.noConfusion | Lean.Server.Requests | {P : Sort u} →
{fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri} →
{handle : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)} →
{fileSource' : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri} →
{handle' : Lea... | false |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.LinearMap.isPositive_iff._simp_1_2 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | false |
_private.Mathlib.Data.Seq.Defs.0.Stream'.Seq.notMem_nil.match_1_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u_1} (a : α) (motive : a ∈ Stream'.Seq.nil → Prop) (x : a ∈ Stream'.Seq.nil),
(∀ (w : ℕ) (h : some a = none), motive ⋯) → motive x | false |
Field.div._inherited_default | Mathlib.Algebra.Field.Defs | {K : Type u} →
(mul : K → K → K) →
(∀ (a b c : K), a * b * c = a * (b * c)) →
(one : K) →
(∀ (a : K), 1 * a = a) →
(∀ (a : K), a * 1 = a) →
(npow : ℕ → K → K) →
(∀ (x : K), npow 0 x = 1) → (∀ (n : ℕ) (x : K), npow (n + 1) x = npow n x * x) → (K → K) → K → K → K | false |
WeierstrassCurve.coeff_Φ | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (n : ℤ), (W.Φ n).coeff (n.natAbs ^ 2) = 1 | true |
_private.Lean.Level.0.Lean.Level.isIMax._sparseCasesOn_1.else_eq | Lean.Level | ∀ {motive : Lean.Level → Sort u} (t : Lean.Level) (imax : (a a_1 : Lean.Level) → motive (a.imax a_1))
(«else» : Nat.hasNotBit 8 t.ctorIdx → motive t) (h : Nat.hasNotBit 8 t.ctorIdx),
Lean.Level.isIMax._sparseCasesOn_1✝ t imax «else» = «else» h | false |
Set.SurjOn.image_invFunOn_image | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} [inst : Nonempty α],
Set.SurjOn f s t → f '' (Function.invFunOn f s '' t) = t | true |
Fin.appendIsometry._proof_2 | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (m n : ℕ) (x x_1 : (Fin m → α) × (Fin n → α)),
edist ((Fin.appendEquiv m n).toFun x) ((Fin.appendEquiv m n).toFun x_1) = edist x x_1 | false |
Valuation.IsEquiv.of_eq | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] {v v' : Valuation R Γ₀},
v = v' → v.IsEquiv v' | true |
_private.Mathlib.Condensed.Light.InternallyProjective.0.LightCondensed.ihom_map_val_app._simp_1_2 | Mathlib.Condensed.Light.InternallyProjective | ∀ {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} (adj : F ⊣ G) {X : C} {Y Y' : D} (f : X ⟶ G.obj Y)
(g : Y ⟶ Y'),
CategoryTheory.CategoryStruct.comp ((adj.homEquiv X Y).symm f) ... | false |
PowerSeries.IsWeierstrassDivisorAt.mod_coe_eq_self | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] {g : PowerSeries A} {I : Ideal A} (H : g.IsWeierstrassDivisorAt I)
[inst_1 : IsAdicComplete I A] {r : Polynomial A},
r.degree < ↑((PowerSeries.map (Ideal.Quotient.mk I)) g).order.toNat → H.mod ↑r = r | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.ker_eval₂Hom_universalFactorizationMap._simp_1_3 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rcf : RingHomClass F R S] {f : F} {r : R}, (r ∈ RingHom.ker f) = (f r = 0) | false |
Lean.Expr.replaceNoCache._sunfold | Lean.Util.ReplaceExpr | (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Expr | false |
Array.setIfInBounds_def | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (xs : Array α) (i : ℕ) (a : α), xs.setIfInBounds i a = if h : i < xs.size then xs.set i a h else xs | true |
Lean.Parser.ParserCategory._sizeOf_1 | Lean.Parser.Basic | Lean.Parser.ParserCategory → ℕ | false |
SeparationQuotient.instAddCommSemigroup | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : AddCommSemigroup M] → [ContinuousAdd M] → AddCommSemigroup (SeparationQuotient M) | true |
CategoryTheory.Over.ConstructProducts.conesEquivFunctor.match_1 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | {J : Type u_1} →
(motive : CategoryTheory.Discrete J → Sort u_2) →
(x : CategoryTheory.Discrete J) → ((j : J) → motive { as := j }) → motive x | false |
TensorProduct.toIntegralClosure_bijective_of_smooth | Mathlib.RingTheory.Smooth.IntegralClosure | ∀ {R : Type u_1} {S : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing B] [inst_4 : Algebra R B] [Algebra.Smooth R S],
Function.Bijective ⇑(TensorProduct.toIntegralClosure R S B) | true |
CategoryTheory.Yoneda.naturality | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C}
(α : CategoryTheory.yoneda.obj X ⟶ CategoryTheory.yoneda.obj Y) {Z Z' : C} (f : Z ⟶ Z') (h : Z' ⟶ X),
CategoryTheory.CategoryStruct.comp f (α.app (Opposite.op Z') h) =
α.app (Opposite.op Z) (CategoryTheory.CategoryStruct.comp f h) | true |
Finsupp.lt_of_forall_lt_of_lt | Mathlib.Data.Finsupp.Lex | ∀ {α : Type u_1} {N : Type u_2} [inst : Zero N] [inst_1 : LinearOrder α] [inst_2 : PartialOrder N] (a b : Lex (α →₀ N))
(i : α), (∀ j < i, (ofLex a) j = (ofLex b) j) → (ofLex a) i < (ofLex b) i → a < b | true |
MeasureTheory.SimpleFunc.instSemilatticeSup._proof_3 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : SemilatticeSup β]
(_f _g _h : MeasureTheory.SimpleFunc α β), _f ≤ _h → _g ≤ _h → ∀ (a : α), _f a ⊔ _g a ≤ _h a | false |
Complex.contDiff_exp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ] {n : WithTop ℕ∞},
ContDiff 𝕜 n Complex.exp | true |
Frm.Iso.mk._proof_4 | Mathlib.Order.Category.Frm | ∀ {α β : Frm} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊓ b) = e.symm a ⊓ e.symm b | false |
Pi.mulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
(α : Type u_1) →
[inst : MonoidWithZero α] →
[inst_1 : (i : I) → Zero (f i)] → [(i : I) → MulActionWithZero α (f i)] → MulActionWithZero α ((i : I) → f i) | true |
HomotopicalAlgebra.PathObject.symm_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.PathObject A), P.symm.ι = P.ι | true |
SimpleGraph.chromaticNumber_le_card | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u} {G : SimpleGraph V} [inst : Fintype V], G.chromaticNumber ≤ ↑(Fintype.card V) | true |
Rat.inv_natCast_num_of_pos | Mathlib.Data.Rat.Lemmas | ∀ {a : ℕ}, 0 < a → (↑a)⁻¹.num = 1 | true |
Set.sInter_delab | Mathlib.Order.SetNotation | Lean.PrettyPrinter.Delaborator.Delab | true |
_private.Lean.Meta.InferType.0.Lean.Meta.inferTypeImp.infer.match_1 | Lean.Meta.InferType | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((c : Lean.Name) → motive (Lean.Expr.const c [])) →
((c : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const c us)) →
((n : Lean.Name) → (i : ℕ) → (s : Lean.Expr) → motive (Lean.Expr.proj n i s)) →
((f arg : Lean.Expr) → motive... | false |
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.finite_of_free_aux._simp_1_2 | Mathlib.RingTheory.Unramified.Finite | ∀ {M : Type u_1} {N : Type u_2} {γ : Type u_3} [inst : AddCommMonoid N] [inst_1 : DistribSMul M N] {r : M} {f : γ → N}
{s : Finset γ}, ∑ x ∈ s, r • f x = r • ∑ x ∈ s, f x | false |
AffineEquiv.mk.sizeOf_spec | 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₂] [inst_7 : SizeOf k] [inst_8 : SizeOf P₁] [inst_9 : SizeOf P₂]
[... | true |
CategoryTheory.Equivalence.instMonoidalInverseTrans._proof_15 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCate... | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Biproducts.0.CategoryTheory.Limits.biproduct.isoProduct_inv._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | false |
ULift.field._proof_9 | Mathlib.Algebra.Field.ULift | ∀ {α : Type u_2} [inst : Field α] (q : ℚ≥0) (a : ULift.{u_1, u_2} α), DivisionRing.nnqsmul q a = ↑q * a | false |
Filter.IsCountableBasis.casesOn | Mathlib.Order.Filter.CountablyGenerated | {α : Type u_1} →
{ι : Type u_4} →
{p : ι → Prop} →
{s : ι → Set α} →
{motive : Filter.IsCountableBasis p s → Sort u} →
(t : Filter.IsCountableBasis p s) →
((toIsBasis : Filter.IsBasis p s) → (countable : (setOf p).Countable) → motive ⋯) → motive t | false |
CategoryTheory.Balanced.isIso_of_mono_of_epi | Mathlib.CategoryTheory.Balanced | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Balanced C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Mono f] [CategoryTheory.Epi f], CategoryTheory.IsIso f | true |
SmoothPartitionOfUnity.casesOn | Mathlib.Geometry.Manifold.PartitionOfUnity | {ι : Type uι} →
{E : Type uE} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type uH} →
[inst_2 : TopologicalSpace H] →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
[inst_3 : TopologicalSpace M] →
[inst_4 : ... | false |
Valuation.IsEquiv.valueGroup₀Fun._proof_3 | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_2} {Γ₀ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] {v : Valuation R Γ₀}
(d : { xy // v xy.1 ≠ 0 ∧ v xy.2 ≠ 0 }), v (↑d).2 ≠ 0 | false |
MeasurableDiv₂.rec | Mathlib.MeasureTheory.Group.Arithmetic | {G₀ : Type u_2} →
[inst : MeasurableSpace G₀] →
[inst_1 : Div G₀] →
{motive : MeasurableDiv₂ G₀ → Sort u} →
((measurable_div : Measurable fun p => p.1 / p.2) → motive ⋯) → (t : MeasurableDiv₂ G₀) → motive t | false |
Std.TreeMap.Raw.Equiv.entryAtIdxD_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {i : ℕ}
{fallback : α × β}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.entryAtIdxD i fallback = t₂.entryAtIdxD i fallback | true |
Perfection.teichmuller | Mathlib.RingTheory.Teichmuller | (p : ℕ) →
[inst : Fact (Nat.Prime p)] →
{R : Type u_1} →
[inst_1 : CommRing R] →
(I : Ideal R) → [inst_2 : CharP (R ⧸ I) p] → [IsAdicComplete I R] → Perfection (R ⧸ I) p →* R | true |
MeasureTheory.Lp.compMeasurePreserving._proof_2 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_2} {E : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {β : Type u_3} [inst_1 : MeasurableSpace β] {μb : MeasureTheory.Measure β} (f : α → β)
(hf : MeasureTheory.MeasurePreserving f μ μb) (g : ↥(MeasureTheory.Lp E p μb)),
(↑g).compMeasureP... | false |
Bundle.Trivialization.contMDiffOn_iff | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {M : Type u_5} {E : B → Type u_6}
[inst : NontriviallyNormedField 𝕜] {EB : Type u_7} [inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB]
{HB : Type u_8} [inst_3 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSp... | true |
Char.instLawfulUpwardEnumerableLE | Init.Data.Range.Polymorphic.Char | Std.PRange.LawfulUpwardEnumerableLE Char | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.