name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ValuativeRel.veq_rfl | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {x : R}, x =ᵥ x |
WeierstrassCurve.VariableChange.recOn | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | {R : Type u} →
[inst : CommRing R] →
{motive : WeierstrassCurve.VariableChange R → Sort u_1} →
(t : WeierstrassCurve.VariableChange R) →
((u : Rˣ) → (r s t : R) → motive { u := u, r := r, s := s, t := t }) → motive t |
SimpleGraph.instIsEmptyElemForallObjOppositeFinsetComponentComplFunctorEndOfFinite | Mathlib.Combinatorics.SimpleGraph.Ends.Properties | ∀ {V : Type} (G : SimpleGraph V) [Finite V], IsEmpty ↑G.end |
Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo.rec | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | {motive : Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo → Sort u} →
((eToInt α he : Lean.Expr) → motive { eToInt := eToInt, α := α, he := he }) →
(t : Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo) → motive t |
_private.Mathlib.Algebra.Order.UpperLower.0.UpperSet.one_mul | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s : UpperSet α), 1 * s = s |
AddSubgroup.map_equiv_eq_comap_symm' | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (f : G ≃+ N) (K : AddSubgroup G),
AddSubgroup.map f.toAddMonoidHom K = AddSubgroup.comap f.symm.toAddMonoidHom K |
RingCon.correspondence._proof_4 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : NonAssocSemiring M] {c : RingCon M} (d : RingCon c.Quotient),
(fun d => RingCon.mapGen ⇑c.mk') ((fun d => ⟨d.comap c.mk', ⋯⟩) d) = d |
BitVec.toNat_eq._simp_1 | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x y : BitVec n}, (x = y) = (x.toNat = y.toNat) |
Lean.Elab.Tactic.ElabSimpArgResult.noConfusion | Lean.Elab.Tactic.Simp | {P : Sort u} →
{t t' : Lean.Elab.Tactic.ElabSimpArgResult} → t = t' → Lean.Elab.Tactic.ElabSimpArgResult.noConfusionType P t t' |
Std.DHashMap.Raw.Const.get?_insertMany_list_of_mem | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {l : List (α × β)} {k k' : α},
(k == k') = true →
∀ {v : β},
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
(k, v) ∈ l → Std.DHashMap.Raw.Const.get? (Std.DHashMap.Raw.Const.insertMany m l) k' = some v |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Eval.0.Polynomial.eval_one_cyclotomic_not_prime_pow._simp_1_5 | Mathlib.RingTheory.Polynomial.Cyclotomic.Eval | ∀ {α : Type u_1} [inst : Monoid α] (a : α), (a ∣ a) = True |
IsMulIndecomposable.mem_or_inv_mem_closure_baseOf | Mathlib.Algebra.Group.Irreducible.Indecomposable | ∀ {ι : Type u_1} {G : Type u_3} {S : Type u_4} [inst : CommGroup G] [inst_1 : LinearOrder S] [Finite ι]
[inst_3 : InvolutiveInv ι] [inst_4 : CommGroup S] [IsOrderedMonoid S] (v : ι → G) (f : G →* S) (i : ι),
f (v i) ≠ 1 →
v i⁻¹ = (v i)⁻¹ →
v i ∈ Submonoid.closure (v '' IsMulIndecomposable.baseOf v f) ∨
(v i)⁻¹ ∈ Submonoid.closure (v '' IsMulIndecomposable.baseOf v f) |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_rev_Ico._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) |
Filter.GenerateSets.brecOn | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {g : Set (Set α)} {motive : (a : Set α) → Filter.GenerateSets g a → Prop} {a : Set α}
(t : Filter.GenerateSets g a),
(∀ (a : Set α) (t : Filter.GenerateSets g a), Filter.GenerateSets.below t → motive a t) → motive a t |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_317 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
_private.Mathlib.Dynamics.PeriodicPts.Lemmas.0.Function.Injective.mem_periodicPts._proof_1_1 | Mathlib.Dynamics.PeriodicPts.Lemmas | ∀ (m n : ℕ), m < n → 0 < n - m |
Int16.toInt64_le._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a.toInt64 ≤ b.toInt64) = (a ≤ b) |
LinearMap.finrank_genEigenspace_le | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {K : Type u_2} {M : Type u_3} [inst : Field K] [inst_1 : AddCommGroup M] [inst_2 : Module K M]
[inst_3 : Module.Finite K M] (φ : Module.End K M) (μ : K) (k : ℕ),
Module.finrank K ↥((φ.genEigenspace μ) ↑k) ≤ Polynomial.rootMultiplicity μ (LinearMap.charpoly φ) |
Subgroup.subset_normalClosure | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {s : Set G}, s ⊆ ↑(Subgroup.normalClosure s) |
Monotone.iSup | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : Preorder α] [inst_1 : CompleteLattice β] {f : ι → α → β},
(∀ (i : ι), Monotone (f i)) → Monotone (⨆ i, f i) |
CategoryTheory.Adjunction.counitSplitMonoOfRFull | Mathlib.CategoryTheory.Adjunction.FullyFaithful | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{L : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor D C} →
(h : L ⊣ R) → [R.Full] → (X : D) → CategoryTheory.SplitMono (h.counit.app X) |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme.0.AlgebraicGeometry.Scheme.IdealSheafData.glueDataT'Aux._proof_3 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (U V W U₀ : ↑X.affineOpens),
↑U ⊓ ↑W ≤ ↑U₀ →
Set.range
⇑(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst (I.glueDataObjι U) (X.homOfLE ⋯))
(CategoryTheory.Limits.pullback.fst (I.glueDataObjι U) (X.homOfLE ⋯)))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (I.glueDataObjι U) (X.homOfLE ⋯))
(CategoryTheory.CategoryStruct.comp (I.glueDataObjι U) (↑U).ι))) ⊆
Set.range ⇑(↑V ⊓ ↑U₀).ι |
Lean.LibrarySuggestions.Selector.intersperse._proof_10 | Lean.LibrarySuggestions.Basic | ∀ (c : Lean.LibrarySuggestions.Config) (suggestions₁ : Array Lean.LibrarySuggestions.Suggestion)
(r : MProd ℕ (Array Lean.LibrarySuggestions.Suggestion)),
r.fst < suggestions₁.size ∧ r.snd.size < c.maxSuggestions → r.fst < suggestions₁.size |
SchwartzMap.instLaplacian._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ F]
[inst_3 : InnerProductSpace ℝ E], LineDerivSMul ℝ E (SchwartzMap E F) (SchwartzMap E F) |
Ordinal.typein_le_typein._simp_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u} (r : α → α → Prop) [inst : IsWellOrder α r] {a b : α},
((Ordinal.typein r).toRelEmbedding a ≤ (Ordinal.typein r).toRelEmbedding b) = ¬r b a |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.BinOpKind.rightact | Lean.Elab.Extra | Lean.Elab.Term.Op.BinOpKind✝ |
Std.DTreeMap.Internal.Impl.Const.maxEntry.match_1.congr_eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → Sort u_3)
(x : Std.DTreeMap.Internal.Impl α fun x => β) (x_1 : x.isEmpty = false)
(h_1 :
(size : ℕ) →
(k : α) →
(v : β) →
(l : Std.DTreeMap.Internal.Impl α fun x => β) →
(x : (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf).isEmpty = false) →
motive (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf) x)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β) →
(l l_1 : Std.DTreeMap.Internal.Impl α fun x => β) →
(size_1 : ℕ) →
(k_1 : α) →
(v_1 : β) →
(l_2 r : Std.DTreeMap.Internal.Impl α fun x => β) →
l_1 = Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_2 r →
(h :
(Std.DTreeMap.Internal.Impl.inner size k v l
(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_2 r)).isEmpty =
false) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v l
(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_2 r))
h)
(size : ℕ) (k : α) (v : β) (l : Std.DTreeMap.Internal.Impl α fun x => β) (size_1 : ℕ) (k_1 : α) (v_1 : β)
(l_1 r : Std.DTreeMap.Internal.Impl α fun x => β)
(h :
(Std.DTreeMap.Internal.Impl.inner size k v l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)).isEmpty =
false),
x = Std.DTreeMap.Internal.Impl.inner size k v l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) →
x_1 ≍ h →
(match x, x_1 with
| Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf, x => h_1 size k v l x
| Std.DTreeMap.Internal.Impl.inner size k v l l_2@h:(Std.DTreeMap.Internal.Impl.inner size_2 k_2 v_2 l_3 r),
h_3 => h_2 size k v l l_2 size_2 k_2 v_2 l_3 r h h_3) ≍
h_2 size k v l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) size_1 k_1 v_1 l_1 r ⋯ h |
Lean.Meta.LibrarySearch.DeclMod.casesOn | Lean.Meta.Tactic.LibrarySearch | {motive : Lean.Meta.LibrarySearch.DeclMod → Sort u} →
(t : Lean.Meta.LibrarySearch.DeclMod) →
motive Lean.Meta.LibrarySearch.DeclMod.none →
motive Lean.Meta.LibrarySearch.DeclMod.mp → motive Lean.Meta.LibrarySearch.DeclMod.mpr → motive t |
Batteries.BinomialHeap.Imp.Heap.WF.deleteMin | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} {le : α → α → Bool} {n : ℕ} {a : α} {s' s : Batteries.BinomialHeap.Imp.Heap α},
Batteries.BinomialHeap.Imp.Heap.WF le n s →
Batteries.BinomialHeap.Imp.Heap.deleteMin le s = some (a, s') → Batteries.BinomialHeap.Imp.Heap.WF le 0 s' |
LinearMap.smulRightₗ._proof_4 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_3} {M : Type u_1} {M₂ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M] [inst_4 : Module R M₂] (c : R) (f : M₂ →ₗ[R] R),
{ toFun := (c • f).smulRight, map_add' := ⋯, map_smul' := ⋯ } =
(RingHom.id R) c • { toFun := f.smulRight, map_add' := ⋯, map_smul' := ⋯ } |
Lean.Lsp.CodeActionOptions | Lean.Data.Lsp.CodeActions | Type |
CategoryTheory.ExactPairing.ofFullyFaithful._proof_2 | Mathlib.CategoryTheory.Monoidal.Rigid.OfEquivalence | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory D] (F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] [inst_5 : F.Full]
(X Y : C) [inst_6 : CategoryTheory.ExactPairing (F.obj X) (F.obj Y)],
F.map
(F.preimage
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OplaxMonoidal.η F)
(CategoryTheory.CategoryStruct.comp (η_ (F.obj X) (F.obj Y)) (CategoryTheory.Functor.LaxMonoidal.μ F X Y)))) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OplaxMonoidal.η F)
(CategoryTheory.CategoryStruct.comp (η_ (F.obj X) (F.obj Y)) (CategoryTheory.Functor.LaxMonoidal.μ F X Y)) |
AffineSubspace.direction_inf | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (s₁ s₂ : AffineSubspace k P), (s₁ ⊓ s₂).direction ≤ s₁.direction ⊓ s₂.direction |
MeasureTheory.measurableCylinders.finset._proof_1 | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)] {t : Set ((i : ι) → α i)},
t ∈ MeasureTheory.measurableCylinders α → ∃ s S, MeasurableSet S ∧ t = MeasureTheory.cylinder s S |
ULift.instOrderTop.eq_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α], ULift.instOrderTop = OrderTop.lift ULift.down ⋯ ⋯ |
Aesop.TraceOption.traceClass | Aesop.Tracing | Aesop.TraceOption → Lean.Name |
CategoryTheory.ConcreteCategory.ext_iff | Mathlib.CategoryTheory.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {X Y : C}
{f g : X ⟶ Y}, f = g ↔ CategoryTheory.ConcreteCategory.hom f = CategoryTheory.ConcreteCategory.hom g |
CategoryTheory.CommSq.LiftStruct.opEquiv._proof_3 | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y}
{g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g),
Function.LeftInverse CategoryTheory.CommSq.LiftStruct.unop CategoryTheory.CommSq.LiftStruct.op |
OrderIso.finTwoArrowIso | Mathlib.Order.Fin.Tuple | (α : Type u_2) → [inst : Preorder α] → (Fin 2 → α) ≃o α × α |
List.drop | Init.Data.List.Basic | {α : Type u} → ℕ → List α → List α |
Int.instCommutativeHMul | Init.Data.Int.Lemmas | Std.Commutative fun x1 x2 => x1 * x2 |
MeasureTheory.Measure.snd_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.IsProbabilityMeasure μ], (μ.prod ν).snd = ν |
Array.getElem_scanl_zero._proof_1 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {init : β} {as : Array α} {f : β → α → β}, 0 < (Array.scanl f init as).size |
CategoryTheory.yonedaMon._proof_11 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X Y Z : CategoryTheory.Mon C} (x : X ⟶ Y) (x_1 : Y ⟶ Z),
{
app := fun Y_1 =>
MonCat.ofHom
{ toFun := fun x_2 => CategoryTheory.CategoryStruct.comp x_2 (CategoryTheory.CategoryStruct.comp x x_1).hom,
map_one' := ⋯, map_mul' := ⋯ },
naturality := ⋯ } =
CategoryTheory.CategoryStruct.comp
{
app := fun Y_1 =>
MonCat.ofHom
{ toFun := fun x_2 => CategoryTheory.CategoryStruct.comp x_2 x.hom, map_one' := ⋯, map_mul' := ⋯ },
naturality := ⋯ }
{
app := fun Y_1 =>
MonCat.ofHom { toFun := fun x => CategoryTheory.CategoryStruct.comp x x_1.hom, map_one' := ⋯, map_mul' := ⋯ },
naturality := ⋯ } |
List.compareLex._sunfold | Init.Data.Ord.Basic | {α : Type u_1} → (α → α → Ordering) → List α → List α → Ordering |
_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_notMem_and_isIntegral_forall_mem_of_ne_of_liesOver._simp_1_2 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) |
CategoryTheory.Functor.LocallyCoverDense.rec | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{G : CategoryTheory.Functor C D} →
{K : CategoryTheory.GrothendieckTopology D} →
{motive : G.LocallyCoverDense K → Sort u} →
((functorPushforward_functorPullback_mem :
∀ ⦃X : C⦄ (T : ↑(K (G.obj X))),
CategoryTheory.Sieve.functorPushforward G (CategoryTheory.Sieve.functorPullback G ↑T) ∈
K (G.obj X)) →
motive ⋯) →
(t : G.LocallyCoverDense K) → motive t |
Std.DHashMap.Raw.size_insertIfNew_le | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, (m.insertIfNew k v).size ≤ m.size + 1 |
Matroid.closure_union_closure_right_eq | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} (M : Matroid α) (X Y : Set α), M.closure (X ∪ M.closure Y) = M.closure (X ∪ Y) |
_private.Lean.Level.0.Lean.Level.substParams.go.match_3 | Lean.Level | (motive : Lean.Level → Sort u_1) →
(u : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((v : Lean.Level) → motive v.succ) →
((v₁ v₂ : Lean.Level) → motive (v₁.max v₂)) →
((v₁ v₂ : Lean.Level) → motive (v₁.imax v₂)) →
((n : Lean.Name) → motive (Lean.Level.param n)) → ((u : Lean.Level) → motive u) → motive u |
Finsupp.zipWith_neLocus_eq_right | Mathlib.Data.Finsupp.NeLocus | ∀ {α : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : DecidableEq α] [inst_1 : DecidableEq M]
[inst_2 : Zero M] [inst_3 : DecidableEq P] [inst_4 : Zero P] [inst_5 : Zero N] {F : M → N → P} (F0 : F 0 0 = 0)
(f₁ f₂ : α →₀ M) (g : α →₀ N),
(∀ (g : N), Function.Injective fun f => F f g) →
(Finsupp.zipWith F F0 f₁ g).neLocus (Finsupp.zipWith F F0 f₂ g) = f₁.neLocus f₂ |
_private.Mathlib.Algebra.QuadraticAlgebra.Basic.0.QuadraticAlgebra.lift._simp_6 | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R),
r • 1 = (algebraMap R A) r |
LieAlgebra.IsKilling.coroot._proof_1 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_1} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L],
AddSubmonoidClass (LieSubalgebra K L) L |
TopCat.hasForgetToMeasCat._proof_2 | Mathlib.MeasureTheory.Category.MeasCat | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z),
⟨⇑(CategoryTheory.CategoryStruct.comp f g).hom', ⋯⟩ = CategoryTheory.CategoryStruct.comp ⟨⇑f.hom', ⋯⟩ ⟨⇑g.hom', ⋯⟩ |
Turing.TM2to1.Λ'.normal.noConfusion | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{P : Sort u} → {a a' : Λ} → Turing.TM2to1.Λ'.normal a = Turing.TM2to1.Λ'.normal a' → (a ≍ a' → P) → P |
cfcL._proof_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : MetricSpace R] [IsTopologicalSemiring R], ContinuousConstSMul R R |
Function.ExtendByOne.hom._proof_2 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {ι : Type u_3} {η : Type u_1} (R : Type u_2) (s : ι → η) [inst : MulOneClass R], Function.extend s 1 1 = 1 |
OpenPartialHomeomorph.Simps.symm_apply | Mathlib.Topology.OpenPartialHomeomorph.Defs | {X : Type u_1} →
{Y : Type u_3} → [inst : TopologicalSpace X] → [inst_1 : TopologicalSpace Y] → OpenPartialHomeomorph X Y → Y → X |
Std.Time.ZonedDateTime.ofPlainDateTimeAssumingUTC | Std.Time.Zoned.ZonedDateTime | Std.Time.PlainDateTime → Std.Time.TimeZone.ZoneRules → Std.Time.ZonedDateTime |
_private.Mathlib.Analysis.Calculus.UniformLimitsDeriv.0.uniformCauchySeqOn_ball_of_fderiv._simp_1_4 | Mathlib.Analysis.Calculus.UniformLimitsDeriv | ∀ (α : Sort u), (∀ (a : α), True) = True |
_private.Std.Time.Date.Basic.0.Std.Time.Second.Offset.ofWeeks._proof_1 | Std.Time.Date.Basic | 86400 * 7 / ↑604800 = 1 |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.monic_X_add_C._simp_1_1 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b < a) = ¬a ≤ b |
FiniteGaloisIntermediateField.instIsSeparableSubtypeMemIntermediateFieldMin | Mathlib.FieldTheory.Galois.GaloisClosure | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(L₁ L₂ : IntermediateField k K) [Algebra.IsSeparable k ↥L₁], Algebra.IsSeparable k ↥(L₁ ⊓ L₂) |
AlgebraicGeometry.germ_injective_of_isIntegral | Mathlib.AlgebraicGeometry.FunctionField | ∀ (X : AlgebraicGeometry.Scheme) [AlgebraicGeometry.IsIntegral X] {U : X.Opens} (x : ↥X) (hx : x ∈ U),
Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom (X.presheaf.germ U x hx)) |
Set.prod_eq_biUnion_left | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, s ×ˢ t = ⋃ a ∈ s, (fun b => (a, b)) '' t |
LowerSet.instPartialOrder._proof_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], Function.Injective SetLike.coe |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.succ_ascFactorial.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x |
SimpleGraph.deleteEdges_sup | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} (G H : SimpleGraph V) (s : Set (Sym2 V)), (G ⊔ H).deleteEdges s = G.deleteEdges s ⊔ H.deleteEdges s |
LinearMap.BilinForm.isCompl_span_singleton_orthogonal | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {V : Type u_5} {K : Type u_6} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{B : LinearMap.BilinForm K V} {x : V}, ¬B.IsOrtho x x → IsCompl (K ∙ x) (B.orthogonal (K ∙ x)) |
MonCat.FilteredColimits.colimitCocone.eq_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J],
MonCat.FilteredColimits.colimitCocone F =
{ pt := MonCat.FilteredColimits.colimit F,
ι := { app := MonCat.FilteredColimits.coconeMorphism F, naturality := ⋯ } } |
Std.Do.PredTrans.pure | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → α → Std.Do.PredTrans ps α |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs.0.EisensteinSeries.D2_mul._simp_1_3 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [LeftDistribClass R] (a b c : R), a * b + a * c = a * (b + c) |
CategoryTheory.CountableCategory.instCountableHomAsType | Mathlib.CategoryTheory.Countable | ∀ (α : Type u) [inst : CategoryTheory.Category.{v, u} α] [inst_1 : CategoryTheory.CountableCategory α],
Countable (CategoryTheory.CountableCategory.HomAsType α) |
Mathlib.Tactic.TFAE.Parser.tfaeHaveDecl.formatter | Mathlib.Tactic.TFAE | Lean.PrettyPrinter.Formatter |
ContMDiffWithinAt.comp_of_eq | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E']
{H' : Type u_6} [inst_7 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7}
[inst_8 : TopologicalSpace M'] {E'' : Type u_8} [inst_9 : NormedAddCommGroup E''] [inst_10 : NormedSpace 𝕜 E'']
{H'' : Type u_9} [inst_11 : TopologicalSpace H''] {I'' : ModelWithCorners 𝕜 E'' H''} {M'' : Type u_10}
[inst_12 : TopologicalSpace M''] [inst_13 : ChartedSpace H M] [inst_14 : ChartedSpace H' M']
[inst_15 : ChartedSpace H'' M''] {f : M → M'} {s : Set M} {n : WithTop ℕ∞} {t : Set M'} {g : M' → M''} {x : M}
{y : M'},
ContMDiffWithinAt I' I'' n g t y →
ContMDiffWithinAt I I' n f s x → Set.MapsTo f s t → f x = y → ContMDiffWithinAt I I'' n (g ∘ f) s x |
WittVector.IsPoly.comp | Mathlib.RingTheory.WittVector.IsPoly | ∀ {p : ℕ} {g f : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R} [hg : WittVector.IsPoly p g]
[hf : WittVector.IsPoly p f], WittVector.IsPoly p fun R _Rcr => g ∘ f |
_private.Mathlib.GroupTheory.GroupAction.ConjAct.0.ConjAct.fixedPoints_eq_center._simp_1_1 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ {G : Type u_1} [inst : Group G] {z : G}, (z ∈ Subgroup.center G) = ∀ (g : G), g * z = z * g |
ENNReal.lintegral_Lp_add_le_of_le_one | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {p : ℝ} {f g : α → ENNReal},
AEMeasurable f μ →
0 ≤ p →
p ≤ 1 →
(∫⁻ (a : α), (f + g) a ^ p ∂μ) ^ (1 / p) ≤
2 ^ (1 / p - 1) * ((∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) + (∫⁻ (a : α), g a ^ p ∂μ) ^ (1 / p)) |
IsStarProjection.le_of_mul_eq_left | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalRing R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R] {p q : R},
IsStarProjection p → IsStarProjection q → p * q = p → p ≤ q |
contMDiffAt_subtype_iff | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E']
{H' : Type u_6} [inst_7 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7}
[inst_8 : TopologicalSpace M'] [inst_9 : ChartedSpace H M] [inst_10 : ChartedSpace H' M'] {n : WithTop ℕ∞}
{U : TopologicalSpace.Opens M} {f : M → M'} {x : ↥U}, ContMDiffAt I I' n (fun x => f ↑x) x ↔ ContMDiffAt I I' n f ↑x |
LeanSearchClient.SearchServer.searchTermSuggestions | LeanSearchClient.Syntax | LeanSearchClient.SearchServer → Lean.Syntax → Lean.TSyntax `str → Lean.Elab.TermElabM Unit |
Std.DTreeMap.Internal.Impl.Balanced.below.leaf | Std.Data.DTreeMap.Internal.Balanced | ∀ {α : Type u} {β : α → Type v} {motive : (a : Std.DTreeMap.Internal.Impl α β) → a.Balanced → Prop},
Std.DTreeMap.Internal.Impl.Balanced.below ⋯ |
BitVec.extractLsb_not_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {hi lo : ℕ}, lo ≤ hi → hi < w → BitVec.extractLsb hi lo (~~~x) = ~~~BitVec.extractLsb hi lo x |
MvPolynomial.pUnitAlgEquiv_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) [inst : CommSemiring R] (p : MvPolynomial PUnit.{u_2 + 1} R),
(MvPolynomial.pUnitAlgEquiv R) p = MvPolynomial.eval₂ Polynomial.C (fun x => Polynomial.X) p |
Lean.Elab.Tactic.Ext.applyExtTheoremAt | Lean.Elab.Tactic.Ext | Lean.MVarId → Lean.MetaM (List Lean.MVarId) |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_26 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax |
ProbabilityTheory.gammaMeasure.eq_1 | Mathlib.Probability.Distributions.Gamma | ∀ (a r : ℝ), ProbabilityTheory.gammaMeasure a r = MeasureTheory.volume.withDensity (ProbabilityTheory.gammaPDF a r) |
_private.Mathlib.FieldTheory.KrullTopology.0.krullTopology_mem_nhds_one_iff_of_normal.match_1_3 | Mathlib.FieldTheory.KrullTopology | ∀ (K : Type u_2) (L : Type u_1) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (s : Set Gal(L/K))
(motive : (∃ E, FiniteDimensional K ↥E ∧ Normal K ↥E ∧ ↑E.fixingSubgroup ⊆ s) → Prop)
(x : ∃ E, FiniteDimensional K ↥E ∧ Normal K ↥E ∧ ↑E.fixingSubgroup ⊆ s),
(∀ (E : IntermediateField K L) (hE : FiniteDimensional K ↥E ∧ Normal K ↥E ∧ ↑E.fixingSubgroup ⊆ s), motive ⋯) →
motive x |
MeasureTheory.ProgMeasurable.finset_sum | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] [inst_2 : MeasurableSpace ι] {γ : Type u_4} [inst_3 : AddCommMonoid β]
[ContinuousAdd β] {U : γ → ι → Ω → β} {s : Finset γ},
(∀ c ∈ s, MeasureTheory.ProgMeasurable f (U c)) → MeasureTheory.ProgMeasurable f fun i a => ∑ c ∈ s, U c i a |
_private.Lean.Meta.Check.0.Lean.Meta.addPPExplicitToExposeDiff.visit._sparseCasesOn_19 | Lean.Meta.Check | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 1152 t.ctorIdx → motive t) → motive t |
Diffeology.DSmooth.continuous' | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : DiffeologicalSpace X]
[Diffeology.IsDTopologyCompatible X] [inst_3 : TopologicalSpace Y] [inst_4 : DiffeologicalSpace Y]
[Diffeology.IsDTopologyCompatible Y] {f : X → Y}, Diffeology.DSmooth f → Continuous f |
CategoryTheory.Limits.ImageMap.map_uniq_aux | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C}
[inst_1 : CategoryTheory.Limits.HasImage f.hom] [inst_2 : CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g}
(map : CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom),
autoParam
(CategoryTheory.CategoryStruct.comp map (CategoryTheory.Limits.image.ι g.hom) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.ι f.hom) sq.right)
CategoryTheory.Limits.ImageMap.map_uniq_aux._auto_1 →
∀ (map' : CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom),
CategoryTheory.CategoryStruct.comp map' (CategoryTheory.Limits.image.ι g.hom) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.ι f.hom) sq.right →
map = map' |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr.0.Lean.Meta.Grind.Arith.Cutsat.LeCnstr.applySubsts.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr | (motive : Option (ℤ × Int.Linear.Var × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u_1) →
(__discr : Option (ℤ × Int.Linear.Var × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
((b : ℤ) → (x : Int.Linear.Var) → (c₁ : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → motive (some (b, x, c₁))) →
((x : Option (ℤ × Int.Linear.Var × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) → motive x) → motive __discr |
SSet.spine.eq_1 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ (X : SSet) (n : ℕ), X.spine n = ((SSet.truncation (n + 1)).obj X).spine n ⋯ |
Aesop.ForwardRule.instToString | Aesop.Rule.Forward | ToString Aesop.ForwardRule |
lt_abs | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] {a b : α}, a < |b| ↔ a < b ∨ a < -b |
Lean.Parser.Term.let_fun._regBuiltin.Lean.Parser.Term.let_fun.formatter_9 | Lean.Parser.Term | IO Unit |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.eq_of_one_to_one.match_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (motive : Fin ((SimplexCategory.mk 1).len + 1) → Prop) (i : Fin ((SimplexCategory.mk 1).len + 1)),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → motive i |
Finset.Colex.isInitSeg_empty | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : LinearOrder α] {r : ℕ}, Finset.Colex.IsInitSeg ∅ r |
CategoryTheory.PreZeroHypercover.restrictIndex_I₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {T : C} (E : CategoryTheory.PreZeroHypercover T) {ι : Type w'}
(f : ι → E.I₀), (E.restrictIndex f).I₀ = ι |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.