name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Fin.instCommRing._proof_11 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) [inst : NeZero n] (a : Fin n), 0 • a = 0 | null | false |
_private.Mathlib.Topology.Order.LiminfLimsup.0.tendsto_iSup_of_tendsto_limsup._simp_1_2 | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
_private.Init.Data.Nat.Sqrt.Lemmas.0.Nat.sqrt.iter_sq_le._proof_1_1 | Init.Data.Nat.Sqrt.Lemmas | ∀ (n guess : ℕ), ¬(guess + n / guess) / 2 < guess → (guess + n / guess) / 2 < guess → False | null | false |
CategoryTheory.Functor.LaxBraided.ofNatIso | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{D : Type u₂} →
[inst_3 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_4 : CategoryTheory.MonoidalCategory D] →
... | Given two lax monoidal, monoidally isomorphic functors, if one is lax braided, so is the other.
| true |
FormalMultilinearSeries.compContinuousLinearMap | Mathlib.Analysis.Calculus.FormalMultilinearSeries | {𝕜 : Type u} →
{E : Type v} →
{F : Type w} →
{G : Type x} →
[inst : Semiring 𝕜] →
[inst_1 : AddCommMonoid E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : ContinuousAdd E] →
[inst_5 : ContinuousConstSMul �... | Composing each term `pₙ` in a formal multilinear series with `(u, ..., u)` where `u` is a fixed
continuous linear map, gives a new formal multilinear series `p.compContinuousLinearMap u`. | true |
RingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J RingCat) →
[Small.{u, max u v} ↑(F.comp (CategoryTheory.forget RingCat)).sections] →
CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ RingCat SemiRingCat) | We show that the forgetful functor `CommRingCat ⥤ RingCat` creates limits.
All we need to do is notice that the limit point has a `Ring` instance available,
and then reuse the existing limit.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Beta.0.Complex.betaIntegral_symm._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Gamma.Beta | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ}
(a b : ℝ), -∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ) in b..a, f x ∂μ | null | false |
CStarAlgebra.mk | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
[toNormedRing : NormedRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedAlgebra : NormedAlgebra ℂ A] → [toStarModule : StarModule ℂ A] → CStarAlgebra A | null | true |
Nat.instConditionallyCompleteLinearOrderBot | Mathlib.Order.Lattice.Nat | ConditionallyCompleteLinearOrderBot ℕ | null | true |
Lean.TSyntax.instCoeNumLitPrec | Init.Meta.Defs | Coe Lean.NumLit Lean.Prec | null | true |
Pi.measurableMul | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {ι : Type u_5} {α : ι → Type u_6} [inst : (i : ι) → Mul (α i)] [inst_1 : (i : ι) → MeasurableSpace (α i)]
[∀ (i : ι), MeasurableMul (α i)], MeasurableMul ((i : ι) → α i) | null | true |
_private.Lean.Server.AsyncList.0.Lean.AsyncList.waitFind?.match_1 | Lean.Server.AsyncList | {α : Type u_2} →
{ε : Type u_1} →
(motive : Lean.AsyncList ε α → Sort u_3) →
(x : Lean.AsyncList ε α) →
(Unit → motive Lean.AsyncList.nil) →
((hd : α) → (tl : Lean.AsyncList ε α) → motive (Lean.AsyncList.cons hd tl)) →
((tl : Lean.Server.ServerTask (Except ε (Lean.AsyncList ε α... | null | false |
ZFClass.«_aux_Mathlib_SetTheory_ZFC_Class___macroRules_ZFClass_term⋃₀__1» | Mathlib.SetTheory.ZFC.Class | Lean.Macro | null | false |
FP.Float.nan | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → FP.Float | null | true |
_private.Mathlib.Tactic.LinearCombination.0.Mathlib.Tactic.LinearCombination.elabLinearCombination.match_3 | Mathlib.Tactic.LinearCombination | (motive : Option Lean.Term → Sort u_1) →
(input : Option Lean.Term) → (Unit → motive none) → ((e : Lean.Term) → motive (some e)) → motive input | null | false |
Array.any_eq_true' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α}, as.any p = true ↔ ∃ x ∈ as, p x = true | Variant of `any_eq_true` in terms of membership rather than an array index. | true |
ContinuousLinearMap.isInvertible_comp_equiv._simp_1 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Invertible | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} {M₃ : Type u_4} [inst : TopologicalSpace M]
[inst_1 : TopologicalSpace M₂] [inst_2 : TopologicalSpace M₃] [inst_3 : Semiring R] [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid M₂] [inst_7 : Module R M₂] [inst_8 : AddCommMonoid M₃]
[inst_9 : ... | null | false |
Aesop.Frontend.Feature.ctorElim | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.Feature → Sort u} →
(ctorIdx : ℕ) →
(t : Aesop.Frontend.Feature) → ctorIdx = t.ctorIdx → Aesop.Frontend.Feature.ctorElimType ctorIdx → motive t | null | false |
Set.prod_pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] (s : Set α) (t : Set β) (n : ℕ),
s ×ˢ t ^ n = (s ^ n) ×ˢ (t ^ n) | null | true |
_private.Mathlib.Data.List.Find.0.List.filter.match_1.eq_1 | Mathlib.Data.List.Find | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () | null | true |
Set.Finite.encard_lt_card | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, s.Finite → s ≠ Set.univ → s.encard < ENat.card α | null | true |
Std.Time.DateFormatSymbols.extendedDayPeriodLong | Std.Time.Format.DateFormat | Std.Time.DateFormatSymbols → Vector String 6 | Full extended-day-period strings for the `B` pattern.
Order: midnight, night, morning, noon, afternoon, evening.
| true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_mon_mul_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D]
(F : CategoryTheory.Functor C (CategoryTheory.CommMon D)) (X : C),
CategoryTheory.MonObj.mul.app X = Cate... | null | true |
_private.Mathlib.AlgebraicTopology.DoldKan.Degeneracies.0.AlgebraicTopology.DoldKan.DegeneraciesVanish.comp._simp_1_1 | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {n : ℕ} {T : C} (f : X.obj (Opposite.op { len := n + 1 }) ⟶ T),
AlgebraicTopology.DoldKan.DegeneraciesVanish f = ∀ (i : Fin (n + 1)), CategoryTheory.CategoryStruct.comp (X.σ... | null | false |
AddSubmonoid.fromLeftNeg_leftNegEquiv_symm | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : AddCommMonoid M] (S : AddSubmonoid M) (hS : S ≤ IsAddUnit.addSubmonoid M) (x : ↥S),
S.fromLeftNeg ((S.leftNegEquiv hS).symm x) = x | null | true |
AlgebraicGeometry.Scheme.instHasPullbacksPrecoverageOfHasPullbacks | Mathlib.AlgebraicGeometry.Sites.MorphismProperty | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) [P.HasPullbacks],
(AlgebraicGeometry.Scheme.precoverage P).HasPullbacks | null | true |
Lean.Elab.Tactic.MkSimpContextResult.rec | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.MkSimpContextResult → Sort u} →
((ctx : Lean.Meta.Simp.Context) →
(simprocs : Lean.Meta.Simp.SimprocsArray) →
(dischargeWrapper : Lean.Elab.Tactic.Simp.DischargeWrapper) →
(simpArgs : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)) →
motive { ct... | null | false |
_private.Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset.0.Finset.inv_op_smul_finset_distrib₀._simp_1_3 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : GroupWithZero α] [inst_2 : MulAction α β]
{s : Finset β} {a : α} {b : β}, a ≠ 0 → (b ∈ a • s) = (a⁻¹ • b ∈ s) | null | false |
CategoryTheory.Limits.Sigma.whiskerEquiv_hom | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u_1} {K : Type u_2} {f : J → C} {g : K → C}
(e : J ≃ K) (w : (j : J) → g (e j) ≅ f j) [inst_1 : CategoryTheory.Limits.HasCoproduct f]
[inst_2 : CategoryTheory.Limits.HasCoproduct g],
(CategoryTheory.Limits.Sigma.whiskerEquiv e w).hom = CategoryThe... | null | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_15 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → ℕ | null | false |
LinearMap.mulLeft._proof_2 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ (R : Type u_2) {A : Type u_1} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[SMulCommClass R A A] (a : A) (x : R) (y : A), a * x • y = x • (a * y) | null | false |
Std.Iter.toList_zip_of_finite_left | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ α₂ β₁ β₂ : Type u_1} [inst : Std.Iterator α₁ Id β₁] [inst_1 : Std.Iterator α₂ Id β₂] {it₁ : Std.Iter β₁}
{it₂ : Std.Iter β₂} [Std.Iterators.Finite α₁ Id] [Std.Iterators.Productive α₂ Id],
(it₁.zip it₂).toList = it₁.toList.zip (Std.Iter.take it₁.toList.length it₂).toList | null | true |
IsTopologicalGroup.mulInvClosureNhd.casesOn | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} →
[inst : TopologicalSpace G] →
{T W : Set G} →
[inst_1 : Group G] →
{motive : IsTopologicalGroup.mulInvClosureNhd T W → Sort u} →
(t : IsTopologicalGroup.mulInvClosureNhd T W) →
((nhds : T ∈ nhds 1) → (inv : T⁻¹ = T) → (isOpen : IsOpen T) → (mul : W * T ⊆ W) → m... | null | false |
SSet.Truncated.instMonoidalTruncation._aux_3 | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | (n : ℕ) →
(X Y : SSet) →
CategoryTheory.MonoidalCategoryStruct.tensorObj ((SSet.truncation n).obj X) ((SSet.truncation n).obj Y) ⟶
(SSet.truncation n).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | null | false |
Ordnode.insert'._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α | null | false |
_private.Mathlib.Algebra.SkewPolynomial.Basic.0.SkewPolynomial.monomial_eq_monomial_iff._simp_1_3 | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (a : G) (b : k),
SkewMonoidAlgebra.single a b = { coeff := fun₀ | a => b } | null | false |
CategoryTheory.Adjunction.right_triangle_components_assoc | 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} (self : F ⊣ G) (Y : D) {Z : C} (h : G.obj Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.unit.app (G.obj Y))
(CategoryTheo... | Equality of the composition of the unit and counit with the identity `G ⟶ GFG ⟶ G = 𝟙` | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.Shape.casesOn | Lean.Meta.MkIffOfInductiveProp | {motive : Lean.Meta.Shape✝ → Sort u} →
(t : Lean.Meta.Shape✝) →
((variablesKept : List Bool) → (neqs : Option ℕ) → motive { variablesKept := variablesKept, neqs := neqs }) →
motive t | null | false |
RingHom.FiniteType.of_surjective | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] (f : A →+* B),
Function.Surjective ⇑f → f.FiniteType | null | true |
Ring.DirectLimit.congr._proof_6 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i →+* G j} {G' : ι → Type u_3} [inst_2 : (i : ι) → CommRing (G' i)]
{f' : (i j : ι) → i ≤ j → G' i →+* G' j} (e : (i : ι) → G i ≃+* G' i),
(∀ (i j : ι) (h : i ≤ j), (e j).toRingHom.comp (f i j h)... | null | false |
CategoryTheory.MorphismProperty.Under.mapPushoutAdj._proof_7 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} [Q.IsStableUnderCobaseChange] (f : X ⟶ Y) [inst_3 : P.HasPushoutsAlong f],
Q f → ∀ (A : P.Under Q X), Q (CategoryTheory.Limits.pushout.inl A.hom f) | null | false |
RingQuot.ringQuotToIdealQuotient | Mathlib.Algebra.RingQuot | {B : Type uR} → [inst : CommRing B] → (r : B → B → Prop) → RingQuot r →+* B ⧸ Ideal.ofRel r | The universal ring homomorphism from `RingQuot r` to `B ⧸ Ideal.ofRel r`. | true |
Std.Format.noConfusion | Init.Data.Format.Basic | {P : Sort u} → {t t' : Std.Format} → t = t' → Std.Format.noConfusionType P t t' | null | false |
Rat.cast_lt_natCast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_2} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℚ} {n : ℕ}, (↑m < ↑n) = (m < ↑n) | null | false |
_private.Mathlib.Algebra.Lie.Basis.Base.0.LieAlgebra.exists_basis_of_base._simp_1_9 | Mathlib.Algebra.Lie.Basis.Base | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
List.maximum_of_length_pos_mem | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] {l : List α} (h : 0 < l.length), List.maximum_of_length_pos h ∈ l | null | true |
Lean.Json.below | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
{motive_2 : Array Lean.Json → Sort u} →
{motive_3 : Std.TreeMap.Raw String Lean.Json compare → Sort u} →
{motive_4 : List Lean.Json → Sort u} →
{motive_5 : Std.DTreeMap.Raw String (fun x => Lean.Json) compare → Sort u} →
{motive_6 : (Std.DTreeMap.Internal.... | null | false |
CategoryTheory.AddMon.uniqueHomToTrivial | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | {D : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D] →
(A : CategoryTheory.AddMon D) → Unique (A ⟶ CategoryTheory.AddMon.trivial D) | null | true |
NonUnitalSubalgebra.center.instNonUnitalCommRing._proof_13 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : NonUnitalNonAssocRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (a b c : ↥(NonUnitalSubalgebra.center R A)),
a * (b + c) = a * b + a * c | null | false |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_eq_of_equiv | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0),
f ≈ g → padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑g (PadicSeq.stationaryPoint hg)) | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform_map_whiskerRight | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | null | true |
Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn.eq | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | ∀ {motive : Mathlib.Tactic.BicategoryLike.NormalExpr → Sort u} (t : Mathlib.Tactic.BicategoryLike.NormalExpr)
(F_1 : (t : Mathlib.Tactic.BicategoryLike.NormalExpr) → Mathlib.Tactic.BicategoryLike.NormalExpr.below t → motive t),
Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn t F_1 =
F_1 t (Mathlib.Tactic.Bicate... | null | true |
_private.Mathlib.Order.Hom.Set.0.StrictMono.eq_of_range_eq._proof_1_1 | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : Preorder β] [Subsingleton (α ≃o α)] {f g : α → β}
(hf : StrictMono f) (hg : StrictMono g),
Set.range f = Set.range g →
Set.range ⇑(OrderEmbedding.ofStrictMono f hf) = Set.range f →
Set.range ⇑(OrderEmbedding.ofStrictMono g hg) = Set.range g ... | null | false |
Function.locallyFinsuppWithin.closedSupport | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [T1Space X] [inst_2 : Zero Y]
(D : Function.locallyFinsuppWithin U Y), IsClosed U → IsClosed D.support | If `X` is T1 and if `U` is closed, then the support of support of a function with locally finite
support within `U` is also closed.
| true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.withExporting._regBuiltin.Lean.Parser.Command.withExporting.formatter_7 | Lean.Parser.Command | IO Unit | null | false |
Lean.StructureResolutionState.ctorIdx | Lean.Structure | Lean.StructureResolutionState → ℕ | null | false |
CategoryTheory.CostructuredArrow.mk_hom_eq_self | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {Y : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T), (CategoryTheory.CostructuredArrow.mk f).hom = f | null | true |
SubNegMonoid.sub._default | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} →
(zero : G) →
(add : G → G → G) →
(∀ (a b c : G), a + b + c = a + (b + c)) →
(∀ (a : G), 0 + a = a) →
(∀ (a : G), a + 0 = a) →
(nsmul : ℕ → G → G) →
(∀ (x : G), 0 • x = 0) → (∀ (n : ℕ) (x : G), (n + 1) • x = n • x + x) → (G → G) → G → G → G | null | false |
sub_eq_add_zero_sub | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : SubNegMonoid G] (a b : G), a - b = a + (0 - b) | null | true |
DiffeologicalSpace.mkOfClosure._proof_1 | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} (g : Set ((n : ℕ) × (EuclideanSpace ℝ (Fin n) → X))) {u : Set X},
TopologicalSpace.IsOpen u ↔ ∀ {n : ℕ}, ∀ p ∈ {p | ⟨n, p⟩ ∈ g}, IsOpen (p ⁻¹' u) | null | false |
DiscreteQuotient.comp_finsetClopens.match_1 | Mathlib.Topology.DiscreteQuotient | (X : Type u_1) →
[inst : TopologicalSpace X] →
(motive : DiscreteQuotient X → Sort u_2) →
(x : DiscreteQuotient X) →
((f : Setoid X) →
(isOpen_setOfPred_rel : ∀ (x : X), IsOpen (Set.ofPred (f x))) →
motive { toSetoid := f, isOpen_setOfPred_rel := isOpen_setOfPred_rel }) →
... | null | false |
iSupIndep.comp' | Mathlib.Order.SupIndep | ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Sort u_5} {ι' : Sort u_6} {t : ι → α} {f : ι' → ι},
iSupIndep (t ∘ f) → Function.Surjective f → iSupIndep t | null | true |
PrimeSpectrum.isIrreducible_iff_vanishingIdeal_isPrime | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] {s : Set (PrimeSpectrum R)},
IsIrreducible s ↔ (PrimeSpectrum.vanishingIdeal s).IsPrime | null | true |
bddAbove_preimage_toDual | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set αᵒᵈ}, BddAbove (⇑OrderDual.toDual ⁻¹' s) ↔ BddBelow s | null | true |
ENNReal.le_of_forall_nnreal_lt | Mathlib.Basic.ENNReal.Inv | ∀ {x y : ENNReal}, (∀ (r : NNReal), ↑r < x → ↑r ≤ y) → x ≤ y | null | true |
_private.Mathlib.Basic.Real.Basic.0.Real.mul | Mathlib.Basic.Real.Basic | ℝ → ℝ → ℝ | null | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.ringEquivOfRingEquiv_spanSingleton._simp_1_3 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y : M},
(x ∈ R ∙ y) = ∃ a, a • y = x | null | false |
CategoryTheory.FreeBicategory.Hom.ctorElimType | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{motive : (a a_1 : B) → CategoryTheory.FreeBicategory.Hom a a_1 → Sort u_1} →
ℕ →
Sort
(max 1 (imax (u + 1) u_1) (imax (u + 1) (u + 1) (u + 1) (max (u + 1) (v + 1)) (max (u + 1) (v + 1)) u_1)
(imax (u + 1) (u + 1) (v + 1) u_1)) | null | false |
LieIdeal.coe_toLieSubalgebra | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
↑(↑R L I) = ↑I | null | true |
instAssociativeUInt64HXor | Init.Data.UInt.Bitwise | Std.Associative fun x1 x2 => x1 ^^^ x2 | null | true |
TopCat.instNegHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier | Mathlib.Topology.Sheaves.CommRingCat | (X : TopCat) → (R : TopCommRingCat) → Neg (X ⟶ (CategoryTheory.forget₂ TopCommRingCat TopCat).obj R) | null | true |
_private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.mem_triangleIndices._simp_1 | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : CommRing α] {s : Finset α} {x : α × α × α},
(x ∈ triangleIndices✝ s) = ∃ y, ∃ a ∈ s, (y, y + a, y + 2 * a) = x | null | false |
Lean.Meta.Grind.Context | Lean.Meta.Tactic.Grind.Types | Type | Context for `GrindM` monad. | true |
Std.DHashMap.Internal.Raw.getKey?_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} (h : m.WF) {a : α},
m.getKey? a = Std.DHashMap.Internal.Raw₀.getKey? ⟨m, ⋯⟩ a | null | true |
_private.Mathlib.Algebra.Module.LocalizedModule.Submodule.0.IsLocalizedModule.toLocalizedQuotient'._simp_1 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{S : Type u_3} [inst_3 : SMul S R] [inst_4 : SMul S M] [inst_5 : IsScalarTower S R M] (r : S) (x : M),
r • Submodule.Quotient.mk x = Submodule.Quotient.mk (r • x) | null | false |
_private.Init.Data.String.Basic.0.String.Pos.Raw.utf8GetAux.match_1.splitter | Init.Data.String.Basic | (motive : List Char → String.Pos.Raw → String.Pos.Raw → Sort u_1) →
(x : List Char) →
(x_1 x_2 : String.Pos.Raw) →
((x x_3 : String.Pos.Raw) → motive [] x x_3) →
((c : Char) → (cs : List Char) → (i p : String.Pos.Raw) → motive (c :: cs) i p) → motive x x_1 x_2 | null | true |
gcdMonoidOfGCD._proof_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : DecidableEq α] (gcd : α → α → α)
(gcd_dvd_left : ∀ (a b : α), gcd a b ∣ a) (a b : α),
Associated (gcd a b * if a = 0 then 0 else Classical.choose ⋯) (a * b) | null | false |
Lean.Meta.Command.ReduceConfig.rec | Init.MetaTypes | {motive : Lean.Meta.Command.ReduceConfig → Sort u} →
((types proofs implicits : Bool) →
(transparency : Lean.Meta.TransparencyMode) →
(smartUnfolding check ignoreStuckTC : Bool) →
motive
{ types := types, proofs := proofs, implicits := implicits, transparency := transparency,
... | null | false |
ConvexCone.pointed_positive | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : PartialOrder M] [inst_4 : IsOrderedAddMonoid M] [inst_5 : Module R M] [inst_6 : PosSMulMono R M],
(ConvexCone.positive R M).Pointed | The positive cone of an ordered module is always pointed. | true |
_private.Lean.Meta.Tactic.Simp.Simproc.0.Lean.Meta.Simp.getSimprocFromDeclImpl.match_6 | Lean.Meta.Tactic.Simp.Simproc | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) → (Unit → motive none) → ((info : Lean.ConstantInfo) → motive (some info)) → motive x | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.le_min_iff._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α},
(cmp a b = Ordering.gt) = (cmp b a = Ordering.lt) | null | false |
ModuleCat.biprodIsoProd_inv_comp_snd_apply | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u} [inst : Ring R] (M N : ModuleCat R) (x : ↑M × ↑N),
(CategoryTheory.ConcreteCategory.hom CategoryTheory.Limits.biprod.snd)
((CategoryTheory.ConcreteCategory.hom (M.biprodIsoProd N).inv) x) =
x.2 | null | true |
Std.Http.URI.instInhabitedQuery | Std.Http.Data.URI.Basic | Inhabited Std.Http.URI.Query | null | true |
BitVec.reduceHShiftLeft | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | Simplification procedure for shift left on `BitVec`. | true |
LocallyLipschitz.const_min | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : α → ℝ},
LocallyLipschitz f → ∀ (a : ℝ), LocallyLipschitz fun x => min a (f x) | null | true |
Lean.Elab.liftMacroM | Lean.Elab.Util | {m : Type → Type} →
{α : Type} →
[Monad m] →
[Lean.Elab.MonadMacroAdapter m] →
[Lean.MonadEnv m] →
[Lean.MonadRecDepth m] →
[Lean.MonadError m] →
[Lean.MonadResolveName m] →
[Lean.MonadTrace m] →
[Lean.MonadOptions m] → [Lean.AddM... | null | true |
CategoryTheory.Pseudofunctor.hasCoeToLax | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → Coe (CategoryTheory.Pseudofunctor B C) (CategoryTheory.LaxFunctor B C) | null | true |
_private.Mathlib.Analysis.RCLike.Basic.0.RCLike.norm_I._proof_1_1 | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], ‖RCLike.I‖ = if RCLike.I = 0 then 0 else 1 | null | false |
_private.Init.Internal.Order.Basic.0.Lean.Order.admissible_pprod_snd.match_1_1 | Init.Internal.Order.Basic | ∀ {α : Sort u_1} {β : Sort u_2} [inst : Lean.Order.CCPO α] [inst_1 : Lean.Order.CCPO β] (c : α ×' β → Prop) (y : β)
(motive : Lean.Order.PProd.chain.snd c y → Prop) (h : Lean.Order.PProd.chain.snd c y),
(∀ (x : α) (hxy : c ⟨x, y⟩), motive ⋯) → motive h | null | false |
_private.Init.Data.Vector.Basic.0.Vector.mapM._proof_2 | Init.Data.Vector.Basic | ∀ {n : ℕ}, ∀ k ≤ n, ¬k < n → ¬k = n → False | null | false |
toIcoMod_intCast_mul_add' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℤ), toIcoMod hp (↑m * p + a) b = ↑m * p + toIcoMod hp a b | null | true |
ProbabilityTheory.HasLaw.ae_eq_of_smul_dirac | Mathlib.Probability.HasLaw | ∀ {Ω : Type u_1} {𝓧 : Type u_2} {mΩ : MeasurableSpace Ω} {m𝓧 : MeasurableSpace 𝓧} {X : Ω → 𝓧}
{P : MeasureTheory.Measure Ω} {c : ENNReal} [MeasurableSingletonClass 𝓧] {x : 𝓧},
ProbabilityTheory.HasLaw X (c • MeasureTheory.Measure.dirac x) P → X =ᵐ[P] fun x_1 => x | null | true |
TensorProduct.AlgebraTensorModule.map._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {A : Type u_2} {P : Type u_4} {Q : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid P] [inst_4 : Module R P] [inst_5 : Module A P]
[inst_6 : IsScalarTower R A P] [inst_7 : AddCommMonoid Q] [inst_8 : Module R Q],
SMulCommClass R A (TensorProduc... | null | false |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.isLongestRevMatch_iff_isLongestRevMatchAt_ofSliceTo._simp_1_2 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {base : s.Pos}
{startPos endPos : (s.sliceTo base).Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt pat startPos endPos =
String.Slice.Pattern.Model.IsLongestRevMatchAt pat (String.Slice.Pos.ofSliceTo startPos)
... | null | false |
addConGen._proof_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (r : M → M → Prop), Equivalence (AddConGen.Rel r) | null | false |
_private.Mathlib.Algebra.Ring.Periodic.0.Function.Antiperiodic.int_mul_eq_of_eq_zero.match_1_1 | Mathlib.Algebra.Ring.Periodic | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | null | false |
sub_add_sub_cancel | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] (a b c : G), a - b + (b - c) = a - c | null | true |
_private.Mathlib.Data.List.Pairwise.0.List.pairwise_iff_forall_infix._proof_1_45 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {l : List α} (l' : List α),
1 < l'.length → l' <:+: l → ∀ (l₁ l₂ : List α), l₁ ++ l' ++ l₂ = l → l'.length - 1 < (l₁ ++ (l' ++ l₂)).length | null | false |
Lean.Compiler.LCNF.ExtractClosed.M | Lean.Compiler.LCNF.ExtractClosed | Type → Type | null | true |
Inclusion.IVar.expr | Mathlib.Tactic.Inclusion.Core.Types | Inclusion.IVar → Lean.Expr | The associated expression of an `IVar`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.