name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
FirstOrder.Language.BoundedFormula.imp.elim | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : (a : ℕ) → L.BoundedFormula α a → Sort u_1} →
{a : ℕ} →
(t : L.BoundedFormula α a) →
t.ctorIdx = 3 → ({n : ℕ} → (f₁ f₂ : L.BoundedFormula α n) → motive n (f₁.imp f₂)) → motive a t | false |
Int8.toInt16_le | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, a.toInt16 ≤ b.toInt16 ↔ a ≤ b | true |
SheafOfModules.pushforwardNatTrans | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : CategoryTheory.GrothendieckTopology C} →
{K : CategoryTheory.GrothendieckTopology D} →
{F G : CategoryTheory.Functor C D} →
{T : Cate... | true |
MonoidWithZeroHom.valueGroup.mk_mul._proof_1 | Mathlib.Algebra.GroupWithZero.Range | ∀ {A : Type u_3} {B : Type u_1} {F : Type u_2} [inst : FunLike F A B] (f : F) [inst_1 : MonoidWithZero A]
[inst_2 : CommGroupWithZero B] [MonoidWithZeroHomClass F A B] {r₁ r₂ : A} {hr₁ : f r₁ ≠ 0} {hr₂ : f r₂ ≠ 0},
f (r₁ * r₂) ≠ 0 | false |
_private.Mathlib.Geometry.Euclidean.Triangle.0.EuclideanGeometry.dist_lt_of_angle_lt._simp_1_2 | Mathlib.Geometry.Euclidean.Triangle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (p₁ p₂ p₃ : P), (EuclideanGeometry.angle p₁ p₂ p₃ ≤ Real.pi) = True | false |
_private.Mathlib.Algebra.Order.Monoid.Canonical.Defs.0.le_iff_exists_mul'._simp_1_1 | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {α : Type u} [inst : Mul α] [inst_1 : LE α] [CanonicallyOrderedMul α] {a b : α}, (a ≤ b) = ∃ c, b = a * c | false |
CategoryTheory.Functor.WellOrderInductionData.Extension.limit._proof_7 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_2} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_1)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} [inst_3 : WellFoundedLT J] (j : J)
(hj : Order.IsSuccLimit j) (e : (i : J) → i < j → d.Extension val₀ i) (i : J) (hi : Order.... | false |
CategoryTheory.IsGrothendieckAbelian.monoMapFactorizationDataRlp.congr_simp | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.IsGrothendieckAbelian.monoMapFactorizationDataRlp f =
CategoryTheory.IsGrothendieckAbelian.monoMapFactorizationDataRlp f | true |
Seminorm.closedBall_finset_sup_eq_iInter | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} {ι : Type u_11} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) {r : ℝ},
0 ≤ r → (s.sup p).closedBall x r = ⋂ i ∈ s, (p i).closedBall x r | true |
AddTorsor.subsingleton_iff | Mathlib.Algebra.AddTorsor.Defs | ∀ (G : Type u_1) (P : Type u_2) [inst : AddGroup G] [AddTorsor G P], Subsingleton G ↔ Subsingleton P | true |
alternatingGroup.nontrivial_of_three_le_card | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α], 3 ≤ Fintype.card α → Nontrivial ↥(alternatingGroup α) | true |
Ideal.isRadical_iInf | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {ι : Sort u_2} (I : ι → Ideal R),
(∀ (i : ι), (I i).IsRadical) → (⨅ i, I i).IsRadical | true |
_private.Mathlib.Algebra.Order.Module.Defs.0.Pi.instPosSMulStrictMono._simp_1 | Mathlib.Algebra.Order.Module.Defs | ∀ {ι : Type u_1} {π : ι → Type u_4} [inst : (i : ι) → Preorder (π i)] {x y : (i : ι) → π i},
(x < y) = (x ≤ y ∧ ∃ i, x i < y i) | false |
Lean.Compiler.LCNF.CollectLevelParams.visitCode | Lean.Compiler.LCNF.Level | Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → Lean.CollectLevelParams.Visitor | true |
Lean.Meta.Config.proofIrrelevance._default | Lean.Meta.Basic | Bool | false |
Lean.arrow_true_congr | Init.SimpLemmas | ∀ (α : Sort u) (p : Prop), p = True → Lean.Arrow α p = True | true |
ProofWidgets.instFromJsonRpcEncodablePacket.fromJson._@.ProofWidgets.Presentation.Expr.2220529756._hygCtx._hyg.10 | ProofWidgets.Presentation.Expr | Lean.Json → Except String ProofWidgets.RpcEncodablePacket✝ | false |
Submonoid.mulAction | Mathlib.Algebra.Group.Submonoid.MulAction | {M' : Type u_1} → {α : Type u_2} → [inst : Monoid M'] → [MulAction M' α] → (S : Submonoid M') → MulAction (↥S) α | true |
Std.Time.OffsetO.recOn | Std.Time.Format.Basic | {motive : Std.Time.OffsetO → Sort u} →
(t : Std.Time.OffsetO) → motive Std.Time.OffsetO.short → motive Std.Time.OffsetO.full → motive t | false |
CategoryTheory.Limits.pullbackDiagonalMapIso.hom._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] {U : C}
(f : X ⟶ Y) (i : U ⟶ Y), CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.cospan f i) | false |
Equiv.Perm.prod_Ioi_comp_eq_sign_mul_prod | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} {R : Type u_1} [inst : CommRing R] (σ : Equiv.Perm (Fin n)) {f : Fin n → Fin n → R},
(∀ (i j : Fin n), f i j = -f j i) →
∏ i, ∏ j ∈ Finset.Ioi i, f (σ i) (σ j) = ↑↑(Equiv.Perm.sign σ) * ∏ i, ∏ j ∈ Finset.Ioi i, f i j | true |
Aesop.Options'.mk._flat_ctor | Aesop.Options.Internal | Aesop.Strategy →
ℕ →
ℕ →
ℕ →
ℕ →
ℕ →
Lean.Meta.TransparencyMode →
Lean.Meta.TransparencyMode →
Lean.Meta.TransparencyMode →
Option Lean.Meta.TransparencyMode →
Bool → Bool → Bool → Bool → Bool → Bool → Bool → B... | false |
Submodule.fg_iff_compact | Mathlib.RingTheory.Finiteness.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(s : Submodule R M), s.FG ↔ IsCompactElement s | true |
Matrix.finite_spectrum | Mathlib.LinearAlgebra.Eigenspace.Minpoly | ∀ {n : Type u_1} {R : Type u_2} [inst : Field R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] (A : Matrix n n R),
(spectrum R A).Finite | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_diff_iff._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Std.HashSet.mem_toList | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [LawfulBEq α] {k : α}, k ∈ m.toList ↔ k ∈ m | true |
CauSeq.pos_add_limZero | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {f g : CauSeq α abs},
f.Pos → g.LimZero → (f + g).Pos | true |
CategoryTheory.Abelian.SpectralObject.H_map_twoδ₂Toδ₁_toCycles_assoc | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | true |
Lean.Language.Lean.CommandParsedSnapshot.isFatal._inherited_default | Lean.Language.Lean.Types | Bool | false |
instFiniteCuspOrbitsOfIsArithmetic | Mathlib.NumberTheory.ModularForms.Cusps | ∀ (𝒢 : Subgroup (GL (Fin 2) ℝ)) [𝒢.IsArithmetic], Finite (CuspOrbits 𝒢) | true |
instRingFreeRing._proof_12 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1) (a b : FreeRing α), a + b = b + a | false |
SeminormedAddGroup | Mathlib.Analysis.Normed.Group.Defs | Type u_8 → Type u_8 | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.sign_ediv._simp_1_7 | Init.Data.Int.DivMod.Lemmas | ∀ {k n m : ℕ}, (n + k < m + k) = (n < m) | false |
_private.Mathlib.Analysis.Calculus.SmoothSeries.0.summable_of_summable_hasDerivAt_of_isPreconnected._simp_1_1 | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[inst_3 : TopologicalSpace F] {f : 𝕜 → F} {x : 𝕜} [inst_4 : ContinuousSMul 𝕜 F] {f' : F},
HasDerivAt f f' x = HasFDerivAt f (ContinuousLinearMap.toSpanSingleton 𝕜 f') x | false |
ArchimedeanClass.mem_ball_iff | 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] [inst_5 : IsOrderedRing K] [inst_6 : Archimedean K] [inst_7 : Module K M]
[inst_8 : PosSMulMono K M] {a : M} {c : ArchimedeanClass M},
c ≠ ⊤ → (a ∈ Archimedea... | true |
Lean.Compiler.LCNF.Simp.Config.mk.sizeOf_spec | Lean.Compiler.LCNF.Simp.Config | ∀ (etaPoly inlinePartial implementedBy inlineDefs : Bool),
sizeOf
{ etaPoly := etaPoly, inlinePartial := inlinePartial, implementedBy := implementedBy, inlineDefs := inlineDefs } =
1 + sizeOf etaPoly + sizeOf inlinePartial + sizeOf implementedBy + sizeOf inlineDefs | true |
_private.Mathlib.RingTheory.PowerBasis.0.PowerBasis.mem_span_pow'._simp_1_10 | Mathlib.RingTheory.PowerBasis | ∀ {R : Type u} [inst : Semiring R] (f : Polynomial R) (n : ℕ), (f.degree < ↑n) = ∀ (m : ℕ), n ≤ m → f.coeff m = 0 | false |
String.Slice.RevSplitIterator.instIteratorOfPure._proof_5 | Init.Data.String.Slice | ∀ {ρ : Type} {ρ_1 : ρ} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)]
[inst_1 : String.Slice.Pattern.ToBackwardSearcher ρ_1 σ] {m : Type → Type u_1} {s : String.Slice} (currPos : s.Pos)
(searcher searcher' : Std.Iter (String.Slice.Pattern.SearchSt... | false |
CStarRing.mul_star_self_eq_zero_iff._simp_1 | Mathlib.Analysis.CStarAlgebra.Basic | ∀ {E : Type u_2} [inst : NonUnitalNormedRing E] [inst_1 : StarRing E] [CStarRing E] (x : E), (x * star x = 0) = (x = 0) | false |
List.zipRight' | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → List α → List β → List (Option α × β) × List α | true |
Aesop.UnsafeQueueEntry.ctorElim | Aesop.Tree.UnsafeQueue | {motive : Aesop.UnsafeQueueEntry → Sort u} →
(ctorIdx : ℕ) →
(t : Aesop.UnsafeQueueEntry) → ctorIdx = t.ctorIdx → Aesop.UnsafeQueueEntry.ctorElimType ctorIdx → motive t | false |
CategoryTheory.AddGrp.instMonoidalCategory._proof_7 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y : CategoryTheory.AddGrp C),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.CategoryStruct.id Y) =
CategoryTheory.CategoryStru... | false |
Interval.boundedOrder._aux_1 | Mathlib.Order.Interval.Basic | {α : Type u_1} → [inst : Preorder α] → [BoundedOrder α] → Interval α | false |
Option.toList_pmap | Init.Data.Option.Attach | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {o : Option α} {f : (a : α) → p a → β} (h : ∀ (a : α), o = some a → p a),
(Option.pmap f o h).toList = List.map (fun x => f ↑x ⋯) o.attach.toList | true |
Ideal.quotientEquivPiZMod._proof_1 | Mathlib.LinearAlgebra.FreeModule.IdealQuotient | ∀ {S : Type u_1} [inst : CommRing S], IsScalarTower ℤ S S | false |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.Seq.superposeAC?.mkResult.match_1 | Lean.Meta.Tactic.Grind.AC.Seq | (motive : Option Lean.Grind.AC.Seq → Option Lean.Grind.AC.Seq → Option Lean.Grind.AC.Seq → Sort u_1) →
(r₁ c r₂ : Option Lean.Grind.AC.Seq) →
((r₁ c r₂ : Lean.Grind.AC.Seq) → motive (some r₁) (some c) (some r₂)) →
((x x_1 x_2 : Option Lean.Grind.AC.Seq) → motive x x_1 x_2) → motive r₁ c r₂ | false |
Con.mkMulHom._proof_1 | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : Mul M] (c : Con M) (x x_1 : M), ↑(x * x_1) = ↑(x * x_1) | false |
IsIntegralClosure.mk'_one | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} (A : Type u_2) {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] (h : optParam (IsIntegral R 1) ⋯),
IsIntegralClosure.mk' A 1 h = 1 | true |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj._proof_10 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C (CategoryTheory.Comon D)),
CategoryTheory.CategoryStruct.comp { app := fun X => CategoryTheory.ComonObj.comul, na... | false |
OmegaCompletePartialOrder.lift | Mathlib.Order.OmegaCompletePartialOrder | {α : Type u_2} →
{β : Type u_3} →
[inst : OmegaCompletePartialOrder α] →
[inst_1 : PartialOrder β] →
(f : β →o α) →
(ωSup₀ : OmegaCompletePartialOrder.Chain β → β) →
(∀ (x y : β), f x ≤ f y → x ≤ y) →
(∀ (c : OmegaCompletePartialOrder.Chain β), f (ωSup₀ c) = Omega... | true |
Lean.Grind.CommRing.Poly.combineC._unary._proof_2 | Init.Grind.Ring.CommSolver | ∀ (k₁ : ℤ) (m₁ : Lean.Grind.CommRing.Mon) (p₁ : Lean.Grind.CommRing.Poly) (k₂ : ℤ) (m₂ : Lean.Grind.CommRing.Mon)
(p₂ : Lean.Grind.CommRing.Poly),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun p₁ p₂ => sizeOf p₁ + sizeOf p₂)
⟨p₁, Lean.Grind.CommRing.Poly.add k₂ m₂ p₂⟩
⟨Lean.Grind.CommRing.P... | false |
FirstOrder.Language.BoundedFormula.ctorIdx | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → {a : ℕ} → L.BoundedFormula α a → ℕ | false |
SimpleGraph.Subgraph.copy._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G' : G.Subgraph) (V'' : Set V),
V'' = G'.verts → ∀ (adj' : V → V → Prop), adj' = G'.Adj → ∀ {v w : V}, adj' v w → v ∈ V'' | false |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.ValidFor.hasNext.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l r : List Char} (motive : (x : String.Legacy.Iterator) → String.Legacy.Iterator.ValidFor l r x → Prop)
(x : String.Legacy.Iterator) (x_1 : String.Legacy.Iterator.ValidFor l r x),
(∀ (it : String.Legacy.Iterator) (h : String.Legacy.Iterator.ValidFor l r it), motive it h) → motive x x_1 | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.State.mk.sizeOf_spec | Lean.Compiler.LCNF.ExplicitRC | ∀ (liveVars : Lean.Compiler.LCNF.LiveVars✝), sizeOf { liveVars := liveVars } = 1 + sizeOf liveVars | true |
Lean.Meta.Sym.ProofInstInfo.casesOn | Lean.Meta.Sym.SymM | {motive : Lean.Meta.Sym.ProofInstInfo → Sort u} →
(t : Lean.Meta.Sym.ProofInstInfo) →
((argsInfo : Array Lean.Meta.Sym.ProofInstArgInfo) → motive { argsInfo := argsInfo }) → motive t | false |
CategoryTheory.MorphismProperty.Comma.homFromCommaOfIsIso | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
{L : CategoryTheory.Functor A T} →
{R : CategoryTheory.Functor B ... | true |
IntermediateField.adjoin_simple_le_iff | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {α : E}
{K : IntermediateField F E}, F⟮α⟯ ≤ K ↔ α ∈ K | true |
Std.DTreeMap.Internal.Impl.Const.equiv_iff_toList_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t₁.WF →
t₂.WF → (t₁.Equiv t₂ ↔ Std.DTreeMap.Internal.Impl.Const.toList t₁ = Std.DTreeMap.Internal.Impl.Const.toList t₂) | true |
Real.instInhabitedAngle | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | Inhabited Real.Angle | true |
CategoryTheory.Localization.liftNatIso_inv | Mathlib.CategoryTheory.Localization.Predicate | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) {E : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : L.IsLocalization W] (F₁ F₂ : CategoryTheor... | true |
_private.Lean.Environment.0.Lean.Environment.setMainModule.unsafe_1 | Lean.Environment | Lean.Environment → NonScalar | true |
Finsupp.lapply_apply | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : α) (f : α →₀ M), (Finsupp.lapply a) f = f a | true |
IO.FS.instInhabitedStream.default | Init.System.IO | IO.FS.Stream | true |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_16 | Mathlib.RingTheory.Nilpotent.Exp | ∀ (n₁ n₂ x y : ℕ), x + y ≤ 2 * max n₁ n₂ → (x + y < 2 * max n₁ n₂ + 1 ∧ x < x + y + 1) ∧ x = x ∧ x + y - x = y | false |
AddMonoid.FG.mk._flat_ctor | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_3} [inst : AddMonoid M], ⊤.FG → AddMonoid.FG M | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.updateCell._proof_12 | Std.Data.DTreeMap.Internal.Model | ¬0 ≤ 0 + 1 → False | false |
CategoryTheory.AB4OfSize.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasCoproducts C] →
{motive : CategoryTheory.AB4OfSize.{w, v, u} C → Sort u_1} →
((ofShape : ∀ (α : Type w), CategoryTheory.HasExactColimitsOfShape (CategoryTheory.Discrete α) C) → motive ⋯) →
(t : Ca... | false |
TopModuleCat.instEpiCokerπ | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | ∀ {R : Type u} [inst : Ring R] [inst_1 : TopologicalSpace R] {M N : TopModuleCat R} (φ : M ⟶ N),
CategoryTheory.Epi (TopModuleCat.cokerπ φ) | true |
HomologicalComplex.instAddCommGroupHom._proof_6 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {V : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} (x : C ⟶ D) (n : ℤ), (n • x).f = n • x.f | false |
Finset.mul_sum | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),
a * ∑ i ∈ s, f i = ∑ i ∈ s, a * f i | true |
TendstoUniformlyOn.inv | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : Group α] [IsUniformGroup α] {ι : Type u_3}
{l : Filter ι} {f : ι → β → α} {g : β → α} {s : Set β}, TendstoUniformlyOn f g l s → TendstoUniformlyOn f⁻¹ g⁻¹ l s | true |
Algebra.TensorProduct.instNonUnitalNonAssocRing._proof_3 | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocRing A]
[inst_2 : Module R A] [inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A]
[inst_5 : NonUnitalNonAssocSemiring B] [inst_6 : Module R B] [inst_7 : SMulCommClass R B B]
[inst_8 : IsScalarTower R B B] (... | false |
_private.Mathlib.AlgebraicGeometry.Cover.QuasiCompact.0.AlgebraicGeometry.QuasiCompactCover.of_hom._simp_1_1 | Mathlib.AlgebraicGeometry.Cover.QuasiCompact | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↥X),
g (f x) = (CategoryTheory.CategoryStruct.comp f g) x | false |
Algebra.Generators.id | Mathlib.RingTheory.Extension.Generators | {R : Type u} → [inst : CommRing R] → Algebra.Generators R R PEmpty.{w + 1} | true |
Lean.Meta.instInhabitedPostponedEntry | Lean.Meta.Basic | Inhabited Lean.Meta.PostponedEntry | true |
MeasureTheory.Pi.isMulLeftInvariant_volume | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} [inst : Fintype ι] {α : Type u_4} [inst_1 : Group α] [inst_2 : MeasureTheory.MeasureSpace α]
[MeasureTheory.SigmaFinite MeasureTheory.volume] [MeasurableMul α] [MeasureTheory.volume.IsMulLeftInvariant],
MeasureTheory.volume.IsMulLeftInvariant | true |
Sum.isGeneratedBy | Mathlib.Topology.Convenient.GeneratedBy | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type v} [tY : TopologicalSpace Y]
{Z : Type v'} [inst_1 : TopologicalSpace Z] [Topology.IsGeneratedBy X Y] [Topology.IsGeneratedBy X Z],
Topology.IsGeneratedBy X (Y ⊕ Z) | true |
CategoryTheory.Abelian.monoLift | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{X Y : C} →
(f : X ⟶ Y) →
[CategoryTheory.Mono f] →
{T : C} →
(g : T ⟶ Y) → CategoryTheory.CategoryStruct.comp g (CategoryTheory.Limits.cokernel.π f) = 0 → (T ⟶ X) | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.mkEMatchTheoremWithKind?.collect.match_5 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Option (Option (List Lean.Expr × List Lean.HeadIndex)) → Sort u_1) →
(x : Option (Option (List Lean.Expr × List Lean.HeadIndex))) →
(Unit → motive none) → ((a : Option (List Lean.Expr × List Lean.HeadIndex)) → motive (some a)) → motive x | false |
Std.PRange.UpwardEnumerable.isSome_succ? | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.InfinitelyUpwardEnumerable α] {a : α},
(Std.PRange.succ? a).isSome = true | true |
Submonoid.leftInvEquiv._proof_4 | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : CommMonoid M] (S : Submonoid M) (hS : S ≤ IsUnit.submonoid M) (x : ↥S),
∃ y, ↑(IsUnit.unit ⋯)⁻¹ * ↑y = 1 | false |
Mathlib.Tactic.Coherence.LiftHom.casesOn | Mathlib.Tactic.CategoryTheory.Coherence | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
[inst_1 : Mathlib.Tactic.Coherence.LiftObj X] →
[inst_2 : Mathlib.Tactic.Coherence.LiftObj Y] →
{f : X ⟶ Y} →
{motive : Mathlib.Tactic.Coherence.LiftHom f → Sort u_1} →
(t : Mathlib.Tactic.Cohe... | false |
Function.Embedding.setValue_eq_iff | Mathlib.Logic.Embedding.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (f : α ↪ β) {a a' : α} {b : β} [inst : (a' : α) → Decidable (a' = a)]
[inst_1 : (a' : α) → Decidable (f a' = b)], (f.setValue a b) a' = b ↔ a' = a | true |
LinearMap.toMatrix_adjoint | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace 𝕜 E] [inst_4 : InnerProductSpace 𝕜 F] {m : Type u_5}
{n : Type u_6} [inst_5 : Fintype m] [inst_6 : DecidableEq m] [inst_7 : Fintype n] [inst_8 : DecidableE... | true |
SpectrumRestricts.cfc | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} {p q : A → Prop} [inst : Semifield R] [inst_1 : StarRing R]
[inst_2 : MetricSpace R] [inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Semifield S]
[inst_6 : StarRing S] [inst_7 : MetricSpace S] [inst_8 : IsTopologicalSemiring S] [inst_9 : Contin... | true |
AdicCompletion.evalOneₐ_surjective | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), Function.Surjective ⇑(AdicCompletion.evalOneₐ I) | true |
Lean.Meta.ExtractLets.containsLet | Lean.Meta.Tactic.Lets | Lean.Expr → Bool | true |
Nat.coe_castRingHom | Mathlib.Data.Nat.Cast.Basic | ∀ {α : Type u_1} [inst : NonAssocSemiring α], ⇑(Nat.castRingHom α) = Nat.cast | true |
Polynomial.span_singleton_annIdealGenerator | Mathlib.LinearAlgebra.AnnihilatingPolynomial | ∀ (𝕜 : Type u_1) {A : Type u_2} [inst : Field 𝕜] [inst_1 : Ring A] [inst_2 : Algebra 𝕜 A] (a : A),
Ideal.span {Polynomial.annIdealGenerator 𝕜 a} = Polynomial.annIdeal 𝕜 a | true |
Lean.Lsp.WorkDoneProgressReport.percentage? | Lean.Data.Lsp.Basic | Lean.Lsp.WorkDoneProgressReport → Option ℕ | true |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.State.mk.inj | Lean.Meta.Match.SimpH | ∀ {mvarId : Lean.MVarId} {xs eqs eqsNew : List Lean.FVarId} {mvarId_1 : Lean.MVarId}
{xs_1 eqs_1 eqsNew_1 : List Lean.FVarId},
{ mvarId := mvarId, xs := xs, eqs := eqs, eqsNew := eqsNew } =
{ mvarId := mvarId_1, xs := xs_1, eqs := eqs_1, eqsNew := eqsNew_1 } →
mvarId = mvarId_1 ∧ xs = xs_1 ∧ eqs = eqs_1 ∧... | true |
CategoryTheory.StrictlyUnitaryPseudofunctor.toStrictlyUnitaryLaxFunctor_mapId | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.StrictlyUnitaryPseudofunctor B C) {x : B}, F.toStrictlyUnitaryLaxFunctor.mapId x = (F.mapId x).inv | true |
Lean.Meta.Simp.Config.zeta._default | Init.MetaTypes | Bool | false |
SemidirectProduct.congr'_apply_right | Mathlib.GroupTheory.SemidirectProduct | ∀ {N₁ : Type u_4} {G₁ : Type u_5} {N₂ : Type u_6} {G₂ : Type u_7} [inst : Group N₁] [inst_1 : Group G₁]
[inst_2 : Group N₂] [inst_3 : Group G₂] {φ₁ : G₁ →* MulAut N₁} (fn : N₁ ≃* N₂) (fg : G₁ ≃* G₂) (x : N₁ ⋊[φ₁] G₁),
((SemidirectProduct.congr' fn fg) x).right = fg x.right | true |
Homeomorph.isOpenMap | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y), IsOpenMap ⇑h | true |
Monoid.CoprodI.lift._proof_1 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} {N : Type u_3} [inst : Monoid N],
MulHomClass (FreeMonoid ((i : ι) × M i) →* N) (FreeMonoid ((i : ι) × M i)) N | false |
_private.Lean.Meta.Tactic.Constructor.0.Lean.MVarId.existsIntro.match_1 | Lean.Meta.Tactic.Constructor | (motive : List Lean.MVarId → Sort u_1) →
(__discr : List Lean.MVarId) →
((mvarId : Lean.MVarId) → motive [mvarId]) → ((x : List Lean.MVarId) → motive x) → motive __discr | false |
AlgEquiv.coe_mk | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] {toEquiv : A₁ ≃ A₂}
{map_mul : ∀ (x y : A₁), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y}
{map_add : ∀ (x y : A₁), toEquiv.toFun (x + ... | true |
Polynomial.deriv_aeval | Mathlib.Analysis.Calculus.Deriv.Polynomial | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {R : Type u_1} [inst_1 : CommSemiring R]
[inst_2 : Algebra R 𝕜] (q : Polynomial R),
deriv (fun x => (Polynomial.aeval x) q) x = (Polynomial.aeval x) (Polynomial.derivative q) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.