name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Function.Antiperiodic.const_inv_smul | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {c : α} [inst : AddMonoid α] [inst_1 : Neg β]
[inst_2 : Group γ] [inst_3 : DistribMulAction γ α],
Function.Antiperiodic f c → ∀ (a : γ), Function.Antiperiodic (fun x => f (a⁻¹ • x)) (a • c) | null | true |
Batteries.Tactic.Lint.SimpTheoremInfo.noConfusionType | Batteries.Tactic.Lint.Simp | Sort u → Batteries.Tactic.Lint.SimpTheoremInfo → Batteries.Tactic.Lint.SimpTheoremInfo → Sort u | null | false |
PNat.XgcdType.wp | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ | `wp` is a variable which changes through the algorithm. | true |
normalize | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_1} → [inst : CommMonoidWithZero α] → [NormalizationMonoid α] → α →*₀ α | Chooses an element of each associate class, by multiplying by `normUnit` | true |
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 | null | 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) | The embedding takes exponentiation to exponentiation, wrapped into the range interval. | true |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleDocumentSymbol.toDocumentSymbols.match_1 | Lean.Server.FileWorker.RequestHandling | (motive : String × Lean.Syntax → Sort u_1) →
(x : String × Lean.Syntax) → ((name : String) → (selection : Lean.Syntax) → motive (name, selection)) → motive x | null | false |
Monovary.of_inv_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : CommGroup β] [inst_2 : PartialOrder β]
[IsOrderedMonoid β] {f : ι → α} {g : ι → β}, Monovary f g⁻¹ → Antivary f g | **Alias** of the forward direction of `monovary_inv_right`. | 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) | null | 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 | null | false |
Module.supportDim_le_ringKrullDim | Mathlib.RingTheory.KrullDimension.Module | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.supportDim R M ≤ ringKrullDim R | null | true |
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 | null | false |
MulHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_3} {N : Type u_4} [inst : Mul M] [inst_1 : Mul N] (f : Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) (a : M),
(MulHom.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a | null | true |
UInt64.toBitVec_eq_of_eq | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a = b → a.toBitVec = b.toBitVec | null | true |
CategoryTheory.WellPowered | Mathlib.CategoryTheory.Subobject.WellPowered | (C : Type u₁) → [inst : CategoryTheory.Category.{v, u₁} C] → [CategoryTheory.LocallySmall.{w, v, u₁} C] → Prop | A category (with morphisms in `Type v`) is well-powered relative to a universe `w`
if it is locally small and `Subobject X` is `w`-small for every `X`.
We show in `wellPowered_of_essentiallySmall_monoOver` and `essentiallySmall_monoOver`
that this is the case if and only if `MonoOver X` is `w`-essentially small for ev... | true |
Complex.exp_ne_zero._simp_1 | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℂ), (Complex.exp x = 0) = False | null | false |
DyckWord.semilength_insidePart_add_semilength_outsidePart_add_one | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ {p : DyckWord}, p ≠ 0 → p.insidePart.semilength + p.outsidePart.semilength + 1 = p.semilength | null | true |
IsLocalExtr.deriv_eq_zero | Mathlib.Analysis.Calculus.LocalExtr.Basic | ∀ {f : ℝ → ℝ} {a : ℝ}, IsLocalExtr f a → deriv f a = 0 | **Fermat's Theorem**: the derivative of a function at a local extremum equals zero. | true |
_private.Mathlib.Order.CountableSupClosed.0.countableSupClosure_eq_sInter._simp_1_2 | Mathlib.Order.CountableSupClosed | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
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 | null | true |
Subfield.topologicalClosure._proof_4 | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : TopologicalSpace α] [inst_2 : IsTopologicalDivisionRing α] (K : Subfield α),
1 ∈ K.topologicalClosure.carrier | null | false |
Lean.Parser.Command.namedName.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | null | 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) | null | true |
OrderIso.IicTop._proof_2 | Mathlib.Order.Interval.Set.OrderIso | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] (x : α), x ≤ ⊤ | null | false |
QuaternionAlgebra.imJ | Mathlib.Algebra.Quaternion | {R : Type u_1} → {a b c : R} → QuaternionAlgebra R a b c → R | Second imaginary part (j) of a quaternion. | true |
SimpleGraph.cliqueFree_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {n : ℕ}, G.CliqueFree n ↔ IsEmpty ((SimpleGraph.completeGraph (Fin n)).Copy G) | null | 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... | null | 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)) | null | 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 | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache.addGate._proof_2 | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf : Std.Sat.CNF ℕ} {lhs rhs : Std.Sat.AIG.Fanin} (cache : Std.Sat.AIG.toCNF.Cache✝ aig cnf),
∀ idx < aig.decls.size,
lhs.gate < idx ∧ rhs.gate < idx → ∀ (idx_1 : ℕ), idx = idx_1 → ¬lhs.gate < aig.decls.size → False | null | false |
op_vadd_eq_add | Mathlib.Algebra.Group.Action.Defs | ∀ {α : Type u_9} [inst : Add α] (a b : α), AddOpposite.op a +ᵥ b = b + a | null | true |
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 | null | 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 | null | true |
exists_pred_iterate_or | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] [IsPredArchimedean α] {a b : α},
(∃ n, Order.pred^[n] a = b) ∨ ∃ n, Order.pred^[n] b = a | null | true |
_private.Mathlib.Tactic.Contrapose.0.Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___elabRules_Mathlib_Tactic_Contrapose_contrapose_1.match_1 | Mathlib.Tactic.Contrapose | (motive : Option Lean.Expr → Option Lean.Expr → Sort u_1) →
(x x_1 : Option Lean.Expr) →
(Unit → motive none none) →
((p : Lean.Expr) → motive (some p) none) →
((q : Lean.Expr) → motive none (some q)) → ((p q : Lean.Expr) → motive (some p) (some q)) → motive x x_1 | null | false |
_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 | null | false |
Std.Tactic.BVDecide.Normalize.BitVec.ite_then_not_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {w : ℕ} (c0 c1 : Bool) {a b : BitVec w},
(bif c0 then ~~~bif c1 then ~~~a else b else a) = bif c0 && !c1 then ~~~b else a | null | true |
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 | This lemma is a special case of `rightInvOn_invFunOn.image_image`; it may make more sense
to use the other lemma directly in an application. | true |
DirectSum.gMulLHom._proof_7 | Mathlib.Algebra.DirectSum.Algebra | ∀ {ι : Type u_3} (R : Type u_2) (A : ι → Type u_1) [inst : CommSemiring R] [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : (i : ι) → Module R (A i)] [inst_3 : AddMonoid ι] [inst_4 : DirectSum.GSemiring A]
[inst_5 : DirectSum.GAlgebra R A] {i j : ι} (x x_1 : A i),
{ toFun := fun b => GradedMonoid.GMul.mul (x + ... | null | false |
Std.HashMap.Raw.toListRev_keysIter | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α],
m.WF → m.keysIter.toListRev = m.keys.reverse | null | 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 | null | false |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.isOpen_iff_of_notMem._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set (OnePoint X)},
IsOpen s = ((OnePoint.infty ∈ s → IsCompact (OnePoint.some ⁻¹' s)ᶜ) ∧ IsOpen (OnePoint.some ⁻¹' s)) | null | false |
CategoryTheory.Functor.IsCartesian.domainUniqueUpToIso.congr_simp | Mathlib.CategoryTheory.FiberedCategory.Fibered | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p p_1 : CategoryTheory.Functor 𝒳 𝒮) (e_p : p = p_1) {R S : 𝒮} {a b : 𝒳} (f f_1 : R ⟶ S) (e_f : f = f_1)
(φ φ_1 : a ⟶ b) (e_φ : φ = φ_1) [inst_2 : p.IsCartesian f φ] {a' : 𝒳} (φ' φ'_1 : a... | null | true |
AlgebraicGeometry.exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isCompact | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens},
IsCompact U.carrier →
∀ (x f : ↑(X.presheaf.obj (Opposite.op U))),
TopCat.Presheaf.restrictOpen x (X.basicOpen f) ⋯ = 0 → ∃ n, f ^ n * x = 0 | If `x : Γ(X, U)` is zero on `D(f)` for some `f : Γ(X, U)`, and `U` is quasi-compact, then
`f ^ n * x = 0` for some `n`. | true |
RootPairingCat.noConfusion | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {P : Sort u_1} →
{R : Type u} →
{inst : CommRing R} →
{t : RootPairingCat R} →
{R' : Type u} →
{inst' : CommRing R'} →
{t' : RootPairingCat R'} → R = R' → inst ≍ inst' → t ≍ t' → RootPairingCat.noConfusionType P t t' | null | false |
_private.Lean.AddDecl.0.Lean.isNamespaceName._sparseCasesOn_1 | Lean.AddDecl | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | 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' | null | true |
Finset.subtypeInsertEquivOption._proof_11 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] {t : Finset α} {x : α} (y : ↥(insert x t)), ¬↑y = x → ↑y ∈ t | null | false |
PrimeSpectrum.comap_injective_of_surjective | Mathlib.RingTheory.Spectrum.Prime.RingHom | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S),
Function.Surjective ⇑f → Function.Injective (PrimeSpectrum.comap f) | null | true |
_private.Mathlib.Tactic.MoveAdd.0.Lean.Expr.getExprInputs.match_1 | Mathlib.Tactic.MoveAdd | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(bt bb : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName bt bb binderInfo)) →
((binderName : Lean.Name) →
(bt bb : Lean.... | null | false |
_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) ... | null | false |
AlgebraicGeometry.PresheafedSpace.pushforwardDiagramToColimit._proof_2 | Mathlib.Geometry.RingedSpace.PresheafedSpace.HasColimits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasColimitsOfShape J TopCat]
(F : CategoryTheory.Functor J (AlgebraicGeometry.PresheafedSpace C)) (j : J),
(CategoryTheory.CategoryStruct.comp
((Top... | null | false |
IsLocalizedModule.surj | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} {inst : CommSemiring R} {M : Type u_2} {M' : Type u_3} {inst_1 : AddCommMonoid M}
{inst_2 : AddCommMonoid M'} {inst_3 : Module R M} {inst_4 : Module R M'} (S : Submonoid R) (f : M →ₗ[R] M')
[self : IsLocalizedModule S f] (y : M'), ∃ x, x.2 • y = f x.1 | null | true |
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 | null | true |
Std.ExtHashMap.noConfusion | Std.Data.ExtHashMap.Basic | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Std.ExtHashMap α β} →
{α' : Type u} →
{β' : Type v} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
{t' : Std.ExtHashM... | null | false |
CategoryTheory.WithTerminal.equivComma_counitIso_hom_app_left_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(X : CategoryTheory.Comma (CategoryTheory.Functor.id (CategoryTheory.Functor C D)) (CategoryTheory.Functor.const C))
(X_1 : C),
(CategoryTheory.WithTerminal.equivComma.counitIso.hom.app X).left.... | null | true |
Batteries.AssocList.mapKey | Batteries.Data.AssocList | {α : Type u_1} → {δ : Type u_2} → {β : Type u_3} → (α → δ) → Batteries.AssocList α β → Batteries.AssocList δ β | `O(n)`. Map a function `f` over the keys of the list. | 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) | null | false |
Lean.Expr.replaceNoCache._sunfold | Lean.Util.ReplaceExpr | (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Expr | null | false |
HMul.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{γ : Type w} →
{t : HMul α β γ} →
{α' : Type u} →
{β' : Type v} →
{γ' : Type w} → {t' : HMul α' β' γ'} → α = α' → β = β' → γ = γ' → t ≍ t' → HMul.noConfusionType P t t' | null | false |
UniformSpace.isClosed_ball_of_isSymm_of_isTrans_of_mem_uniformity | Mathlib.Topology.UniformSpace.Ultra.Basic | ∀ {X : Type u_1} [inst : UniformSpace X] (x : X) {V : SetRel X X} [V.IsSymm] [V.IsTrans],
V ∈ uniformity X → IsClosed (UniformSpace.ball x V) | null | true |
DistribMulActionSemiHomClass.toDistribMulActionHom.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : DistribMulAction M A] {B : Type u_5} [inst_4 : AddMonoid B] [inst_5 : DistribMulAction N B] {F : Type u_10}
[inst_6 : FunLike F A B] [inst_7 : DistribMulActionSemiHomClass F (⇑φ) A B] (... | null | true |
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 | null | true |
String.utf8Len_le_of_suffix | Batteries.Data.String.Lemmas | ∀ {cs₁ cs₂ : List Char}, cs₁ <:+ cs₂ → String.utf8Len cs₁ ≤ String.utf8Len cs₂ | null | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.of_injective._simp_1_3 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ : List (α × Bool)} {x : α × Bool}, FreeGroup.Red [x] L₁ = (L₁ = [x]) | null | false |
Lean.Parser.ParserCategory._sizeOf_1 | Lean.Parser.Basic | Lean.Parser.ParserCategory → ℕ | null | false |
SeparationQuotient.instAddCommSemigroup | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : AddCommSemigroup M] → [ContinuousAdd M] → AddCommSemigroup (SeparationQuotient M) | null | true |
Aesop.LocalNormSimpRule.rec | Aesop.Rule | {motive : Aesop.LocalNormSimpRule → Sort u} →
((id : Lean.Name) → (simpTheorem : Lean.Term) → motive { id := id, simpTheorem := simpTheorem }) →
(t : Aesop.LocalNormSimpRule) → motive t | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.termσ | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | Lean.ParserDescr | null | true |
Lean.Expr.abstractRangeM | Lean.Meta.Basic | Lean.Expr → ℕ → Array Lean.Expr → Lean.MetaM Lean.Expr | Similar to `abstractM` but consider only the first `min n xs.size` entries in `xs`
It is also similar to `Expr.abstractRange`, but handles metavariables correctly.
It uses `elimMVarDeps` to ensure `e` and the type of the free variables `xs` do not
contain a metavariable `?m` s.t. local context of `?m` contains a free ... | true |
Ultrafilter.coe_le_coe._simp_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} {f g : Ultrafilter α}, (↑f ≤ ↑g) = (f = g) | null | false |
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 | null | 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) | null | true |
Function.locallyFinsuppWithin.memAddSubmonoid | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddMonoid Y]
(D : Function.locallyFinsuppWithin U Y), ⇑D ∈ Function.locallyFinsuppWithin.addSubmonoid U | null | 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 | null | false |
Complex.contDiff_exp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ] {n : WithTop ℕ∞},
ContDiff 𝕜 n Complex.exp | null | true |
Lean.RArray.get_eq_getImpl | Init.Data.RArray | @Lean.RArray.get = @Lean.RArray.getImpl | null | true |
Ideal.nonPrincipals | Mathlib.RingTheory.PrincipalIdealDomain | (R : Type u) → [inst : Semiring R] → Set (Ideal R) | `nonPrincipals R` is the set of all ideals of `R` that are not principal ideals. | 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 | null | false |
Lean.Core.CoreM.parIter | Lean.Elab.Parallel | {α : Type} → List (Lean.CoreM α) → Lean.CoreM (Std.IterM Lean.CoreM (Except Lean.Exception α)) | Runs a list of CoreM computations in parallel (without cancellation hook).
Returns an iterator that yields results in original order, wrapped in `Except Exception α`.
| true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associates.decompositionMonoid_iff._simp_1_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ (α : Type u_1) [inst : Semigroup α], DecompositionMonoid α = ∀ (a : α), IsPrimal a | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Inv.0.Lean.Meta.Grind.Arith.Linear.checkUppers | Lean.Meta.Tactic.Grind.Arith.Linear.Inv | Lean.Meta.Grind.Arith.Linear.LinearM Unit | null | true |
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) | null | true |
Algebra.map_bot | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B), Subalgebra.map f ⊥ = ⊥ | null | true |
AddAction.nsmul_vadd_eq_iff_minimalPeriod_dvd | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type v} {G : Type u} [inst : AddGroup G] [inst_1 : AddAction G α] {a : G} {b : α} {n : ℕ},
n • a +ᵥ b = b ↔ Function.minimalPeriod (fun x => a +ᵥ x) b ∣ n | null | 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.ι | null | true |
SimpleGraph.chromaticNumber_le_card | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} {G : SimpleGraph V} [inst : Fintype V], G.chromaticNumber ≤ ↑(Fintype.card V) | null | true |
Rat.inv_natCast_num_of_pos | Mathlib.Data.Rat.Lemmas | ∀ {a : ℕ}, 0 < a → (↑a)⁻¹.num = 1 | null | true |
Set.sInter_delab | Mathlib.Order.SetNotation | Lean.PrettyPrinter.Delaborator.Delab | Delaborator for indexed intersections. | 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... | null | 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 | null | false |
Nat.gcd_right_comm | Mathlib.Data.Nat.GCD.Basic | ∀ (a b c : ℕ), (a.gcd b).gcd c = (a.gcd c).gcd b | null | true |
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₂]
[... | null | true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceE_exact._auto_3 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
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... | null | false |
RCLike.inv_pos | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {z : K}, 0 < z⁻¹ ↔ 0 < z | null | true |
List.mapIdxM.go.eq_1 | Init.Data.Array.MapIdx | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : ℕ → α → m β) (a : Array β),
List.mapIdxM.go f [] a = pure a.toList | null | true |
_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) | null | 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 | null | 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 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.