name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Int16.lt_of_lt_of_le | Init.Data.SInt.Lemmas | ∀ {a b c : Int16}, a < b → b ≤ c → a < c |
Vector.setIfInBounds_setIfInBounds | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} (a : α) {b : α} {xs : Vector α n},
(xs.setIfInBounds i a).setIfInBounds i b = xs.setIfInBounds i b |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction_actionRight_op | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (c : C) {d d' : D} (f : d ⟶ d'),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight (Opposite.op c) f.op =
Opposite.op (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight c f) |
CategoryTheory.Functor.FullyFaithful.ofFullyFaithful | Mathlib.CategoryTheory.Functor.FullyFaithful | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) → [F.Full] → [F.Faithful] → F.FullyFaithful |
Int.Linear.eq_coeff | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p p' : Int.Linear.Poly) (k : ℤ),
Int.Linear.eq_coeff_cert p p' k = true → Int.Linear.Poly.denote' ctx p = 0 → Int.Linear.Poly.denote' ctx p' = 0 |
Prod.gameAdd_mk_iff | Mathlib.Order.GameAdd | ∀ {α : Type u_1} {β : Type u_2} {rα : α → α → Prop} {rβ : β → β → Prop} {a₁ a₂ : α} {b₁ b₂ : β},
Prod.GameAdd rα rβ (a₁, b₁) (a₂, b₂) ↔ rα a₁ a₂ ∧ b₁ = b₂ ∨ rβ b₁ b₂ ∧ a₁ = a₂ |
Fin.instCommRing._proof_11 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) [inst : NeZero n] (n_1 : ℕ), ↑(n_1 + 1) = ↑n_1 + 1 |
_private.Mathlib.Topology.Order.LiminfLimsup.0.tendsto_iSup_of_tendsto_limsup._simp_1_2 | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b |
CategoryTheory.Functor.LaxBraided.ofNatIso | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{D : Type u₂} →
[inst_3 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_4 : CategoryTheory.MonoidalCategory D] →
[inst_5 : CategoryTheory.BraidedCategory D] →
{F G : CategoryTheory.Functor C D} →
(i : F ≅ G) →
[inst_6 : F.LaxBraided] →
[inst_7 : G.LaxMonoidal] → [CategoryTheory.NatTrans.IsMonoidal i.hom] → G.LaxBraided |
FormalMultilinearSeries.compContinuousLinearMap | Mathlib.Analysis.Calculus.FormalMultilinearSeries | {𝕜 : Type u} →
{E : Type v} →
{F : Type w} →
{G : Type x} →
[inst : Semiring 𝕜] →
[inst_1 : AddCommMonoid E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : ContinuousAdd E] →
[inst_5 : ContinuousConstSMul 𝕜 E] →
[inst_6 : AddCommMonoid F] →
[inst_7 : Module 𝕜 F] →
[inst_8 : TopologicalSpace F] →
[inst_9 : ContinuousAdd F] →
[inst_10 : ContinuousConstSMul 𝕜 F] →
[inst_11 : AddCommMonoid G] →
[inst_12 : Module 𝕜 G] →
[inst_13 : TopologicalSpace G] →
[inst_14 : ContinuousAdd G] →
[inst_15 : ContinuousConstSMul 𝕜 G] →
FormalMultilinearSeries 𝕜 F G → (E →L[𝕜] F) → FormalMultilinearSeries 𝕜 E G |
RingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J RingCat) →
[Small.{u, max u v} ↑(F.comp (CategoryTheory.forget RingCat)).sections] →
CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ RingCat SemiRingCat) |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Beta.0.Complex.betaIntegral_symm._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Gamma.Beta | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ}
(a b : ℝ), -∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ) in b..a, f x ∂μ |
CStarAlgebra.mk | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
[toNormedRing : NormedRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedAlgebra : NormedAlgebra ℂ A] → [toStarModule : StarModule ℂ A] → CStarAlgebra A |
Nat.instConditionallyCompleteLinearOrderBot | Mathlib.Data.Nat.Lattice | ConditionallyCompleteLinearOrderBot ℕ |
Lean.TSyntax.instCoeNumLitPrec | Init.Meta.Defs | Coe Lean.NumLit Lean.Prec |
Pi.measurableMul | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {ι : Type u_5} {α : ι → Type u_6} [inst : (i : ι) → Mul (α i)] [inst_1 : (i : ι) → MeasurableSpace (α i)]
[∀ (i : ι), MeasurableMul (α i)], MeasurableMul ((i : ι) → α i) |
FP.Float.nan | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → FP.Float |
_private.Mathlib.Tactic.LinearCombination.0.Mathlib.Tactic.LinearCombination.elabLinearCombination.match_3 | Mathlib.Tactic.LinearCombination | (motive : Option Lean.Term → Sort u_1) →
(input : Option Lean.Term) → (Unit → motive none) → ((e : Lean.Term) → motive (some e)) → motive input |
Array.any_eq_true' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α}, as.any p = true ↔ ∃ x ∈ as, p x = true |
ContinuousLinearMap.isInvertible_comp_equiv._simp_1 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} {M₃ : Type u_4} [inst : TopologicalSpace M]
[inst_1 : TopologicalSpace M₂] [inst_2 : TopologicalSpace M₃] [inst_3 : Semiring R] [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid M₂] [inst_7 : Module R M₂] [inst_8 : AddCommMonoid M₃]
[inst_9 : Module R M₃] {e : M₃ ≃L[R] M} {f : M →L[R] M₂}, (f.comp ↑e).IsInvertible = f.IsInvertible |
Aesop.Frontend.Feature.ctorElim | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.Feature → Sort u} →
(ctorIdx : ℕ) →
(t : Aesop.Frontend.Feature) → ctorIdx = t.ctorIdx → Aesop.Frontend.Feature.ctorElimType ctorIdx → motive t |
UInt32.reduceAdd._regBuiltin.UInt32.reduceAdd.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2998934274._hygCtx._hyg.35 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
Set.prod_pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] (s : Set α) (t : Set β) (n : ℕ),
s ×ˢ t ^ n = (s ^ n) ×ˢ (t ^ n) |
_private.Mathlib.Data.ENNReal.Real.0.Mathlib.Meta.Positivity.evalENNRealOfReal.match_1 | Mathlib.Data.ENNReal.Real | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e) → Sort u_1) →
(u : Lean.Level) →
{α : Q(Type u)} →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e)) →
((α : Q(Type)) →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e)) →
motive Lean.Level.zero _zα _pα e __alt __alt_2) →
((x : Lean.Level) →
(α : Q(Type x)) →
(_zα : Q(Zero «$α»)) →
(_pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα _pα e)) →
motive x _zα _pα e __alt __alt_2) →
motive u _zα _pα e __alt __alt_1 |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_mon_mul_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D]
(F : CategoryTheory.Functor C (CategoryTheory.CommMon D)) (X : C),
CategoryTheory.MonObj.mul.app X = CategoryTheory.MonObj.mul |
AddSubmonoid.fromLeftNeg_leftNegEquiv_symm | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : AddCommMonoid M] (S : AddSubmonoid M) (hS : S ≤ IsAddUnit.addSubmonoid M) (x : ↥S),
S.fromLeftNeg ((S.leftNegEquiv hS).symm x) = x |
AlgebraicGeometry.Scheme.instHasPullbacksPrecoverageOfHasPullbacks | Mathlib.AlgebraicGeometry.Sites.MorphismProperty | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) [P.HasPullbacks],
(AlgebraicGeometry.Scheme.precoverage P).HasPullbacks |
Lean.Elab.Tactic.MkSimpContextResult.rec | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.MkSimpContextResult → Sort u} →
((ctx : Lean.Meta.Simp.Context) →
(simprocs : Lean.Meta.Simp.SimprocsArray) →
(dischargeWrapper : Lean.Elab.Tactic.Simp.DischargeWrapper) →
(simpArgs : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)) →
motive { ctx := ctx, simprocs := simprocs, dischargeWrapper := dischargeWrapper, simpArgs := simpArgs }) →
(t : Lean.Elab.Tactic.MkSimpContextResult) → motive t |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_8 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {x : α} [inst : BEq α] (h : 1 ≤ (List.filter (fun x_1 => x_1 == x) xs).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length |
_private.Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset.0.Finset.inv_op_smul_finset_distrib₀._simp_1_3 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : GroupWithZero α] [inst_2 : MulAction α β]
{s : Finset β} {a : α} {b : β}, a ≠ 0 → (b ∈ a • s) = (a⁻¹ • b ∈ s) |
CategoryTheory.Limits.Sigma.whiskerEquiv_hom | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u_1} {K : Type u_2} {f : J → C} {g : K → C}
(e : J ≃ K) (w : (j : J) → g (e j) ≅ f j) [inst_1 : CategoryTheory.Limits.HasCoproduct f]
[inst_2 : CategoryTheory.Limits.HasCoproduct g],
(CategoryTheory.Limits.Sigma.whiskerEquiv e w).hom = CategoryTheory.Limits.Sigma.map' ⇑e fun j => (w j).inv |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_15 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → ℕ |
LinearMap.mulLeft._proof_2 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ (R : Type u_2) {A : Type u_1} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[SMulCommClass R A A] (a : A) (x : R) (y : A), a * x • y = x • (a * y) |
Std.Iter.toList_zip_of_finite_left | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ α₂ β₁ β₂ : Type u_1} [inst : Std.Iterator α₁ Id β₁] [inst_1 : Std.Iterator α₂ Id β₂] {it₁ : Std.Iter β₁}
{it₂ : Std.Iter β₂} [Std.Iterators.Finite α₁ Id] [Std.Iterators.Productive α₂ Id],
(it₁.zip it₂).toList = it₁.toList.zip (Std.Iter.take it₁.toList.length it₂).toList |
IsTopologicalGroup.mulInvClosureNhd.casesOn | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} →
[inst : TopologicalSpace G] →
{T W : Set G} →
[inst_1 : Group G] →
{motive : IsTopologicalGroup.mulInvClosureNhd T W → Sort u} →
(t : IsTopologicalGroup.mulInvClosureNhd T W) →
((nhds : T ∈ nhds 1) → (inv : T⁻¹ = T) → (isOpen : IsOpen T) → (mul : W * T ⊆ W) → motive ⋯) → motive t |
Ordnode.insert'._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α |
CategoryTheory.Adjunction.right_triangle_components_assoc | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {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} (self : F ⊣ G) (Y : D) {Z : C} (h : G.obj Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.unit.app (G.obj Y))
(CategoryTheory.CategoryStruct.comp (G.map (self.counit.app Y)) h) =
h |
RingHom.FiniteType.of_surjective | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] (f : A →+* B),
Function.Surjective ⇑f → f.FiniteType |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.Shape.casesOn | Lean.Meta.MkIffOfInductiveProp | {motive : Lean.Meta.Shape✝ → Sort u} →
(t : Lean.Meta.Shape✝¹) →
((variablesKept : List Bool) → (neqs : Option ℕ) → motive { variablesKept := variablesKept, neqs := neqs }) →
motive t |
Ring.DirectLimit.congr._proof_6 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i →+* G j} {G' : ι → Type u_3} [inst_2 : (i : ι) → CommRing (G' i)]
{f' : (i j : ι) → i ≤ j → G' i →+* G' j} (e : (i : ι) → G i ≃+* G' i),
(∀ (i j : ι) (h : i ≤ j), (e j).toRingHom.comp (f i j h) = (f' i j h).comp ↑(e i)) →
∀ (i j : ι) (h : i ≤ j), (↑(e j).symm).comp (f' i j h) = (f i j h).comp ↑(e i).symm |
RingQuot.ringQuotToIdealQuotient | Mathlib.Algebra.RingQuot | {B : Type uR} → [inst : CommRing B] → (r : B → B → Prop) → RingQuot r →+* B ⧸ Ideal.ofRel r |
Std.Format.noConfusion | Init.Data.Format.Basic | {P : Sort u} → {t t' : Std.Format} → t = t' → Std.Format.noConfusionType P t t' |
Rat.cast_lt_natCast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℚ} {n : ℕ}, (↑m < ↑n) = (m < ↑n) |
List.maximum_of_length_pos_mem | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] {l : List α} (h : 0 < l.length), List.maximum_of_length_pos h ∈ l |
Lean.Json.below | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
{motive_2 : Array Lean.Json → Sort u} →
{motive_3 : Std.TreeMap.Raw String Lean.Json compare → Sort u} →
{motive_4 : List Lean.Json → Sort u} →
{motive_5 : Std.DTreeMap.Raw String (fun x => Lean.Json) compare → Sort u} →
{motive_6 : (Std.DTreeMap.Internal.Impl String fun x => Lean.Json) → Sort u} → Lean.Json → Sort (max 1 u) |
Num.commSemiring._proof_5 | Mathlib.Data.Num.Lemmas | ∀ (x : Num), 0 * x = 0 |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_eq_of_equiv | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0),
f ≈ g → padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑g (PadicSeq.stationaryPoint hg)) |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform_map_whiskerRight | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A₁] [inst_4 : CategoryTheory.Category.{v₅, u₅} B₁]
[inst_5 : CategoryTheory.Category.{v₆, u₆} C₁] {F₁ : CategoryTheory.Functor A₁ B₁} {G₁ : CategoryTheory.Functor C₁ B₁}
{A₂ : Type u₇} {B₂ : Type u₈} {C₂ : Type u₉} [inst_6 : CategoryTheory.Category.{v₇, u₇} A₂]
[inst_7 : CategoryTheory.Category.{v₈, u₈} B₂] [inst_8 : CategoryTheory.Category.{v₉, u₉} C₂]
{F₂ : CategoryTheory.Functor A₂ B₂} {G₂ : CategoryTheory.Functor C₂ B₂} (X : Type u₇)
[inst_9 : CategoryTheory.Category.{v₇, u₇} X] {ψ ψ' : CategoryTheory.Limits.CatCospanTransform F G F₁ G₁} (α : ψ ⟶ ψ')
(φ : CategoryTheory.Limits.CatCospanTransform F₁ G₁ F₂ G₂),
(CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform X).map
(CategoryTheory.Limits.CatCospanTransformMorphism.whiskerRight α φ) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transformObjComp X ψ φ).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.whiskerRight
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform X).map α)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform X).obj φ))
(CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transformObjComp X ψ' φ).inv) |
Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn.eq | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | ∀ {motive : Mathlib.Tactic.BicategoryLike.NormalExpr → Sort u} (t : Mathlib.Tactic.BicategoryLike.NormalExpr)
(F_1 : (t : Mathlib.Tactic.BicategoryLike.NormalExpr) → Mathlib.Tactic.BicategoryLike.NormalExpr.below t → motive t),
Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn t F_1 =
F_1 t (Mathlib.Tactic.BicategoryLike.NormalExpr.brecOn.go t F_1).2 |
Function.locallyFinsuppWithin.closedSupport | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [T1Space X] [inst_2 : Zero Y]
(D : Function.locallyFinsuppWithin U Y), IsClosed U → IsClosed D.support |
Lean.StructureResolutionState.ctorIdx | Lean.Structure | Lean.StructureResolutionState → ℕ |
CategoryTheory.CostructuredArrow.mk_hom_eq_self | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {Y : C} {S : CategoryTheory.Functor C D} (f : S.obj Y ⟶ T), (CategoryTheory.CostructuredArrow.mk f).hom = f |
SubNegMonoid.sub._default | Mathlib.Algebra.Group.Defs | {G : Type u} →
(add : G → G → G) →
(∀ (a b c : G), a + b + c = a + (b + c)) →
(zero : G) →
(∀ (a : G), 0 + a = a) →
(∀ (a : G), a + 0 = a) →
(nsmul : ℕ → G → G) →
(∀ (x : G), nsmul 0 x = 0) → (∀ (n : ℕ) (x : G), nsmul (n + 1) x = nsmul n x + x) → (G → G) → G → G → G |
sub_eq_add_zero_sub | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : SubNegMonoid G] (a b : G), a - b = a + (0 - b) |
DiffeologicalSpace.mkOfClosure._proof_1 | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} (g : Set ((n : ℕ) × (EuclideanSpace ℝ (Fin n) → X))) {u : Set X},
TopologicalSpace.IsOpen u ↔ ∀ {n : ℕ}, ∀ p ∈ {p | ⟨n, p⟩ ∈ g}, IsOpen (p ⁻¹' u) |
DiscreteQuotient.comp_finsetClopens.match_1 | Mathlib.Topology.DiscreteQuotient | (X : Type u_1) →
[inst : TopologicalSpace X] →
(motive : DiscreteQuotient X → Sort u_2) →
(x : DiscreteQuotient X) →
((f : Setoid X) →
(isOpen_setOf_rel : ∀ (x : X), IsOpen (setOf (f x))) →
motive { toSetoid := f, isOpen_setOf_rel := isOpen_setOf_rel }) →
motive x |
iSupIndep.comp' | Mathlib.Order.SupIndep | ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Sort u_5} {ι' : Sort u_6} {t : ι → α} {f : ι' → ι},
iSupIndep (t ∘ f) → Function.Surjective f → iSupIndep t |
PrimeSpectrum.isIrreducible_iff_vanishingIdeal_isPrime | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] {s : Set (PrimeSpectrum R)},
IsIrreducible s ↔ (PrimeSpectrum.vanishingIdeal s).IsPrime |
bddAbove_preimage_toDual | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set αᵒᵈ}, BddAbove (⇑OrderDual.toDual ⁻¹' s) ↔ BddBelow s |
ENNReal.le_of_forall_nnreal_lt | Mathlib.Data.ENNReal.Inv | ∀ {x y : ENNReal}, (∀ (r : NNReal), ↑r < x → ↑r ≤ y) → x ≤ y |
CategoryTheory.FreeBicategory.Hom.ctorElimType | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{motive : (a a_1 : B) → CategoryTheory.FreeBicategory.Hom a a_1 → Sort u_1} →
ℕ →
Sort
(max 1 (imax (u + 1) u_1) (imax (u + 1) (u + 1) (u + 1) (max (u + 1) (v + 1)) (max (u + 1) (v + 1)) u_1)
(imax (u + 1) (u + 1) (v + 1) u_1)) |
LieIdeal.coe_toLieSubalgebra | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
↑(LieIdeal.toLieSubalgebra R L I) = ↑I |
instAssociativeUInt64HXor | Init.Data.UInt.Bitwise | Std.Associative fun x1 x2 => x1 ^^^ x2 |
TopCat.instNegHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier | Mathlib.Topology.Sheaves.CommRingCat | (X : TopCat) → (R : TopCommRingCat) → Neg (X ⟶ (CategoryTheory.forget₂ TopCommRingCat TopCat).obj R) |
_private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.mem_triangleIndices._simp_1 | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : CommRing α] {s : Finset α} {x : α × α × α},
(x ∈ triangleIndices✝ s) = ∃ y, ∃ a ∈ s, (y, y + a, y + 2 * a) = x |
Lean.Meta.Grind.Context | Lean.Meta.Tactic.Grind.Types | Type |
Std.DHashMap.Internal.Raw.getKey?_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} (h : m.WF) {a : α},
m.getKey? a = Std.DHashMap.Internal.Raw₀.getKey? ⟨m, ⋯⟩ a |
_private.Mathlib.Algebra.Module.LocalizedModule.Submodule.0.IsLocalizedModule.toLocalizedQuotient'._simp_1 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{S : Type u_3} [inst_3 : SMul S R] [inst_4 : SMul S M] [inst_5 : IsScalarTower S R M] (r : S) (x : M),
r • Submodule.Quotient.mk x = Submodule.Quotient.mk (r • x) |
_private.Init.Data.String.Basic.0.String.Pos.Raw.utf8GetAux.match_1.splitter | Init.Data.String.Basic | (motive : List Char → String.Pos.Raw → String.Pos.Raw → Sort u_1) →
(x : List Char) →
(x_1 x_2 : String.Pos.Raw) →
((x x_3 : String.Pos.Raw) → motive [] x x_3) →
((c : Char) → (cs : List Char) → (i p : String.Pos.Raw) → motive (c :: cs) i p) → motive x x_1 x_2 |
_private.Mathlib.MeasureTheory.Measure.AEDisjoint.0.MeasureTheory.exists_null_pairwise_disjoint_diff._simp_1_8 | Mathlib.MeasureTheory.Measure.AEDisjoint | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x |
gcdMonoidOfGCD._proof_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : DecidableEq α] (gcd : α → α → α)
(gcd_dvd_left : ∀ (a b : α), gcd a b ∣ a) (a b : α),
Associated (gcd a b * if a = 0 then 0 else Classical.choose ⋯) (a * b) |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1.noConfusion | Lean.Server.FileWorker.WidgetRequests | {P : Sort u} →
{t t' : Lean.Widget.RpcEncodablePacket✝} →
t = t' →
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1.noConfusionType
P t t' |
ConvexCone.pointed_positive | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : PartialOrder M] [inst_4 : IsOrderedAddMonoid M] [inst_5 : Module R M] [inst_6 : PosSMulMono R M],
(ConvexCone.positive R M).Pointed |
_private.Lean.Meta.Tactic.Simp.Simproc.0.Lean.Meta.Simp.getSimprocFromDeclImpl.match_6 | Lean.Meta.Tactic.Simp.Simproc | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) → (Unit → motive none) → ((info : Lean.ConstantInfo) → motive (some info)) → motive x |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.le_min_iff._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α},
(cmp a b = Ordering.gt) = (cmp b a = Ordering.lt) |
ModuleCat.biprodIsoProd_inv_comp_snd_apply | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u} [inst : Ring R] (M N : ModuleCat R) (x : ↑M × ↑N),
(CategoryTheory.ConcreteCategory.hom CategoryTheory.Limits.biprod.snd)
((CategoryTheory.ConcreteCategory.hom (M.biprodIsoProd N).inv) x) =
x.2 |
BitVec.reduceHShiftLeft | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc |
LocallyLipschitz.const_min | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : α → ℝ},
LocallyLipschitz f → ∀ (a : ℝ), LocallyLipschitz fun x => min a (f x) |
Int.Linear.Poly | Init.Data.Int.Linear | Type |
Lean.Elab.liftMacroM | Lean.Elab.Util | {m : Type → Type} →
{α : Type} →
[Monad m] →
[Lean.Elab.MonadMacroAdapter m] →
[Lean.MonadEnv m] →
[Lean.MonadRecDepth m] →
[Lean.MonadError m] →
[Lean.MonadResolveName m] →
[Lean.MonadTrace m] →
[Lean.MonadOptions m] → [Lean.AddMessageContext m] → [MonadLiftT IO m] → Lean.MacroM α → m α |
CategoryTheory.Pseudofunctor.hasCoeToLax | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → Coe (CategoryTheory.Pseudofunctor B C) (CategoryTheory.LaxFunctor B C) |
_private.Init.Internal.Order.Basic.0.Lean.Order.admissible_pprod_snd.match_1_1 | Init.Internal.Order.Basic | ∀ {α : Sort u_1} {β : Sort u_2} [inst : Lean.Order.CCPO α] [inst_1 : Lean.Order.CCPO β] (c : α ×' β → Prop) (y : β)
(motive : Lean.Order.PProd.chain.snd c y → Prop) (h : Lean.Order.PProd.chain.snd c y),
(∀ (x : α) (hxy : c ⟨x, y⟩), motive ⋯) → motive h |
_private.Init.Data.Vector.Basic.0.Vector.mapM._proof_2 | Init.Data.Vector.Basic | ∀ {n : ℕ}, ∀ k ≤ n, ¬k < n → ¬k = n → False |
toIcoMod_intCast_mul_add' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℤ), toIcoMod hp (↑m * p + a) b = ↑m * p + toIcoMod hp a b |
TensorProduct.AlgebraTensorModule.map._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {A : Type u_2} {P : Type u_4} {Q : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid P] [inst_4 : Module R P] [inst_5 : Module A P]
[inst_6 : IsScalarTower R A P] [inst_7 : AddCommMonoid Q] [inst_8 : Module R Q],
SMulCommClass R A (TensorProduct R P Q) |
addConGen._proof_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (r : M → M → Prop), Equivalence (AddConGen.Rel r) |
_private.Mathlib.Algebra.Ring.Periodic.0.Function.Antiperiodic.int_mul_eq_of_eq_zero.match_1_1 | Mathlib.Algebra.Ring.Periodic | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x |
sub_add_sub_cancel | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] (a b c : G), a - b + (b - c) = a - c |
Lean.Compiler.LCNF.ExtractClosed.M | Lean.Compiler.LCNF.ExtractClosed | Type → Type |
CategoryTheory.EnrichedFunctor.obj | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
{D : Type u₂} → [inst_3 : CategoryTheory.EnrichedCategory V D] → CategoryTheory.EnrichedFunctor V C D → C → D |
iteratedDeriv_div_const | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_6} [inst_1 : NormedDivisionRing 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {n : ℕ} (f : 𝕜 → 𝕜') (c : 𝕜'),
iteratedDeriv n (fun x => f x / c) x = iteratedDeriv n f x / c |
_private.Mathlib.Data.List.Dedup.0.List.dedup_cons_of_mem'._simp_1_2 | Mathlib.Data.List.Dedup | ∀ {a : Prop}, (¬¬a) = a |
MvQPF.Comp.map' | Mathlib.Data.QPF.Multivariate.Constructions.Comp | {n m : ℕ} →
{G : Fin2 n → TypeVec.{u} m → Type u} →
{α β : TypeVec.{u} m} → α.Arrow β → [(i : Fin2 n) → MvFunctor (G i)] → TypeVec.Arrow (fun i => G i α) fun i => G i β |
Std.TreeMap.contains_insert_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
(t.insert k v).contains k = true |
_private.Mathlib.Data.List.Cycle.0.Cycle.chain_of_pairwise._proof_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {r : α → α → Prop} (a : α) (l : List α),
(∀ a_1 ∈ ↑(a :: l), ∀ b ∈ ↑(a :: l), r a_1 b) →
a ∈ ↑(a :: l) → (∀ {b : α}, b ∈ l → b ∈ ↑(a :: l)) → ∀ b ∈ l ++ [a], r a b |
EIO.catchExceptions | Init.System.IO | {ε α : Type} → EIO ε α → (ε → BaseIO α) → BaseIO α |
NNReal.toReal_ne._simp_1 | Mathlib.Data.NNReal.Basic | ∀ (a b : NNReal), (a ≠ b) = (↑a ≠ ↑b) |
ContinuousAffineMap.differentiableOn | Mathlib.Analysis.Calculus.FDeriv.Affine | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E →ᴬ[𝕜] F)
{s : Set E}, DifferentiableOn 𝕜 (⇑f) s |
_private.Lean.Syntax.0.Lean.Syntax.isQuot._sparseCasesOn_2 | Lean.Syntax | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
IsometricContinuousFunctionalCalculus.casesOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : MetricSpace R] →
[inst_3 : IsTopologicalSemiring R] →
[inst_4 : ContinuousStar R] →
[inst_5 : Ring A] →
[inst_6 : StarRing A] →
[inst_7 : MetricSpace A] →
[inst_8 : Algebra R A] →
{motive : IsometricContinuousFunctionalCalculus R A p → Sort u} →
(t : IsometricContinuousFunctionalCalculus R A p) →
([toContinuousFunctionalCalculus : ContinuousFunctionalCalculus R A p] →
(isometric : ∀ (a : A) (ha : p a), Isometry ⇑(cfcHom ha)) → motive ⋯) →
motive t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.