name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
MvPolynomial.mapAlgEquiv._proof_3 | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {R : Type u_3} [inst : CommSemiring R] {A₁ : Type u_1} {A₂ : Type u_2} [inst_1 : CommSemiring A₁]
[inst_2 : CommSemiring A₂] [inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂], RingHomClass (A₁ ≃ₐ[R] A₂) A₁ A₂ | false |
Nat.toList_roo_eq_if | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m<...n).toList = if m + 1 < n then (m + 1) :: ((m + 1)<...n).toList else [] | true |
TensorProduct.piRightHom._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Pi | ∀ (R : Type u_1) [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (N : Type u_3)
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : Module S N] [IsScalarTower R S N], SMulCommClass R S N | false |
induced_to_pi | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {A : ι → Type u_6} [T : (i : ι) → TopologicalSpace (A i)] {X : Type u_9} (f : X → (i : ι) → A i),
TopologicalSpace.induced f Pi.topologicalSpace = ⨅ i, TopologicalSpace.induced (fun x => f x i) inferInstance | true |
CategoryTheory.Limits.HasImages.mk | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
(∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.Limits.HasImage f) → CategoryTheory.Limits.HasImages C | true |
Lean.Syntax.isNodeOf | Init.Prelude | Lean.Syntax → Lean.SyntaxNodeKind → ℕ → Bool | true |
Lean.Sym.Fin.eq_eq_true | Init.Sym.Lemmas | ∀ {n : ℕ} (a b : Fin n), decide (a = b) = true → (a = b) = True | true |
Order.isSuccPrelimitRecOn_of_isSuccPrelimit | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {b : α} {motive : α → Sort u_2} [inst : PartialOrder α] [inst_1 : SuccOrder α]
(succ : (a : α) → ¬IsMax a → motive (Order.succ a)) (isSuccPrelimit : (a : α) → Order.IsSuccPrelimit a → motive a)
(hb : Order.IsSuccPrelimit b), Order.isSuccPrelimitRecOn b succ isSuccPrelimit = isSuccPrelimit b hb | true |
Lean.IR.EmitC.GroundState.casesOn | Lean.Compiler.IR.EmitC | {motive : Lean.IR.EmitC.GroundState → Sort u} →
(t : Lean.IR.EmitC.GroundState) → ((auxCounter : ℕ) → motive { auxCounter := auxCounter }) → motive t | false |
Lean.PrettyPrinter.Delaborator.SubExpr.withAppFn | Lean.PrettyPrinter.Delaborator.SubExpr | {α : Type} →
{m : Type → Type} → [Monad m] → [MonadReaderOf Lean.SubExpr m] → [MonadWithReaderOf Lean.SubExpr m] → m α → m α | true |
SemicontinuousAt | Mathlib.Topology.Semicontinuity.Defs | {α : Type u_1} → {β : Type u_2} → [TopologicalSpace α] → (α → β → Prop) → α → Prop | true |
Real.contDiff_fourier | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
{f : V → E} {N : ℕ∞},
(∀ (n : ℕ), ↑n ≤ N → MeasureTheory.Integrable (fun v... | true |
OrderHom.monotone' | Mathlib.Order.Hom.Basic | ∀ {α : Type u_6} {β : Type u_7} [inst : Preorder α] [inst_1 : Preorder β] (self : α →o β), Monotone self.toFun | true |
MeasureTheory.integral_divergence_prod_Icc_of_hasFDerivAt_off_countable_of_le | Mathlib.MeasureTheory.Integral.DivergenceTheorem | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (f g : ℝ × ℝ → E)
(f' g' : ℝ × ℝ → ℝ × ℝ →L[ℝ] E) (a b : ℝ × ℝ),
a ≤ b →
∀ (s : Set (ℝ × ℝ)),
s.Countable →
ContinuousOn f (Set.Icc a b) →
ContinuousOn g (Set.Icc a b) →
(∀ x ∈ Set.Ioo a.1 b.1 ×ˢ Set.Ioo ... | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanMapIso | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{A : Type u'} →
[inst_2 : CategoryTheory.Category.{v', u'} A] →
{X : C} →
(data : F.Pre... | true |
Std.ExtHashSet.filter_eq_self_iff | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{f : α → Bool}, Std.ExtHashSet.filter f m = m ↔ ∀ (k : α) (h : k ∈ m), f (m.get k h) = true | true |
«_aux_Init_Notation___macroRules_term_<*__1» | Init.Notation | Lean.Macro | false |
MeasureTheory.lconvolution_comm | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : AddCommGroup G] [MeasurableAdd₂ G] [MeasurableNeg G]
{μ : MeasureTheory.Measure G} [μ.IsAddLeftInvariant] [μ.IsNegInvariant] {f g : G → ENNReal},
MeasureTheory.lconvolution f g μ = MeasureTheory.lconvolution g f μ | true |
UpperHalfPlane.smulFDeriv.eq_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Manifold | ∀ (g : GL (Fin 2) ℝ) (z : ℂ),
UpperHalfPlane.smulFDeriv g z =
(↑↑(UpperHalfPlane.σ g)).comp
(ContinuousLinearMap.restrictScalars ℝ
(ContinuousLinearMap.toSpanSingleton ℂ (↑↑(Matrix.GeneralLinearGroup.det g) / UpperHalfPlane.denom g z ^ 2))) | true |
InfTopHom.top_apply | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Top α] [inst_2 : SemilatticeInf β] [inst_3 : OrderTop β]
(a : α), ⊤ a = ⊤ | true |
_private.Mathlib.Geometry.Manifold.Riemannian.PathELength.0.Manifold.riemannianEDist_comm._simp_1_1 | Mathlib.Geometry.Manifold.Riemannian.PathELength | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
{n : WithTop ℕ∞} {f : E → E'}, ContMDiff (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') n f = ContD... | false |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR.run._unary._proof_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (n : ℕ) (xs : { l // l.length = n + 2 }) (l : { l // l.length = (n + 2 + 1) / 2 }),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun n a => n) ⟨(n + 2 + 1) / 2, l⟩ ⟨n.succ.succ, xs⟩ | false |
_private.Mathlib.Topology.Algebra.Valued.ValuedField.0.Valued.continuous_valuation_of_surjective._simp_1_1 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {α : Type u} {p q : α → Prop}, ({a | p a} ⊆ {a | q a}) = ∀ (a : α), p a → q a | false |
finrank_vectorSpan_insert_le_set | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : Set P) (p : P),
Module.finrank k ↥(vectorSpan k (insert p s)) ≤ Module.finrank k ↥(vectorSpan k s) + 1 | true |
_private.Plausible.Gen.0.Plausible.Gen.printSamples.match_1 | Plausible.Gen | (motive : IO.Error → Sort u_1) →
(ex : IO.Error) → ((msg : String) → motive (IO.Error.userError msg)) → ((e : IO.Error) → motive e) → motive ex | false |
CategoryTheory.Limits.opProductIsoCoproduct_inv_comp_lift | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {α : Type u_1} {Z : α → C}
[inst_1 : CategoryTheory.Limits.HasProduct Z] {X : C} (π : (a : α) → X ⟶ Z a),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opProductIsoCoproduct Z).inv
(CategoryTheory.Limits.Pi.lift π).op =
CategoryTheory... | true |
Equiv.subtypeEquivCodomain.match_1 | Mathlib.Logic.Equiv.Basic | ∀ {X : Sort u_1} {x : X} (motive : { x' // x' = x } → Prop) (x_1 : { x' // x' = x }),
(∀ (val : X) (h : val = x), motive ⟨val, h⟩) → motive x_1 | false |
ProofWidgets.GetExprPresentationParams.mk.sizeOf_spec | ProofWidgets.Presentation.Expr | ∀ (expr : Lean.Server.WithRpcRef ProofWidgets.ExprWithCtx) (name : Lean.Name),
sizeOf { expr := expr, name := name } = 1 + sizeOf expr + sizeOf name | true |
List.getLast?_eq_none_iff._simp_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, (xs.getLast? = none) = (xs = []) | false |
Lean.PrettyPrinter.Formatter.rawIdentNoAntiquot.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter | true |
noncompact_univ | Mathlib.Topology.Compactness.Compact | ∀ (X : Type u_2) [inst : TopologicalSpace X] [NoncompactSpace X], ¬IsCompact Set.univ | true |
Std.Rii.toList_eq_match_roi | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rii α} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.PRange.LawfulUpwardEnumerable α] [inst_3 : Std.Rxi.IsAlwaysFinite α],
r.toList =
match Std.PRange.least? with
| none => []
| some init => init :: init<...*.toList | true |
_private.Mathlib.NumberTheory.MahlerMeasure.0.Polynomial.card_mahlerMeasure._proof_1_5 | Mathlib.NumberTheory.MahlerMeasure | ∀ (n : ℕ) (p : Polynomial ℤ), p.natDegree ≤ n → (Polynomial.map (Int.castRingHom ℂ) p).natDegree ≤ n | false |
Set.Ioi_subset_Ioc_union_Ici | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, Set.Ioi a ⊆ Set.Ioc a b ∪ Set.Ici b | true |
_private.Init.Data.List.ToArray.0.Array.findSomeM?.match_1.eq_2 | Init.Data.List.ToArray | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (x : Option β) (h_1 : (b : β) → motive (some b))
(h_2 : (x : Option β) → motive x),
(∀ (b : β), x = some b → False) →
(match x with
| some b => h_1 b
| x => h_2 x) =
h_2 x | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Clause.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray._proof_1 | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {n : ℕ} (map : Std.HashMap (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) Bool)
(l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n), (l, true) ∉ map.toList ∨ (l, false) ∉ map.toList | false |
GrpCat.FilteredColimits.G.mk_eq | Mathlib.Algebra.Category.Grp.FilteredColimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.IsFiltered J]
(F : CategoryTheory.Functor J GrpCat) (x y : (j : J) × ↑(F.obj j)),
(∃ k f g,
(CategoryTheory.ConcreteCategory.hom (F.map f)) x.snd = (CategoryTheory.ConcreteCategory.hom (F.map g)) y.snd) →
GrpCat.FilteredColimi... | true |
WeakDual.CharacterSpace.equivAlgHom.congr_simp | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : CompleteSpace A]
[inst_3 : NormedAlgebra 𝕜 A], WeakDual.CharacterSpace.equivAlgHom = WeakDual.CharacterSpace.equivAlgHom | true |
CategoryTheory.Limits.parallelPair_initial_mk | Mathlib.CategoryTheory.Limits.Final.ParallelPair | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} (f g : X ⟶ Y),
(∀ (Z : C), Nonempty (X ⟶ Z)) →
(∀ ⦃Z : C⦄ (i j : X ⟶ Z),
∃ a, i = CategoryTheory.CategoryStruct.comp f a ∧ j = CategoryTheory.CategoryStruct.comp g a) →
(CategoryTheory.Limits.parallelPair f g).Initial | true |
IsCornerFree.image | Mathlib.Combinatorics.Additive.Corner.Defs | ∀ {G : Type u_1} {H : Type u_2} [inst : AddCommMonoid G] [inst_1 : AddCommMonoid H] {A : Set (G × G)} {s : Set G}
{t : Set H} {f : G → H}, IsAddFreimanIso 2 s t f → A ⊆ s ×ˢ s → IsCornerFree A → IsCornerFree (Prod.map f f '' A) | true |
PSigma.exists | Mathlib.Data.Sigma.Basic | ∀ {α : Sort u_1} {β : α → Sort u_2} {p : (a : α) ×' β a → Prop}, (∃ x, p x) ↔ ∃ a b, p ⟨a, b⟩ | true |
FractionalIdeal.dual_ne_zero | Mathlib.RingTheory.DedekindDomain.Different | ∀ (A : Type u_1) (K : Type u_2) {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L... | true |
Array.back?_flatMap | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Array β},
(Array.flatMap f xs).back? = Array.findSome? (fun a => (f a).back?) xs.reverse | true |
intervalIntegral.FTCFilter.mk._flat_ctor | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {a : outParam ℝ} {outer : Filter ℝ} {inner : outParam (Filter ℝ)},
Filter.Tendsto (fun p => Set.Ioc p.1 p.2) (outer ×ˢ outer) inner.smallSets →
pure a ≤ outer →
inner ≤ nhds a → ∀ [meas_gen : inner.IsMeasurablyGenerated], intervalIntegral.FTCFilter a outer inner | false |
CategoryTheory.Oplax.OplaxTrans.StrongCore.mk | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η : F ⟶ G} →
(naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.C... | true |
AddMagmaCat.coe_of | Mathlib.Algebra.Category.Semigrp.Basic | ∀ (M : Type u) [inst : Add M], ↑(AddMagmaCat.of M) = M | true |
CategoryTheory.LiftsToColimit.mk | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | true |
_private.Mathlib.Data.Set.Image.0.Set.image_preimage_eq_range_inter._proof_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_2} {β : Type u_1} {f : α → β} {t : Set β}, f '' (f ⁻¹' t) = Set.range f ∩ t | false |
_private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.tendsto_logb_atTop_of_base_lt_one._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
AddCommMonCat.coyonedaForget.eq_1 | Mathlib.Algebra.Category.MonCat.Yoneda | AddCommMonCat.coyonedaForget =
CategoryTheory.NatIso.ofComponents
(fun X =>
CategoryTheory.NatIso.ofComponents
(fun Y =>
{ hom := fun f => AddCommMonCat.ofHom f, inv := fun f => AddCommMonCat.Hom.hom f, hom_inv_id := ⋯,
inv_hom_id := ⋯ })
⋯)
@AddCommMonCat.coyonedaF... | true |
ContinuousOn.cfcₙ_fun | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {X : Type u_1} {R : Type u_2} {A : Type u_3} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R]
[inst_2 : MetricSpace R] [inst_3 : Nontrivial R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R]
[inst_6 : NonUnitalRing A] [inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module ... | true |
PNat.coprime_one._simp_1 | Mathlib.Data.PNat.Prime | ∀ {n : ℕ+}, n.Coprime 1 = True | false |
Function.partialInv_left | Mathlib.Logic.Function.Basic | ∀ {α : Type u_4} {β : Sort u_5} {f : α → β}, Function.Injective f → ∀ (x : α), Function.partialInv f (f x) = some x | true |
CategoryTheory.Join.mapPairComp_hom_app_right | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {E' : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} E'] {J : Type u₅} [inst_4 : CategoryTheory.Category.{v₅, u₅} J]
{K : Type u₆... | true |
Cardinal.mul_natCast_inj._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {n : ℕ} {a b : Cardinal.{u_1}}, n ≠ 0 → (a * ↑n = b * ↑n) = (a = b) | false |
MulActionHom.mk._flat_ctor | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{φ : M → N} →
{X : Type u_5} →
[inst : SMul M X] →
{Y : Type u_6} →
[inst_1 : SMul N Y] → (toFun : X → Y) → (∀ (m : M) (x : X), toFun (m • x) = φ m • toFun x) → X →ₑ[φ] Y | false |
Function.Injective.factorsThrough | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β},
Function.Injective f → ∀ (g : α → γ), Function.FactorsThrough g f | true |
AffineIsometryEquiv.coe_symm_toContinuousAffineEquiv | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : Pseudo... | true |
_private.Batteries.Tactic.Lint.Misc.0.Batteries.Tactic.Lint.univParamsGrouped._sparseCasesOn_1 | Batteries.Tactic.Lint.Misc | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 24 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Oplax.OplaxTrans.whiskerLeft_naturality_id | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{G H : CategoryTheory.OplaxFunctor B C} (θ : CategoryTheory.Oplax.OplaxTrans G H) {a : B} {a' : C} (f : a' ⟶ G.obj a),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (θ.natura... | true |
MeasureTheory.NullMeasurableSet._auto_1 | Mathlib.MeasureTheory.Measure.NullMeasurable | Lean.Syntax | false |
OrderMonoidWithZeroHom.coe_mk | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulZeroOneClass α]
[inst_3 : MulZeroOneClass β] (f : α →*₀ β) (h : Monotone (↑f).toFun),
⇑{ toMonoidWithZeroHom := f, monotone' := h } = ⇑f | true |
birkhoffSum_of_comp_eq | Mathlib.Dynamics.BirkhoffSum.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] {f : α → α} {φ : α → M},
φ ∘ f = φ → ∀ (n : ℕ), birkhoffSum f φ n = n • φ | true |
Laplacian.laplacian | Mathlib.Analysis.Distribution.DerivNotation | {E : Type v} → {F : outParam (Type w)} → [self : Laplacian E F] → E → F | true |
AddEquiv.toAdditive_toMultiplicative_symm_apply | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {G : Type u_2} [inst : AddZeroClass G] (a : G),
AddEquiv.toAdditive_toMultiplicative.symm a = Additive.ofMul (Multiplicative.ofAdd a) | true |
Pell.dnsq | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a), Zsqrtd.Nonsquare (Pell.d✝ a1) | true |
Lean.Lsp.CreateFile.mk.inj | Lean.Data.Lsp.Basic | ∀ {uri : Lean.Lsp.DocumentUri} {options? : Option Lean.Lsp.CreateFile.Options} {annotationId? : Option String}
{uri_1 : Lean.Lsp.DocumentUri} {options?_1 : Option Lean.Lsp.CreateFile.Options} {annotationId?_1 : Option String},
{ uri := uri, options? := options?, annotationId? := annotationId? } =
{ uri := uri... | true |
Set.fintypeAdd | Mathlib.Algebra.Group.Pointwise.Set.Finite | {α : Type u_2} → [inst : Add α] → [DecidableEq α] → (s t : Set α) → [Fintype ↑s] → [Fintype ↑t] → Fintype ↑(s + t) | true |
CategoryTheory.ObjectProperty.instSmallPair | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X Y : C),
CategoryTheory.ObjectProperty.Small.{w, v, u} (CategoryTheory.ObjectProperty.pair X Y) | true |
TopologicalAddGroup.IsSES.isOpenQuotientMap | Mathlib.Topology.Algebra.Group.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : AddGroup A] [inst_1 : AddGroup B] [inst_2 : AddGroup C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] {φ : A →+ B} {ψ : B →+ C},
TopologicalAddGroup.IsSES φ ψ → IsOpenQuotientMap ⇑ψ | true |
_aux_Init_Notation___unexpand_HAppend_hAppend_1 | Init.Notation | Lean.PrettyPrinter.Unexpander | false |
Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem | Mathlib.RingTheory.GradedAlgebra.Radical | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : CommRing A] [inst_1 : AddCommMonoid ι] [inst_2 : LinearOrder ι]
[IsOrderedCancelAddMonoid ι] [inst_4 : SetLike σ A] [inst_5 : AddSubmonoidClass σ A] {𝒜 : ι → σ}
[inst_6 : GradedRing 𝒜] {I : Ideal A},
Ideal.IsHomogeneous 𝒜 I →
I ≠ ⊤ →
(∀ {x y : A}... | true |
RingHom.StableUnderCompositionWithLocalizationAwayTarget.and | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
(RingHom.StableUnderCompositionWithLocalizationAwayTarget fun {R S} [CommRing R] [CommRing S] => P) →
(RingHom.StableUnderCompositionWithLocalizationAwayTarget fun {R S} [CommRing R] [CommRing S] => Q) →
RingHom.Stabl... | true |
Finset.EquitableOn.le_add_one | Mathlib.Data.Set.Equitable | ∀ {α : Type u_1} {s : Finset α} {f : α → ℕ} {a : α}, (↑s).EquitableOn f → a ∈ s → f a ≤ (∑ i ∈ s, f i) / s.card + 1 | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceFinHAddNatOfNatProdIntCoreE₂CohomologicalFin._proof_11 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r p : ℤ), p - r + r = p | false |
SimpleGraph.Walk.IsCycle.of_mapLe | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G G' : SimpleGraph V} (h : G ≤ G') {u : V} {p : G.Walk u u},
(SimpleGraph.Walk.mapLe h p).IsCycle → p.IsCycle | true |
Nat.lcm_mul_right_right | Init.Data.Nat.Lcm | ∀ (m n : ℕ), n.lcm (n * m) = n * m | true |
_private.Qq.Macro.0.Qq.Impl.unquoteExpr.match_5 | Qq.Macro | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((c : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const c us)) → ((x : Lean.Expr) → motive x) → motive x | false |
AddGroupExtension.Equiv.ofAddMonoidHom._proof_4 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_4} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup G] {E : Type u_2} [inst_2 : AddGroup E]
{S : AddGroupExtension N E G} {E' : Type u_1} [inst_3 : AddGroup E'] {S' : AddGroupExtension N E' G} (f : E →+ E'),
f.comp S.inl = S'.inl →
S'.rightHom.comp f = S.rightHom →
∀ (e' : E'),
... | false |
_private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.«term_∣[_]__1» | Mathlib.NumberTheory.ModularForms.SlashActions | Lean.TrailingParserDescr | true |
Int.two_dvd_ne_zero._simp_1 | Mathlib.Algebra.Group.Int.Even | ∀ {n : ℤ}, (¬2 ∣ n) = (n % 2 = 1) | false |
Int8.neg_one_or | Init.Data.SInt.Bitwise | ∀ {a : Int8}, -1 ||| a = -1 | true |
Real.arcsin_le_arcsin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x y : ℝ}, x ≤ y → Real.arcsin x ≤ Real.arcsin y | true |
CategoryTheory.shift_shiftFunctorCompIsoId_add_neg_cancel_hom_app | Mathlib.CategoryTheory.Shift.Basic | ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddGroup A]
[inst_2 : CategoryTheory.HasShift C A] (n : A) (X : C),
(CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorCompIsoId C n (-n) ⋯).hom.app X) =
(CategoryTheory.shiftFunctorCompIsoId C (-n) n ⋯).hom.app ((... | true |
Mathlib.Tactic.RingNF.RingMode.raw.elim | Mathlib.Tactic.Ring.RingNF | {motive : Mathlib.Tactic.RingNF.RingMode → Sort u} →
(t : Mathlib.Tactic.RingNF.RingMode) → t.ctorIdx = 1 → motive Mathlib.Tactic.RingNF.RingMode.raw → motive t | false |
Ideal.quotientMulEquivQuotientProd._proof_3 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : CommRing R] (I J : Ideal R), IsCoprime I J → I * J = I ⊓ J | false |
_private.Lean.Data.RBMap.0.Lean.RBNode.isSingleton._sparseCasesOn_1.else_eq | Lean.Data.RBMap | ∀ {α : Type u} {β : α → Type v} {motive : Lean.RBNode α β → Sort u_1} (t : Lean.RBNode α β)
(node :
(color : Lean.RBColor) →
(lchild : Lean.RBNode α β) →
(key : α) → (val : β key) → (rchild : Lean.RBNode α β) → motive (Lean.RBNode.node color lchild key val rchild))
(«else» : Nat.hasNotBit 2 t.ctor... | false |
_private.Lean.Elab.PreDefinition.Eqns.0.Lean.Elab.Eqns.simpEqnType.match_1 | Lean.Elab.PreDefinition.Eqns | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(__discr : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst : Lean.Expr) → (fvarId : Lean.FVarId) → (rhs : Lean.Expr) → motive (some (fst, Lean.Expr.fvar fvarId, rhs))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → mot... | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go_get | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w newWidth : ℕ} (aig : Std.Sat.AIG α) (input : aig.RefVec w)
(lo curr : ℕ) (hcurr : curr ≤ newWidth) (s : aig.RefVec curr) (idx : ℕ) (hidx1 : idx < newWidth),
curr ≤ idx →
(Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go input lo curr hcurr s).get i... | true |
BoundedContinuousFunction.probCharDual | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | {F : Type u_2} →
[inst : SeminormedAddCommGroup F] → [inst_1 : NormedSpace ℝ F] → StrongDual ℝ F → BoundedContinuousFunction F ℂ | true |
Real.hasSum_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.Series | ∀ (r : ℝ), HasSum (fun n => r ^ (2 * n + 1) / ↑(2 * n + 1).factorial) (Real.sinh r) | true |
CategoryTheory.IsIso.instUnmopOfMonoidalOpposite | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᴹᵒᵖ} (f : X ⟶ Y) [CategoryTheory.IsIso f],
CategoryTheory.IsIso f.unmop | true |
CommMonCat.coyonedaType._proof_2 | Mathlib.Algebra.Category.MonCat.Yoneda | ∀ (X : Type u_1ᵒᵖ) {X_1 Y Z : CommMonCat} (f : X_1 ⟶ Y) (g : Y ⟶ Z),
CommMonCat.ofHom
(Pi.monoidHom fun i =>
(CommMonCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g)).comp (Pi.evalMonoidHom (fun a => ↑X_1) i)) =
CategoryTheory.CategoryStruct.comp
(CommMonCat.ofHom (Pi.monoidHom fun i => (C... | false |
Batteries.RBNode.all._unsafe_rec | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → Bool) → Batteries.RBNode α → Bool | false |
MeasureTheory.Lp.indicatorConstLp_compMeasurePreserving._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.Indicator | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_2} [inst : MeasurableSpace β]
{μb : MeasureTheory.Measure β} {f : α → β} {s : Set β},
MeasurableSet s → μb s ≠ ⊤ → MeasureTheory.MeasurePreserving f μ μb → μ (f ⁻¹' s) ≠ ⊤ | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform.0.EisensteinSeries.δ._proof_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | (1 + 1).AtLeastTwo | false |
MeasureTheory.IsStoppingTime.measurableSet_ge | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι] {f : MeasureTheory.Filtration ι m}
{τ : Ω → WithTop ι} [inst_1 : TopologicalSpace ι] [OrderTopology ι] [FirstCountableTopology ι],
MeasureTheory.IsStoppingTime f τ → ∀ (i : ι), MeasurableSet {ω | ↑i ≤ τ ω} | true |
_private.Mathlib.Algebra.Polynomial.Div.0.Polynomial.sub_dvd_eval_sub._simp_1_1 | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} {a : R} [inst : CommRing R] {p : Polynomial R}, (Polynomial.X - Polynomial.C a ∣ p) = p.IsRoot a | false |
Mathlib.Tactic.withResetServerInfo.Result.mk.noConfusion | Mathlib.Tactic.Basic | {α : Type} →
{P : Sort u} →
{result? : Option α} →
{msgs : Lean.MessageLog} →
{trees : Lean.PersistentArray Lean.Elab.InfoTree} →
{result?' : Option α} →
{msgs' : Lean.MessageLog} →
{trees' : Lean.PersistentArray Lean.Elab.InfoTree} →
{ result? := ... | false |
ProfiniteAddGrp.instIsTopologicalAddGroupCarrierToTopTotallyDisconnectedSpacePtProfiniteLimitConeCompForget₂ContinuousAddMonoidHomToProfiniteContinuousMap | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max v u}),
IsTopologicalAddGroup
↑(Profinite.limitCone (F.comp (CategoryTheory.forget₂ ProfiniteAddGrp.{max u v} Profinite))).pt.toTop | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.