name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Limits.HasLimit | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} → [inst_1 : CategoryTheory.Category.{v, u} C] → CategoryTheory.Functor J C → Prop |
Std.ExtDHashMap.size_inter_eq_size_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (∀ a ∈ m₁, a ∈ m₂) → (m₁ ∩ m₂).size = m₁.size |
Ideal.jacobson_eq_self_of_isMaximal | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} [H : I.IsMaximal], I.jacobson = I |
_private.Mathlib.GroupTheory.Perm.List.0.List.formPerm_ext_iff._simp_1_2 | Mathlib.GroupTheory.Perm.List | ∀ {α : Type u_1} {a : α} {l : List α}, (a :: l).Nodup = (a ∉ l ∧ l.Nodup) |
Nat.count_lt_card | Mathlib.Data.Nat.Count | ∀ {p : ℕ → Prop} [inst : DecidablePred p] {n : ℕ} (hp : (setOf p).Finite), p n → Nat.count p n < hp.toFinset.card |
Units.continuousConstSMul | Mathlib.Topology.Algebra.ConstMulAction | ∀ {M : Type u_1} {α : Type u_2} [inst : TopologicalSpace α] [inst_1 : Monoid M] [inst_2 : MulAction M α]
[ContinuousConstSMul M α], ContinuousConstSMul Mˣ α |
ContinuousMap.Homotopic.refl | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y)), f.Homotopic f |
IdemSemiring.ofSemiring._proof_7 | Mathlib.Algebra.Order.Kleene | ∀ {α : Type u_1} [inst : Semiring α] (h : ∀ (a : α), a + a = a) (a b : α), a + b = a ⊔ b |
AlgebraicGeometry.Scheme.OpenCover.isColimitCoconeOfLocallyDirected._proof_1 | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [inst : CategoryTheory.Category.{u_3, u_1} 𝒰.I₀]
[inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰]
(s : CategoryTheory.Limits.Cocone (AlgebraicGeometry.Scheme.Cover.functorOfLocallyDirected 𝒰)) {i j : 𝒰.I₀}
(x : i ⟶ j),
CategoryTheory.CategoryStruct.comp ((AlgebraicGeometry.Scheme.Cover.functorOfLocallyDirected 𝒰).map x) (s.ι.app j) =
CategoryTheory.CategoryStruct.comp (s.ι.app i) (((CategoryTheory.Functor.const 𝒰.I₀).obj s.pt).map x) |
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.noConfusionType | Mathlib.CategoryTheory.Monoidal.Action.Basic | Sort u →
{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] →
[inst_2 : CategoryTheory.MonoidalCategoryStruct C] →
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct C D →
{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'] →
[inst'_2 : CategoryTheory.MonoidalCategoryStruct C'] →
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct C' D' → Sort u |
Vector.mk_lt_mk | Init.Data.Vector.Lex | ∀ {α : Type u_1} {n : ℕ} {data₁ : Array α} {size₁ : data₁.size = n} {data₂ : Array α} {size₂ : data₂.size = n}
[inst : LT α], Vector.mk data₁ size₁ < Vector.mk data₂ size₂ ↔ data₁ < data₂ |
MeasureTheory.laverage | Mathlib.MeasureTheory.Integral.Average | {α : Type u_1} → {m0 : MeasurableSpace α} → MeasureTheory.Measure α → (α → ENNReal) → ENNReal |
Lean.Language.Lean.SetupImportsResult.noConfusionType | Lean.Language.Lean | Sort u → Lean.Language.Lean.SetupImportsResult → Lean.Language.Lean.SetupImportsResult → Sort u |
Complex.UnitDisc.im | Mathlib.Analysis.Complex.UnitDisc.Basic | Complex.UnitDisc → ℝ |
Finset.singleton_product_singleton | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β}, {a} ×ˢ {b} = {(a, b)} |
Lean.IR.Expr.fap.noConfusion | Lean.Compiler.IR.Basic | {P : Sort u} →
{c : Lean.IR.FunId} →
{ys : Array Lean.IR.Arg} →
{c' : Lean.IR.FunId} →
{ys' : Array Lean.IR.Arg} → Lean.IR.Expr.fap c ys = Lean.IR.Expr.fap c' ys' → (c = c' → ys = ys' → P) → P |
ConjAct.units_smul_def | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ {M : Type u_2} [inst : Monoid M] (g : ConjAct Mˣ) (h : M),
g • h = ↑(ConjAct.ofConjAct g) * h * ↑(ConjAct.ofConjAct g)⁻¹ |
Std.Do.SPred.imp_curry | Std.Do.SPred.Laws | ∀ {σs : List (Type u)} {P Q : Std.Do.SVal.StateTuple σs → Prop},
((Std.Do.SVal.curry fun t => { down := P t }) → Std.Do.SVal.curry fun t => { down := Q t }) ⊣⊢ₛ
Std.Do.SVal.curry fun t => { down := P t → Q t } |
Lean.ForEachExprWhere.visited | Lean.Util.ForEachExprWhere | {ω : Type} →
{m : Type → Type} →
[inst : STWorld ω m] → [MonadLiftT (ST ω) m] → [Monad m] → Lean.Expr → Lean.ForEachExprWhere.ForEachM m Bool |
CategoryTheory.Presheaf.isSeparating | Mathlib.CategoryTheory.Generator.Presheaf | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A]
[inst_2 : CategoryTheory.Limits.HasCoproducts A] {ι : Type w} {S : ι → A},
(CategoryTheory.ObjectProperty.ofObj S).IsSeparating →
(CategoryTheory.ObjectProperty.ofObj fun x =>
match x with
| (X, i) => CategoryTheory.Presheaf.freeYoneda X (S i)).IsSeparating |
FirstOrder.Language.Substructure.gi | Mathlib.ModelTheory.Substructures | (L : FirstOrder.Language) →
(M : Type w) → [inst : L.Structure M] → GaloisInsertion (FirstOrder.Language.Substructure.closure L).toFun SetLike.coe |
ENNReal.tsum_const | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_4} (c : ENNReal), ∑' (x : α), c = ↑(ENat.card α) * c |
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_assoc._simp_1_1 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {α : Sort u_1} (a b : α), (a = b) = (a ≍ b) |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RankNat.0.SSet.Subcomplex.Pairing.isRegular_iff_nonempty_rankFunction.match_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RankNat | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) (motive : Nonempty (P.RankFunction ℕ) → Prop)
(x : Nonempty (P.RankFunction ℕ)), (∀ (h : P.RankFunction ℕ), motive ⋯) → motive x |
IsZGroup.mk._flat_ctor | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G], (∀ (p : ℕ), Nat.Prime p → ∀ (P : Sylow p G), IsCyclic ↥↑P) → IsZGroup G |
Lean.Lsp.InitializationOptions.mk.sizeOf_spec | Lean.Data.Lsp.InitShutdown | ∀ (hasWidgets? : Option Bool) (logCfg? : Option Lean.Lsp.LogConfig),
sizeOf { hasWidgets? := hasWidgets?, logCfg? := logCfg? } = 1 + sizeOf hasWidgets? + sizeOf logCfg? |
OrderIso.mulRight_symm | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [inst_2 : MulRightMono α] (a : α),
(OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ |
EuclideanGeometry.dist_div_cos_oangle_right_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P},
EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(Real.pi / 2) → dist p₃ p₂ / (EuclideanGeometry.oangle p₂ p₃ p₁).cos = dist p₁ p₃ |
MeasureTheory.Lp.toTemperedDistribution._proof_9 | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℂ F], SMulCommClass ℝ ℂ F |
MeasureTheory.spanningSetsIndex.congr_simp | Mathlib.MeasureTheory.Integral.Lebesgue.Countable | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ μ_1 : MeasureTheory.Measure α) (e_μ : μ = μ_1)
[inst : MeasureTheory.SigmaFinite μ] (x x_1 : α),
x = x_1 → MeasureTheory.spanningSetsIndex μ x = MeasureTheory.spanningSetsIndex μ_1 x_1 |
dist_le_tsum_dist_of_tendsto | Mathlib.Topology.Algebra.InfiniteSum.Real | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {f : ℕ → α} {a : α},
(Summable fun n => dist (f n) (f n.succ)) →
Filter.Tendsto f Filter.atTop (nhds a) → ∀ (n : ℕ), dist (f n) a ≤ ∑' (m : ℕ), dist (f (n + m)) (f (n + m).succ) |
CategoryTheory.Pseudofunctor.StrongTrans.Modification.recOn | Mathlib.CategoryTheory.Bicategory.Modification.Pseudo | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.Pseudofunctor B C} →
{η θ : F ⟶ G} →
{motive : CategoryTheory.Pseudofunctor.StrongTrans.Modification η θ → Sort u} →
(t : CategoryTheory.Pseudofunctor.StrongTrans.Modification η θ) →
((app : (a : B) → η.app a ⟶ θ.app a) →
(naturality :
∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (app b))
(θ.naturality f).hom =
CategoryTheory.CategoryStruct.comp (η.naturality f).hom
(CategoryTheory.Bicategory.whiskerRight (app a) (G.map f))) →
motive { app := app, naturality := naturality }) →
motive t |
ContinuousMap.instNonUnitalRingOfIsTopologicalRing._proof_3 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : NonUnitalRing β] [IsTopologicalRing β], ContinuousNeg β |
_private.Mathlib.RingTheory.Extension.Presentation.Core.0.Algebra.Presentation.tensorModelOfHasCoeffsInv._simp_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) |
_private.Mathlib.Topology.Algebra.Valued.ValuedField.0.Valued.extensionValuation._simp_3 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {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) |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valued.integer.totallyBounded_iff_finite_residueField._simp_1_9 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {α : Type u_2} [inst : SeminormedRing α] [NormOneClass α] [NormMulClass α] (a : α) (n : ℕ), ‖a‖ ^ n = ‖a ^ n‖ |
ProbabilityTheory.IsMeasurableRatCDF.measure_stieltjesFunction_univ | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : ProbabilityTheory.IsMeasurableRatCDF f) (a : α),
(hf.stieltjesFunction a).measure Set.univ = 1 |
RingCon.recOn | Mathlib.RingTheory.Congruence.Defs | {R : Type u_1} →
[inst : Add R] →
[inst_1 : Mul R] →
{motive : RingCon R → Sort u} →
(t : RingCon R) →
((toCon : Con R) →
(add' : ∀ {w x y z : R}, toCon.toSetoid w x → toCon.toSetoid y z → toCon.toSetoid (w + y) (x + z)) →
motive { toCon := toCon, add' := add' }) →
motive t |
Lean.IR.IRType.brecOn | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
{motive_2 : Array Lean.IR.IRType → Sort u} →
{motive_3 : List Lean.IR.IRType → Sort u} →
(t : Lean.IR.IRType) →
((t : Lean.IR.IRType) → t.below → motive_1 t) →
((t : Array Lean.IR.IRType) → Lean.IR.IRType.below_1 t → motive_2 t) →
((t : List Lean.IR.IRType) → Lean.IR.IRType.below_2 t → motive_3 t) → motive_1 t |
FreeAbelianGroup.map.eq_1 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u} {β : Type v} (f : α → β), FreeAbelianGroup.map f = FreeAbelianGroup.lift (FreeAbelianGroup.of ∘ f) |
Std.DTreeMap.insertManyIfNew | Std.Data.DTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
{ρ : Type u_1} → [ForIn Id ρ ((a : α) × β a)] → Std.DTreeMap α β cmp → ρ → Std.DTreeMap α β cmp |
AlgebraicGeometry.Scheme.GlueData.oneHypercover_Y | Mathlib.AlgebraicGeometry.GluingOneHypercover | ∀ (D : AlgebraicGeometry.Scheme.GlueData) (i₁ i₂ : D.J) (x : PUnit.{u + 1}), D.oneHypercover.Y x = D.V (i₁, i₂) |
CategoryTheory.Limits.coprod.rightUnitor._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
[inst_2 : CategoryTheory.Limits.HasInitial C] (P : C),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
(CategoryTheory.Limits.coprod.desc (CategoryTheory.CategoryStruct.id P) (CategoryTheory.Limits.initial.to P)) =
CategoryTheory.CategoryStruct.id P |
MvPolynomial.scalarRTensor_symm_apply_single | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ {R : Type u} {N : Type v} [inst : CommSemiring R] {σ : Type u_1} [inst_1 : DecidableEq σ] [inst_2 : AddCommMonoid N]
[inst_3 : Module R N] (d : σ →₀ ℕ) (n : N),
(MvPolynomial.scalarRTensor.symm fun₀ | d => n) = (MvPolynomial.monomial d) 1 ⊗ₜ[R] n |
Submodule.factor_surjective | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {p p' : Submodule R M}
(H : p ≤ p'), Function.Surjective ⇑(Submodule.factor H) |
OrderMonoidIso.mk.inj | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_6} {β : Type u_7} {inst : Preorder α} {inst_1 : Preorder β} {inst_2 : Mul α} {inst_3 : Mul β}
{toMulEquiv : α ≃* β} {map_le_map_iff' : ∀ {a b : α}, toMulEquiv.toFun a ≤ toMulEquiv.toFun b ↔ a ≤ b}
{toMulEquiv_1 : α ≃* β} {map_le_map_iff'_1 : ∀ {a b : α}, toMulEquiv_1.toFun a ≤ toMulEquiv_1.toFun b ↔ a ≤ b},
{ toMulEquiv := toMulEquiv, map_le_map_iff' := map_le_map_iff' } =
{ toMulEquiv := toMulEquiv_1, map_le_map_iff' := map_le_map_iff'_1 } →
toMulEquiv = toMulEquiv_1 |
ONote.opowAux.eq_def | Mathlib.SetTheory.Ordinal.Notation | ∀ (e a0 a : ONote) (x x_1 : ℕ),
e.opowAux a0 a x x_1 =
match x, x_1 with
| x, 0 => 0
| 0, m.succ => e.oadd m.succPNat 0
| k.succ, m => (e + a0.mulNat k).scale a + e.opowAux a0 a k m |
AlgebraicClosure.instField._proof_1 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k] (q : ℚ≥0), ↑q = ↑q.num / ↑q.den |
ContinuousMultilinearMap.toContinuousLinearMap._proof_1 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u_4} {ι : Type u_3} {M₁ : ι → Type u_1} {M₂ : Type u_2} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
(f : ContinuousMultilinearMap R M₁ M₂) [inst_7 : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι),
Continuous (f.toFun ∘ Function.update m i) |
_private.Mathlib.RingTheory.Ideal.Height.0.exists_spanRank_le_and_le_height_of_le_height._simp_1_3 | Mathlib.RingTheory.Ideal.Height | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x |
_private.Mathlib.Condensed.Discrete.Colimit.0.LightCondensed.isoFinYonedaComponents_inv_comp._simp_1_2 | Mathlib.Condensed.Discrete.Colimit | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op |
mul_pos_iff | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [ExistsAddOfLE R] [PosMulStrictMono R]
[MulPosStrictMono R] [AddLeftStrictMono R] [AddLeftReflectLT R], 0 < a * b ↔ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0 |
CategoryTheory.Limits.parallelPair.ext._auto_3 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | Lean.Syntax |
instReprNum | Mathlib.Data.Num.Basic | Repr Num |
Array.toList_range' | Init.Data.Array.Lemmas | ∀ {start size step : ℕ}, (Array.range' start size step).toList = List.range' start size step |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.ordered_iff._simp_1_4 | Batteries.Data.RBMap.Lemmas | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) |
CategoryTheory.MorphismProperty.IsStableUnderTransfiniteCompositionOfShape.congr_simp | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W W_1 : CategoryTheory.MorphismProperty C),
W = W_1 →
∀ (J : Type w) [inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J],
W.IsStableUnderTransfiniteCompositionOfShape J = W_1.IsStableUnderTransfiniteCompositionOfShape J |
_private.Mathlib.Topology.Homotopy.Basic.0.ContinuousMap.homotopicRel_empty.match_1_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
(motive : f₀.Homotopic f₁ → Prop) (x : f₀.Homotopic f₁), (∀ (F : f₀.Homotopy f₁), motive ⋯) → motive x |
Equiv.Perm.sumCongrHom.decidableMemRange | Mathlib.GroupTheory.Perm.Subgroup | {α : Type u_1} →
{β : Type u_2} →
[DecidableEq α] →
[DecidableEq β] → [Fintype α] → [Fintype β] → DecidablePred fun x => x ∈ (Equiv.Perm.sumCongrHom α β).range |
QuadraticAlgebra.instCommRing._proof_5 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : CommRing R] (a_1 b_1 c : QuadraticAlgebra R a b), a_1 * b_1 * c = a_1 * (b_1 * c) |
SkewMonoidAlgebra.mapDomain_comp | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {G' : Type u_3} {G'' : Type u_4} {f : G → G'} {g : G' → G''}
{v : SkewMonoidAlgebra k G},
(SkewMonoidAlgebra.mapDomain (g ∘ f)) v = (SkewMonoidAlgebra.mapDomain g) ((SkewMonoidAlgebra.mapDomain f) v) |
MulEquiv.toMagmaCatIso.eq_1 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y : Type u} [inst : Mul X] [inst_1 : Mul Y] (e : X ≃* Y),
e.toMagmaCatIso =
{ hom := MagmaCat.ofHom e.toMulHom, inv := MagmaCat.ofHom e.symm.toMulHom, hom_inv_id := ⋯, inv_hom_id := ⋯ } |
exists_isCompact_superset_iff._simp_1 | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R1Space X] {s : Set X}, (∃ K, IsCompact K ∧ s ⊆ K) = IsCompact (closure s) |
AlgebraicGeometry.Scheme.fromSpecStalk_closedPoint | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} {x : ↥X}, (X.fromSpecStalk x) (IsLocalRing.closedPoint ↑(X.presheaf.stalk x)) = x |
_private.Batteries.Tactic.Lint.Frontend.0.Batteries.Tactic.Lint.lintCore.match_1 | Batteries.Tactic.Lint.Frontend | (motive : Except Lean.Exception (Option Lean.MessageData) → Sort u_1) →
(x : Except Lean.Exception (Option Lean.MessageData)) →
((msg? : Option Lean.MessageData) → motive (Except.ok msg?)) →
((err : Lean.Exception) → motive (Except.error err)) → motive x |
SubalgebraClass.val._proof_3 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {S : Type u_2} {A : Type u_1} [inst : Semiring A] [inst_1 : SetLike S A] [inst_2 : SubsemiringClass S A] (s : S)
(x y : ↥s),
(↑↑(SubsemiringClass.subtype s)).toFun (x * y) =
(↑↑(SubsemiringClass.subtype s)).toFun x * (↑↑(SubsemiringClass.subtype s)).toFun y |
ProbabilityTheory.poissonPMFReal_pos | Mathlib.Probability.Distributions.Poisson.Basic | ∀ {r : NNReal} {n : ℕ}, 0 < r → 0 < ProbabilityTheory.poissonPMFReal r n |
Vector.insertIdx_eraseIdx_of_le._proof_4 | Init.Data.Vector.InsertIdx | ∀ {n i : ℕ} {j : ℕ}, i < n → i + 1 < n + 1 |
Mathlib.Tactic.Widget.StringDiagram.IdNode.mk._flat_ctor | Mathlib.Tactic.Widget.StringDiagram | ℕ → ℕ → ℕ → Mathlib.Tactic.BicategoryLike.Atom₁ → Mathlib.Tactic.Widget.StringDiagram.IdNode |
Batteries.RBSet.findP?_insert_of_eq | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {v : α} [Std.TransCmp cmp]
[Batteries.RBNode.IsStrictCut cmp cut] (t : Batteries.RBSet α cmp),
cut v = Ordering.eq → (t.insert v).findP? cut = some v |
_private.Mathlib.RingTheory.MvPowerSeries.Basic.0.MvPowerSeries.instNontrivialSubalgebraOfNonempty._simp_1 | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {x : A},
(x ∈ ⊥) = (x ∈ Set.range ⇑(algebraMap R A)) |
Batteries.BinomialHeap.Imp.Heap.tail | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} → (α → α → Bool) → Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α |
Lean.Meta.altArity | Lean.Meta.Tactic.ElimInfo | Lean.Expr → ℕ → Lean.Expr → ℕ × Bool |
UInt64.toNat_or | Init.Data.UInt.Bitwise | ∀ (a b : UInt64), (a ||| b).toNat = a.toNat ||| b.toNat |
Aesop.RuleState.erasePatSubst | Aesop.Forward.State | Aesop.Substitution → Aesop.PatSubstSource → Aesop.RuleState → Aesop.RuleState |
Height.mulHeight_eq_mulHeight_restrict_support | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} [Finite ι] (x : ι → K),
Height.mulHeight x = Height.mulHeight fun i => x ↑i |
Nat.factorial_two | Mathlib.Data.Nat.Factorial.Basic | Nat.factorial 2 = 2 |
ContMDiffVectorBundle.casesOn | Mathlib.Geometry.Manifold.VectorBundle.Basic | {n : WithTop ℕ∞} →
{𝕜 : Type u_1} →
{B : Type u_2} →
{F : Type u_4} →
{E : B → Type u_6} →
[inst : NontriviallyNormedField 𝕜] →
{EB : Type u_7} →
[inst_1 : NormedAddCommGroup EB] →
[inst_2 : NormedSpace 𝕜 EB] →
{HB : Type u_8} →
[inst_3 : TopologicalSpace HB] →
{IB : ModelWithCorners 𝕜 EB HB} →
[inst_4 : TopologicalSpace B] →
[inst_5 : ChartedSpace HB B] →
[inst_6 : (x : B) → AddCommMonoid (E x)] →
[inst_7 : (x : B) → Module 𝕜 (E x)] →
[inst_8 : NormedAddCommGroup F] →
[inst_9 : NormedSpace 𝕜 F] →
[inst_10 : TopologicalSpace (Bundle.TotalSpace F E)] →
[inst_11 : (x : B) → TopologicalSpace (E x)] →
[inst_12 : FiberBundle F E] →
[inst_13 : VectorBundle 𝕜 F E] →
{motive : ContMDiffVectorBundle n F E IB → Sort u} →
(t : ContMDiffVectorBundle n F E IB) →
((contMDiffOn_coordChangeL :
∀ (e e' : Bundle.Trivialization F Bundle.TotalSpace.proj)
[inst_14 : MemTrivializationAtlas e]
[inst_15 : MemTrivializationAtlas e'],
ContMDiffOn IB (modelWithCornersSelf 𝕜 (F →L[𝕜] F)) n
(fun b => ↑(Bundle.Trivialization.coordChangeL 𝕜 e e' b))
(e.baseSet ∩ e'.baseSet)) →
motive ⋯) →
motive t |
Std.ExtTreeSet.getD_minD | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp],
t ≠ ∅ → ∀ {fallback fallback' : α}, t.getD (t.minD fallback) fallback' = t.minD fallback |
WeierstrassCurve.Jacobian.polynomialZ | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | {R : Type r} → [inst : CommRing R] → WeierstrassCurve.Jacobian R → MvPolynomial (Fin 3) R |
Std.DHashMap.Internal.AssocList.foldrM._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{δ : Type w} →
{m : Type w → Type w'} → [Monad m] → ((a : α) → β a → δ → m δ) → δ → Std.DHashMap.Internal.AssocList α β → m δ |
ArithmeticFunction.prodPrimeFactors | Mathlib.NumberTheory.ArithmeticFunction.Misc | {R : Type u_1} → [inst : CommMonoidWithZero R] → (ℕ → R) → ArithmeticFunction R |
Std.Internal.IO.Async.Waiter.race | Std.Internal.Async.Select | {m : Type → Type} →
{α β : Type} →
[Monad m] →
[MonadLiftT (ST IO.RealWorld) m] →
Std.Internal.IO.Async.Waiter α → m β → (IO.Promise (Except IO.Error α) → m β) → m β |
WithTop.add_left_cancel | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] {x y z : WithTop α} [IsLeftCancelAdd α], x ≠ ⊤ → x + y = x + z → y = z |
Std.ExtHashMap.getElem_map | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
{f : α → β → γ} {k : α} {h' : k ∈ Std.ExtHashMap.map f m}, (Std.ExtHashMap.map f m)[k] = f k m[k] |
MeasureTheory.Measure.InnerRegularWRT.comap | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure β}
{pa qa : Set α → Prop} {pb qb : Set β → Prop},
μ.InnerRegularWRT pb qb →
∀ {f : α → β},
MeasurableEmbedding f →
(∀ (U : Set α), qa U → qb (f '' U)) →
(∀ K ⊆ Set.range f, pb K → pa (f ⁻¹' K)) → (MeasureTheory.Measure.comap f μ).InnerRegularWRT pa qa |
_private.Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas.0.IsDedekindDomain.HeightOneSpectrum.iInf_localization_eq_bot.match_1_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ (R : Type u_1) [inst : CommRing R] (motive : MaximalSpectrum R → Prop) (x : MaximalSpectrum R),
(∀ (v : Ideal R) (hv : v.IsMaximal), motive { asIdeal := v, isMaximal := hv }) → motive x |
Lean.Widget.InfoPopup.exprExplicit | Lean.Server.FileWorker.WidgetRequests | Lean.Widget.InfoPopup → Option Lean.Widget.CodeWithInfos |
Continuous.nnnorm' | Mathlib.Analysis.Normed.Group.Continuity | ∀ {α : Type u_1} {E : Type u_4} [inst : SeminormedGroup E] [inst_1 : TopologicalSpace α] {f : α → E},
Continuous f → Continuous fun x => ‖f x‖₊ |
ENat.le_ceil_self | Mathlib.Algebra.Order.Floor.Extended | ∀ {r : ENNReal}, r ≤ ↑⌈r⌉ₑ |
NonUnitalSubring.mk_le_mk | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {S S' : NonUnitalSubsemiring R}
(h : ∀ {x : R}, x ∈ S.carrier → -x ∈ S.carrier) (h' : ∀ {x : R}, x ∈ S'.carrier → -x ∈ S'.carrier),
{ toNonUnitalSubsemiring := S, neg_mem' := h } ≤ { toNonUnitalSubsemiring := S', neg_mem' := h' } ↔ S ≤ S' |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3._aux_Mathlib_Util_Notation3___elabRules_Mathlib_Notation3_notation3_1.match_3 | Mathlib.Util.Notation3 | (motive : Array (Lean.TSyntax `stx) × Array Lean.Syntax → Sort u_1) →
(__discr : Array (Lean.TSyntax `stx) × Array Lean.Syntax) →
((syntaxArgs : Array (Lean.TSyntax `stx)) → (pattArgs : Array Lean.Syntax) → motive (syntaxArgs, pattArgs)) →
motive __discr |
subset_seqClosure | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, s ⊆ seqClosure s |
CategoryTheory.ShiftedHom.opEquiv' | Mathlib.CategoryTheory.Shift.ShiftedHomOpposite | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
{X Y : C} →
(n a a' : ℤ) →
n + a = a' →
CategoryTheory.ShiftedHom X Y a' ≃
(Opposite.op ((CategoryTheory.shiftFunctor C a).obj Y) ⟶
(CategoryTheory.shiftFunctor Cᵒᵖ n).obj (Opposite.op X)) |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.AnalyzeResult | Lean.Elab.Extra | Type |
Std.DTreeMap.Internal.Impl.get?.match_1.congr | Std.Data.DTreeMap.Internal.Model | ∀ {α : Sort u} {o o' : Ordering} {lt : o = Ordering.lt → α} {eq : o = Ordering.eq → α} {gt : o = Ordering.gt → α}
{lt' : o' = Ordering.lt → α} {eq' : o' = Ordering.eq → α} {gt' : o' = Ordering.gt → α} (ho : o = o'),
(∀ (h : o' = Ordering.lt), lt ⋯ = lt' h) →
(∀ (h : o' = Ordering.eq), eq ⋯ = eq' h) →
(∀ (h : o' = Ordering.gt), gt ⋯ = gt' h) →
(match h : o with
| Ordering.lt => lt h
| Ordering.gt => gt h
| Ordering.eq => eq h) =
match h : o' with
| Ordering.lt => lt' h
| Ordering.gt => gt' h
| Ordering.eq => eq' h |
RingEquiv.ringKrullDim | Mathlib.RingTheory.KrullDimension.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (e : R ≃+* S),
ringKrullDim R = ringKrullDim S |
CochainComplex.HomComplex.Cochain.fromSingleMk.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {p q : ℤ} (f f_1 : X ⟶ K.X q),
f = f_1 →
∀ {n : ℤ} (x : p + n = q) (T : CochainComplex.HomComplex.Triplet n),
CochainComplex.HomComplex.Cochain.fromSingleMk f x T = CochainComplex.HomComplex.Cochain.fromSingleMk f_1 x T |
_private.Mathlib.Probability.Decision.Risk.Defs.0.ProbabilityTheory.bayesRisk_of_isEmpty'._simp_1_1 | Mathlib.Probability.Decision.Risk.Defs | ∀ {α : Sort u_1} (p : α → Prop), IsEmpty (Subtype p) = ∀ (x : α), ¬p x |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.Mathlib.Meta.Positivity.evalNNRealRpow.match_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) → Sort u_1) →
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e)) →
((α : Q(Type)) →
(x : Q(Zero «$α»)) →
(x_2 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_2 e)) →
motive Lean.Level.zero x x_2 e __alt __alt_2) →
((x : Lean.Level) →
(α : Q(Type x)) →
(x_2 : Q(Zero «$α»)) →
(x_3 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness x_2 x_3 e)) →
motive x x_2 x_3 e __alt __alt_2) →
motive u x x_1 e __alt __alt_1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.