name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterM.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {β : Type u_1} {n : Type u_1 → Type u_2} {f : β → n (ULift.{u_1, 0} Bool)} [inst : MonadAttach n] (out : β)
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) (hf : MonadAttach.CanReturn (f out) { down := true })
(h_1 : (hf : MonadAttach.CanReturn (f out) { down := false }) → motive ⟨{ down := false },... | null | true |
FormalMultilinearSeries.compChangeOfVariables_blocksFun | Mathlib.Analysis.Analytic.Composition | ∀ (m M N : ℕ) {i : (n : ℕ) × (Fin n → ℕ)} (hi : i ∈ FormalMultilinearSeries.compPartialSumSource m M N) (j : Fin i.fst),
(FormalMultilinearSeries.compChangeOfVariables m M N i hi).snd.blocksFun ⟨↑j, ⋯⟩ = i.snd j | null | true |
Set.infinite_of_finite_compl | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} [Infinite α] {s : Set α}, sᶜ.Finite → s.Infinite | null | true |
WeierstrassCurve.Δ._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | (7 + 1).AtLeastTwo | null | false |
Real.deriv_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.InverseDeriv | deriv Real.arccos = fun x => -(1 / √(1 - x ^ 2)) | null | true |
Algebra.TensorProduct.instNonUnitalRing | Mathlib.RingTheory.TensorProduct.Basic | {R : Type uR} →
{A : Type uA} →
{B : Type uB} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalRing A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] →
[inst_5 : NonUnitalSemiring B] →
[inst_6 : Module R B] ... | null | true |
QuadraticModuleCat.Hom.mk.injEq | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u} [inst : CommRing R] {V W : QuadraticModuleCat R} (toIsometry' toIsometry'_1 : V.form →qᵢ W.form),
({ toIsometry' := toIsometry' } = { toIsometry' := toIsometry'_1 }) = (toIsometry' = toIsometry'_1) | null | true |
Std.ExtDHashMap.mem_inter_iff._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (k ∈ m₁ ∩ m₂) = (k ∈ m₁ ∧ k ∈ m₂) | null | false |
CategoryTheory.Pi.closedUnit._proof_2 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] [inst_2 : (i : I) → CategoryTheory.MonoidalClosed (C i)]
(X : (i : I) → C i) ⦃X_1 Y : (i : I) → C i⦄ (f : X_1 ⟶ Y),
(CategoryTheory.CategoryStruct.comp ((Categ... | null | false |
DirectSum.instCommRingOfNat._proof_8 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddCommMonoid ι] [inst_3 : DirectSum.GCommRing A] (x : ℕ) (x_1 : A 0),
(DirectSum.of A 0) (x • x_1) = x • (DirectSum.of A 0) x_1 | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.equiv_iff_toList_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
CategoryTheory.Limits.filtered_colim_preservesFiniteLimits_of_types | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {K : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} K] [inst_1 : Small.{v, u₂} K] [CategoryTheory.IsFiltered K],
CategoryTheory.Limits.PreservesFiniteLimits CategoryTheory.Limits.colim | null | true |
_private.Mathlib.Analysis.Convex.PathConnected.0.Path.range_segment._simp_1_1 | Mathlib.Analysis.Convex.PathConnected | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [inst_3 : ContinuousAdd E]
[inst_4 : ContinuousSMul ℝ E] (a b : E) (t : ↑unitInterval), (AffineMap.lineMap a b) ↑t = (Path.segment a b) t | null | false |
LinearMap.coe_restrictScalars | Mathlib.Algebra.Module.LinearMap.Defs | ∀ (R : Type u_1) {S : Type u_5} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module S M] [inst_7 : Module S M₂] [inst_8 : LinearMap.CompatibleSMul M M₂ R S] (f : M →ₗ[S] M₂),
... | null | true |
Option.decidableForallMem._proof_1 | Init.Data.Option.Instances | ∀ {α : Type u_1} {p : α → Prop}, ∀ a ∈ none, p a | null | false |
_private.Plausible.Testable.0.Plausible.instEvalExprConfiguration.evalExpr | Plausible.Testable | Lean.Expr → Lean.MetaM Plausible.Configuration | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceShiftWithBitVecLit | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Name → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.DStep | Helper function for reducing `x <<< i` and `x >>> i` where `i` is a bitvector literal,
into one that is a natural number literal.
| true |
HomologicalComplex.mapBifunctor₁₂.D₁.congr_simp | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
Lean.MessageSeverity.recOn | Lean.Message | {motive : Lean.MessageSeverity → Sort u} →
(t : Lean.MessageSeverity) →
motive Lean.MessageSeverity.information →
motive Lean.MessageSeverity.warning → motive Lean.MessageSeverity.error → motive t | null | false |
AlgebraicTopology.DoldKan.Γ₀.splitting._proof_3 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ) (Δ : SimplexCategoryᵒᵖ),
CategoryTheory.Limits.HasColimit
(CategoryTheory.Discrete.functor (CategoryTheory.SimplicialObject.Splitting.summan... | null | false |
CategoryTheory.FreeBicategory.homCategory' | Mathlib.CategoryTheory.Bicategory.Coherence | {B : Type u} →
[inst : Quiver B] → (a b : B) → CategoryTheory.Category.{max u v, max u v} (CategoryTheory.FreeBicategory.Hom a b) | Category structure on `Hom a b`. In this file, we will use `Hom a b` for `a b : B`
(precisely, `FreeBicategory.Hom a b`) instead of the definitionally equal expression
`a ⟶ b` for `a b : FreeBicategory B`. The main reason is that we have to annoyingly write
`@Quiver.Hom (FreeBicategory B) _ a b` to get the latter expre... | true |
UInt32.mul_def | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), a * b = { toBitVec := a.toBitVec * b.toBitVec } | null | true |
List.findIdx_map | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} (xs : List α) (f : α → β) (p : β → Bool),
List.findIdx p (List.map f xs) = List.findIdx (p ∘ f) xs | null | true |
Lean.Meta.LazyDiscrTree.InitEntry._sizeOf_1 | Lean.Meta.LazyDiscrTree | {α : Type} → [SizeOf α] → Lean.Meta.LazyDiscrTree.InitEntry α → ℕ | null | false |
Lean.MonadStateCacheT | Lean.Util.MonadCache | (α : Type) → Type → (Type → Type) → [BEq α] → [Hashable α] → Type → Type | Similar to `MonadCacheT`, but using `StateT` instead of `StateRefT` | true |
MulHom.coe_ofDense | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Semigroup M] [inst_1 : Semigroup N] {s : Set M} (f : M → N)
(hs : Subsemigroup.closure s = ⊤) (hmul : ∀ (x y : M), y ∈ s → f (x * y) = f x * f y), ⇑(MulHom.ofDense f hs hmul) = f | null | true |
CategoryTheory.Arrow.w_mk_assoc | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y X' Y' : T} {f : X ⟶ Y} {g : X' ⟶ Y'}
(sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) {Z : T} (h : Y' ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.Hom.left sq) (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.Ca... | null | true |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.data_extract._proof_1_4 | Init.Data.ByteArray.Lemmas | ∀ {a : ByteArray} {b e : ℕ}, ¬b ≤ e → ¬min e a.data.size ≤ b → False | null | false |
Submonoid.mem_divPairs | Mathlib.GroupTheory.MonoidLocalization.DivPairs | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G] {f : ⊤.LocalizationMap G} {s : Submonoid G}
{x : M × M}, x ∈ Submonoid.divPairs f s ↔ f x.1 / f x.2 ∈ s | null | true |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_free_of_surjective._simp_1_7 | Mathlib.Algebra.Module.FinitePresentation | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{M' : Type u_6} [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') (v : α → M) (l : α →₀ R),
(Finsupp.linearCombination R (⇑f ∘ v)) l = f ((Finsupp.linearCombination R v) l) | null | false |
_private.Lean.Level.0.Lean.Level.normLtAux._unary._proof_3 | Lean.Level | ∀ (l₁ : Lean.Level) (k₁ : ℕ) (l₂ : Lean.Level) (k₂ : ℕ),
(invImage
(fun x =>
PSigma.casesOn x fun a a_1 => PSigma.casesOn a_1 fun a_2 a_3 => PSigma.casesOn a_3 fun a_4 a_5 => (a, a_4))
Prod.instWellFoundedRelation).1
⟨l₁, ⟨k₁, ⟨l₂, k₂ + 1⟩⟩⟩ ⟨l₁, ⟨k₁, ⟨l₂.succ, k₂⟩⟩⟩ | null | false |
MeasureTheory.FiniteMeasure.coeFn_def | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω), ⇑μ = fun s => (↑μ s).toNNReal | null | true |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.exists_presentation_of_basis_cotangent._simp_1_3 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | null | false |
CategoryTheory.Limits.IsWeakLimit.ofIsoWeakLimit_lift | Mathlib.CategoryTheory.Limits.WeakLimits.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{v_3, u_3} C] {F : CategoryTheory.Functor J C} {r t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsWeakLimit r) (i : r ≅ t) (s : CategoryTheory.Limits.Cone F),
(P.ofIsoWeakLimit i).lift s ... | null | true |
Quotient.finChoice._proof_2 | Mathlib.Data.Fintype.Quotient | ∀ {ι : Type u_1} (x x_1 : { l // ∀ (i : ι), i ∈ l }),
(Subtype.instSetoid_mathlib fun l => ∀ (i : ι), i ∈ l) x x_1 ↔
(Subtype.instSetoid_mathlib fun l => ∀ (i : ι), i ∈ l) x x_1 | null | false |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobian._simp_1_2 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m n : ℕ), (f.sylvester g m n).det = f.resultant g m n | null | false |
RBTree.RBNode.balLeft.match_4.congr_eq_1 | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} (motive : RBTree.RBNode α → Sort u_2) (l : RBTree.RBNode α)
(h_1 : (a : RBTree.RBNode α) → (x : α) → (b : RBTree.RBNode α) → motive (RBTree.RBNode.node RBTree.RBColor.red a x b))
(h_2 : (l : RBTree.RBNode α) → motive l) (a : RBTree.RBNode α) (x : α) (b : RBTree.RBNode α),
l = RBTree.RBNode.node R... | null | true |
GrpWithZero.carrier | Mathlib.Algebra.Category.GrpWithZero | GrpWithZero → Type u_1 | The underlying group with zero. | true |
Std.Do.SPred.exists.match_1 | Std.Do.SPred.SPred | {α : Sort u_3} →
(motive : (σs : List (Type u_1)) → (α → Std.Do.SPred σs) → Sort u_2) →
(σs : List (Type u_1)) →
(P : α → Std.Do.SPred σs) →
((P : α → Std.Do.SPred []) → motive [] P) →
((σ : Type u_1) → (tail : List (Type u_1)) → (P : α → Std.Do.SPred (σ :: tail)) → motive (σ :: tail) P) →... | null | false |
IsPrimitiveRoot.toRootsOfUnity | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | {M : Type u_1} → [inst : CommMonoid M] → {μ : M} → {n : ℕ} → [NeZero n] → IsPrimitiveRoot μ n → ↥(rootsOfUnity n M) | Turn a primitive root μ into a member of the `rootsOfUnity` subgroup. | true |
Mathlib.Meta.NormNum.not_isSquare_of_isNNRat_rat_of_num | Mathlib.Tactic.NormNum.IsSquare | ∀ (a : ℚ) (n d : ℕ), ¬IsSquare n → n.Coprime d → Mathlib.Meta.NormNum.IsNNRat a n d → ¬IsSquare a | null | true |
DFinsupp.lsum_single | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} (S : Type u_4) {M : ι → Type u_5} {N : Type u_6} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : AddCommMonoid N]
[inst_4 : Module R N] [inst_5 : DecidableEq ι] [inst_6 : Semiring S] [inst_7 : Module S N]
[inst_8 : SMulComm... | While `simp` can prove this, it is often convenient to avoid unfolding `lsum` into `sumAddHom`
with `DFinsupp.lsum_apply_apply`. | true |
Bound.mul_le_one | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a b : M₀} [PosMulMono M₀] [MulPosMono M₀],
a ≤ 1 → b ≤ 1 → 0 ≤ a ∨ 0 ≤ b → a * b ≤ 1 | null | true |
Lean.Meta.Grind.AC.MonadGetStruct.noConfusionType | Lean.Meta.Tactic.Grind.AC.Util | Sort u →
{m : Type → Type} →
Lean.Meta.Grind.AC.MonadGetStruct m → {m' : Type → Type} → Lean.Meta.Grind.AC.MonadGetStruct m' → Sort u | null | false |
_private.Init.Meta.Defs.0.Lean.Name.replacePrefix.match_1 | Init.Meta.Defs | (motive : Lean.Name → Lean.Name → Lean.Name → Sort u_1) →
(x x_1 x_2 : Lean.Name) →
((newP : Lean.Name) → motive Lean.Name.anonymous Lean.Name.anonymous newP) →
((x x_3 : Lean.Name) → motive Lean.Name.anonymous x x_3) →
((n p : Lean.Name) →
(s : String) →
(h : n = p.str s) ... | null | false |
Lean.Expr.replace | Lean.Util.ReplaceExpr | (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Expr | null | true |
Lean.instToJsonPrintImportResult.toJson | Lean.Elab.ParseImportsFast | Lean.PrintImportResult → Lean.Json | null | true |
SemiNormedGrp.of.injEq | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (carrier : Type u) [str : SeminormedAddCommGroup carrier] (carrier_1 : Type u)
(str_1 : SeminormedAddCommGroup carrier_1), (↧carrier = ↧carrier_1) = (carrier = carrier_1 ∧ str ≍ str_1) | null | true |
Filter.elabEventuallyEq | Mathlib.Order.Filter.Defs | Lean.Elab.Term.TermElab | Elaborator for `x =ᶠ[l] y`, dispatching on the type of `x` (or of `y` if the type of `x` is not
yet known): `Filter.EventuallyEqSet` for sets, `Filter.EventuallyEq` for functions. | true |
Finset.Ioo_subset_Ioi_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] [inst_2 : LocallyFiniteOrder α],
Finset.Ioo a b ⊆ Finset.Ioi a | null | true |
_private.Lean.Exception.0.Lean.initFn._@.Lean.Exception.2633972168._hygCtx._hyg.2 | Lean.Exception | IO Lean.InternalExceptionId | null | false |
Lean.Elab.Attribute.name | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.Name | null | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.elabSetOption._regBuiltin.Lean.Elab.Tactic.elabSetOption_5 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | null | false |
_private.Batteries.Data.List.Basic.0.List.getRest.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : List α → List α → Sort u_2) →
(x x_1 : List α) →
((l : List α) → motive l []) →
((x : List α) → motive [] x) →
((x : α) → (l : List α) → (y : α) → (l₁ : List α) → motive (x :: l) (y :: l₁)) → motive x x_1 | null | false |
Std.DHashMap.Internal.Raw₀.Const.any_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β) {p : α → β → Bool},
((Std.DHashMap.Raw.Const.toList ↑m).any fun x => p x.1 x.2) = (↑m).any p | null | true |
Function.support_enorm | Mathlib.MeasureTheory.Function.LpSeminorm.Defs | ∀ {α : Type u_4} {ε : Type u_5} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : α → ε},
(Function.support fun x => ‖f x‖ₑ) = Function.support f | null | true |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
CuspFormClass.rec | Mathlib.NumberTheory.ModularForms.Basic | {F : Type u_2} →
{Γ : Subgroup (GL (Fin 2) ℝ)} →
{k : ℤ} →
[inst : FunLike F UpperHalfPlane ℂ] →
{motive : CuspFormClass F Γ k → Sort u} →
([toSlashInvariantFormClass : SlashInvariantFormClass F Γ k] →
(holo : ∀ (f : F), MDiff ⇑f) →
(zero_at_cusps : ∀ (f : F) ... | null | false |
Nat.primorial_dvd_lcmUpto | Mathlib.NumberTheory.Chebyshev | ∀ (n : ℕ), primorial n ∣ n.lcmUpto | null | true |
Turing.TM1to1.trCfg.eq_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {n : ℕ} (enc : Γ → List.Vector Bool n) [inst : Inhabited Γ]
(enc0 : enc default = List.Vector.replicate n false) (l : Option Λ) (v : σ) (T : Turing.Tape Γ),
Turing.TM1to1.trCfg enc enc0 { l := l, var := v, Tape := T } =
{ l := Option.map Turing.TM1to1.Λ'.normal l, ... | null | true |
GroupExtension.Splitting.conjAct | Mathlib.GroupTheory.GroupExtension.Basic | {N : Type u_1} →
{G : Type u_2} →
[inst : Group N] →
[inst_1 : Group G] →
{E : Type u_3} → [inst_2 : Group E] → {S : GroupExtension N E G} → S.Splitting → G →* MulAut N | `G` acts on `N` by conjugation. | true |
Std.HashMap.Raw.getElem_congr | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h : m.WF) {a b : α} (hab : (a == b) = true) {h' : a ∈ m}, m[a] = m[b] | null | true |
RatFunc.irreducible_minpolyX | Mathlib.FieldTheory.RatFunc.IntermediateField | ∀ {K : Type u_1} [inst : Field K] (f : RatFunc K), (¬∃ c, f = RatFunc.C c) → Irreducible (f.minpolyX ↥K⟮f⟯) | null | true |
WeakSpace.instModule' | Mathlib.Topology.Algebra.Module.Spaces.WeakDual | {𝕜 : Type u_2} →
{𝕝 : Type u_3} →
{E : Type u_4} →
[inst : CommSemiring 𝕜] →
[inst_1 : TopologicalSpace 𝕜] →
[inst_2 : ContinuousAdd 𝕜] →
[inst_3 : ContinuousConstSMul 𝕜 𝕜] →
[inst_4 : AddCommMonoid E] →
[inst_5 : Module 𝕜 E] →
... | null | true |
Real.tendsto_sin_div_nhdsNE_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | Filter.Tendsto (fun x => Real.sin x / x) (nhdsWithin 0 {0}ᶜ) (nhds 1) | The limit `lim_{x → 0} (sin x) / x = 1`. | true |
CategoryTheory.Subfunctor.range | Mathlib.CategoryTheory.Subfunctor.Image | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F F' : CategoryTheory.Functor C (Type w)} → (F' ⟶ F) → CategoryTheory.Subfunctor F | The range of a morphism of type-valued functors, as a subfunctor of the target. | true |
QuaternionAlgebra.equivProd | Mathlib.Algebra.Quaternion | {R : Type u_1} → (c₁ c₂ c₃ : R) → QuaternionAlgebra R c₁ c₂ c₃ ≃ R × R × R × R | The equivalence between a quaternion algebra over `R` and `R × R × R × R`. | true |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.matchesAt_iff_matchesAt_decide._simp_1_2 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt p pos pos' =
String.Slice.Pattern.Model.IsLongestMatchAt (fun x => decide (p x)) pos pos' | null | false |
Vector.set_mk._proof_3 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} (h : xs.size = n) {i : ℕ} {x : α} (w : i < n), (xs.set i x ⋯).size = n | null | false |
Function.locallyFinsuppWithin.mapRange_apply | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_3} {Z : Type u_4} [inst_1 : Zero Y]
[inst_2 : Zero Z] {f : Y → Z} {hf : f 0 = 0} {g : Function.locallyFinsuppWithin U Y} {a : X},
(Function.locallyFinsuppWithin.mapRange f hf g) a = f (g a) | null | true |
ContDiffOn.pow | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {n : WithTop ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸]
[inst_4 : NormedAlgebra 𝕜 𝔸] {f : E → 𝔸}, ContDiffOn 𝕜 n f s → ∀ (m : ℕ), ContDiffOn 𝕜 n (fun y => f y ^ m) s | null | true |
Aesop.GoalOrigin | Aesop.Tree.Data | Type | A goal `G` can be added to the tree for three reasons:
1. `G` was produced by its parent rule as a subgoal. This is the most common
reason.
2. `G` was copied because it contains some metavariables which were assigned by
its parent rule. In this case, we record goal of which `G` is a copy. We also
record the r... | true |
Submodule.span_smul | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_8}
[inst_3 : Monoid α] [inst_4 : DistribMulAction α M] [inst_5 : SMulCommClass α R M] (a : α) (s : Set M),
Submodule.span R (a • s) = a • Submodule.span R s | null | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.complexMGF_id_gaussianReal._simp_1_5 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Lean.Meta.Grind.InjectiveInfo.inv? | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.InjectiveInfo → Option (Lean.Expr × Lean.Expr) | Inverse function and a proof that `∀ a, inv (f a) = a`
**Note**: The following two fields are `none` if no `f`-application has been found yet.
| true |
CategoryTheory.Limits.sigmaConstObjCompIso.congr_simp | Mathlib.CategoryTheory.Limits.Preserves.SigmaConst | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
[inst_2 : CategoryTheory.Limits.HasCoproducts C] [inst_3 : CategoryTheory.Limits.HasCoproducts D]
(F : CategoryTheory.Functor C D)
[inst_4 : ∀ (T : Type w), CategoryTheory.Limits.PreservesColimitsO... | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.commShiftIso_opOp_hom_app._proof_3 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ (n m : ℤ), autoParam (n + m = 0) CategoryTheory.Pretriangulated.commShiftIso_opOp_hom_app._auto_1 → m + n = 0 | null | false |
Valuation.val_le_one_or_val_inv_lt_one | Mathlib.RingTheory.Valuation.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
(v : Valuation K Γ₀) (x : K), v x ≤ 1 ∨ v x⁻¹ < 1 | null | true |
AddAction.stabilizer.eq_1 | Mathlib.GroupTheory.GroupAction.Defs | ∀ (G : Type u_1) {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] (a : α),
AddAction.stabilizer G a = { toAddSubmonoid := AddAction.stabilizerAddSubmonoid G a, neg_mem' := ⋯ } | null | true |
ContinuousMultilinearMap.nnnorm_constOfIsEmpty | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u) {ι : Type v} (E : ι → Type wE) {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] [inst_6 : IsEmpty ι] (x : G),
‖Continuou... | null | true |
groupCohomology.Hilbert90.aux.eq_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : FiniteDimensional K L] (f : Gal(L/K) → Lˣ),
groupCohomology.Hilbert90.aux f =
(Finsupp.linearCombination L fun φ => ⇑φ) (Finsupp.equivFunOnFinite.symm fun φ => ↑(f φ)) | null | true |
Polynomial.Monic.degree_pos | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : CommSemiring R] {p : Polynomial R}, p.Monic → (0 < p.degree ↔ p ≠ 1) | null | true |
SeparationQuotient.instDistrib._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Distrib R] [inst_2 : ContinuousMul R] [inst_3 : ContinuousAdd R]
(a b c : SeparationQuotient R), a * (b + c) = a * b + a * c | null | false |
_private.Mathlib.Data.List.TakeDrop.0.List.takeD_eq_take.match_1_1 | Mathlib.Data.List.TakeDrop | ∀ {α : Type u_1} (motive : (x : ℕ) → (x_1 : List α) → α → x ≤ x_1.length → Prop) (x : ℕ) (x_1 : List α) (x_2 : α)
(x_3 : x ≤ x_1.length),
(∀ (x : List α) (x_4 : α) (x_5 : 0 ≤ x.length), motive 0 x x_4 x_5) →
(∀ (n : ℕ) (head : α) (tail : List α) (a : α) (h : n + 1 ≤ (head :: tail).length),
motive n.succ... | null | false |
Lean.instInhabitedTheoremVal | Lean.Declaration | Inhabited Lean.TheoremVal | null | true |
t1Space_iff_specializes_imp_eq | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X], T1Space X ↔ ∀ ⦃x y : X⦄, x ⤳ y → x = y | null | true |
Submodule.IsOrtho.le | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{U V : Submodule 𝕜 E}, U ⟂ V → U ≤ Vᗮ | null | true |
AdicCompletion.of_injective | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[IsHausdorff I M], Function.Injective ⇑(AdicCompletion.of I M) | null | true |
MeasureTheory.Measure.pi | Mathlib.MeasureTheory.Constructions.Pi | {ι : Type u_4} →
{α : ι → Type u_5} →
[Fintype ι] →
[inst : (i : ι) → MeasurableSpace (α i)] →
((i : ι) → MeasureTheory.Measure (α i)) → MeasureTheory.Measure ((i : ι) → α i) | `Measure.pi μ` is the finite product of the measures `{μ i | i : ι}`.
It is defined to be measure corresponding to `MeasureTheory.OuterMeasure.pi`. | true |
MonoidWithZeroHom | Mathlib.Algebra.GroupWithZero.Hom | (α : Type u_7) → (β : Type u_8) → [MulZeroOneClass α] → [MulZeroOneClass β] → Type (max u_7 u_8) | `α →*₀ β` is the type of functions `α → β` that preserve
the `MonoidWithZero` structure.
`MonoidWithZeroHom` is also used for group homomorphisms.
When possible, instead of parametrizing results over `(f : α →*₀ β)`,
you should parametrize over `(F : Type*) [MonoidWithZeroHomClass F α β] (f : F)`.
When you extend th... | true |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise.0.SubMulAction.instMulOneClass._simp_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | ∀ {R : Type u_1} {M : Type u_2} [inst : Monoid R] [inst_1 : MulAction R M] [inst_2 : Mul M]
[inst_3 : IsScalarTower R M M] {p q : SubMulAction R M} {x : M}, (x ∈ p * q) = ∃ y ∈ p, ∃ z ∈ q, y * z = x | null | false |
Std.DTreeMap.Internal.Impl.Const.get!_insertIfNew! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
t.WF →
∀ {k a : α} {v : β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.insertIfNew! k v t) a =
if compare k a = Ordering.eq ∧ k ∉ t then v else ... | null | true |
ContDiffOn.continuousOn_fderivWithin_apply | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {f : E → F}
{n : WithTop ℕ∞},
ContDiffOn 𝕜 n f s → UniqueDiffOn 𝕜 s → 1 ≤ n → ContinuousOn (fun ... | If a function is at least `C^1`, its bundled derivative (mapping `(x, v)` to `Df(x) v`) is
continuous. | true |
MultiplierAlgebra.«_aux_Mathlib_Analysis_CStarAlgebra_Multiplier___macroRules_MultiplierAlgebra_term𝓜(_,_)_1» | Mathlib.Analysis.CStarAlgebra.Multiplier | Lean.Macro | null | false |
iteratedFDerivWithin_insert | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : ℕ} {y : E}, iteratedFDerivWithin 𝕜 n f (insert x s) y = iteratedFDerivWithin �... | null | true |
Finite.ciInf_le_of_le | Mathlib.Data.Fintype.Order | ∀ {α : Type u_1} {ι : Type u_2} [Finite ι] [inst : ConditionallyCompleteLattice α] {a : α} {f : ι → α} (c : ι),
f c ≤ a → iInf f ≤ a | null | true |
AddActionHom.inverse._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {X : Type u_1} [inst : VAdd M X] {Y₁ : Type u_3} [inst_1 : VAdd M Y₁] (f : X →ₑ[id] Y₁) (g : Y₁ → X)
(m : M) (x : Y₁), g (m +ᵥ f (g x)) = g (f (m +ᵥ g x)) | null | false |
Lean.Meta.Simp.debug.simp.check.have | Lean.Meta.Tactic.Simp.Main | Lean.Option Bool | null | true |
_private.Aesop.Script.Step.0.Aesop.Script.LazyStep.runFirstSuccessfulTacticBuilder.tryTacticBuilder.match_4 | Aesop.Script.Step | (motive : Option (Lean.Meta.SavedState × List Lean.MVarId) → Sort u_1) →
(tacticResult : Option (Lean.Meta.SavedState × List Lean.MVarId)) →
((actualPostState : Lean.Meta.SavedState) →
(actualPostGoals : List Lean.MVarId) → motive (some (actualPostState, actualPostGoals))) →
((x : Option (Lean.Meta.... | null | false |
_private.Mathlib.Order.Cover.0.LT.lt.exists_disjoint_Iio_Ioi._proof_1_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, a < b → ∃ a', a < a' ∧ ∃ b' < b, ∀ x < a', ∀ (y : α), b' < y → x < y | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.