name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ProbabilityTheory.moment_def | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} (X : Ω → ℝ) (p : ℕ) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.moment X p μ = ∫ (x : Ω), (X ^ p) x ∂μ | true |
CategoryTheory.Codiscrete.as | Mathlib.CategoryTheory.CodiscreteCategory | {α : Type u} → CategoryTheory.Codiscrete α → α | true |
Filter.NeBot.of_vadd_filter | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {f : Filter β} {a : α}, (a +ᵥ f).NeBot → f.NeBot | true |
SemilatSupCat.of.noConfusion | Mathlib.Order.Category.Semilat | {P : Sort u_1} →
{X : Type u} →
{isSemilatticeSup : SemilatticeSup X} →
{isOrderBot : OrderBot X} →
{X' : Type u} →
{isSemilatticeSup' : SemilatticeSup X'} →
{isOrderBot' : OrderBot X'} →
{ X := X, isSemilatticeSup := isSemilatticeSup, isOrderBot := isOrderBot } =
{ X := X', isSemilatticeSup := isSemilatticeSup', isOrderBot := isOrderBot' } →
(X = X' → isSemilatticeSup ≍ isSemilatticeSup' → isOrderBot ≍ isOrderBot' → P) → P | false |
_private.Mathlib.CategoryTheory.Limits.VanKampen.0.CategoryTheory.IsUniversalColimit.map_reflective._simp_1_2 | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.comp f g)) h | false |
TypeVec.toSubtype'._unsafe_rec | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u} n} →
(p : (α.prod α).Arrow (TypeVec.repeat n Prop)) →
TypeVec.Arrow (fun i => { x // TypeVec.ofRepeat (p i (TypeVec.prod.mk i x.1 x.2)) }) (TypeVec.Subtype_ p) | false |
Rep.instSymmetricCategory._proof_2 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : CommRing k] [inst_1 : Monoid G] (X Y : Rep.{u_1, u_1, u_2} k G),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | false |
CategoryTheory.Oplax.OplaxTrans.Hom | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} → (F ⟶ G) → (F ⟶ G) → Type (max u₁ w₂) | true |
MeasureTheory.VectorMeasure.AbsolutelyContinuous.add | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_4} {N : Type u_5} [inst : AddCommMonoid M]
[inst_1 : TopologicalSpace M] [inst_2 : AddCommMonoid N] [inst_3 : TopologicalSpace N] [inst_4 : ContinuousAdd M]
{v₁ v₂ : MeasureTheory.VectorMeasure α M} {w : MeasureTheory.VectorMeasure α N},
v₁.AbsolutelyContinuous w → v₂.AbsolutelyContinuous w → (v₁ + v₂).AbsolutelyContinuous w | true |
Subsemigroup.giMapComap._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_2} {N : Type u_1} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Surjective ⇑f → ∀ (S : Subsemigroup N), ∀ x ∈ S, x ∈ Subsemigroup.map f (Subsemigroup.comap f S) | false |
_private.Init.Data.Order.Factories.0.Std.LawfulOrderSup.of_lt._simp_1_2 | Init.Data.Order.Factories | ∀ {a b : Prop} [Decidable a] [Decidable b], (¬a ↔ ¬b) = (a ↔ b) | false |
CategoryTheory.MorphismProperty.rlp_coproducts | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C),
(CategoryTheory.MorphismProperty.coproducts.{w, v, u} T).rlp = T.rlp | true |
LocallyConstant.instAddZeroClass | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} → {Y : Type u_2} → [inst : TopologicalSpace X] → [AddZeroClass Y] → AddZeroClass (LocallyConstant X Y) | true |
Subsingleton.conformalAt._simp_1 | Mathlib.Analysis.Calculus.Conformal.NormedSpace | ∀ {X : Type u_1} {Y : Type u_2} [inst : NormedAddCommGroup X] [inst_1 : NormedAddCommGroup Y] [inst_2 : NormedSpace ℝ X]
[inst_3 : NormedSpace ℝ Y] [Subsingleton X] (f : X → Y) (x : X), ConformalAt f x = True | false |
CanonicallyOrderedAdd | Mathlib.Algebra.Order.Monoid.Canonical.Defs | (α : Type u_1) → [Add α] → [LE α] → Prop | true |
CategoryTheory.Functor.WellOrderInductionData.Extension.ofLE._proof_3 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_2} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_1)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} {j : J} (e : d.Extension val₀ j)
{i : J} (hij : i ≤ j) (k : J) (hk : Order.IsSuccLimit k) (hki : k ≤ i),
F.map (CategoryTheory.homOfLE hki).op (F.map (CategoryTheory.homOfLE hij).op e.val) =
d.lift k hk
⟨fun x =>
match x with
| Opposite.op ⟨k_1, hk⟩ => F.map (CategoryTheory.homOfLE ⋯).op (F.map (CategoryTheory.homOfLE hij).op e.val),
⋯⟩ | false |
Filter.tendsto_mul_const_atTop_of_pos | Mathlib.Order.Filter.AtTopBot.Field | ∀ {α : Type u_1} {β : Type u_2} [inst : Semifield α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {l : Filter β}
{f : β → α} {r : α}, 0 < r → (Filter.Tendsto (fun x => f x * r) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop) | true |
_private.Lean.Elab.Tactic.Omega.OmegaM.0.Lean.Elab.Tactic.Omega.commitWhen.match_1 | Lean.Elab.Tactic.Omega.OmegaM | {α : Type} →
(motive : α × Bool → Sort u_1) → (__discr : α × Bool) → ((a : α) → (r : Bool) → motive (a, r)) → motive __discr | false |
AddSubmonoid.ctorIdx | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} → {inst : AddZeroClass M} → AddSubmonoid M → ℕ | false |
Array.modifyMUnsafe | Init.Data.Array.Basic | {α : Type u} → {m : Type u → Type u_1} → [Monad m] → Array α → ℕ → (α → m α) → m (Array α) | true |
Function.ext_iff_support | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f g : ι → M},
f = g ↔ Function.support f = Function.support g ∧ ∀ x ∈ Function.support f, f x = g x | true |
CategoryTheory.Limits.BinaryBicone.sndKernelFork | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} → (c : CategoryTheory.Limits.BinaryBicone X Y) → CategoryTheory.Limits.KernelFork c.snd | true |
DoubleCentralizer.instRing._proof_7 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {A : Type u_1} [inst : NonUnitalNormedRing A], IsScalarTower ℤ A A | false |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Type | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct.0.CategoryTheory.Limits.SequentialProduct.functorMap_epi.match_1_1 | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | ∀ (n : ℕ) (motive : { x // x < n + 1 } → Prop) (h : { x // x < n + 1 }),
(∀ (val : ℕ) (property : val < n + 1), motive ⟨val, property⟩) → motive h | false |
UpperSet.coe_sub._simp_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (s t : UpperSet α),
↑s - ↑t = ↑(s - t) | false |
String.findAllSubstr | Batteries.Data.String.Matcher | String → Substring.Raw → Array Substring.Raw | true |
_private.Mathlib.Order.Category.BddOrd.0.BddOrd.Hom.mk.inj | Mathlib.Order.Category.BddOrd | ∀ {X Y : BddOrd} {hom' hom'_1 : BoundedOrderHom ↑X.toPartOrd ↑Y.toPartOrd},
{ hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | true |
Complex.restrictScalars_one_smulRight | Mathlib.Analysis.Complex.Basic | ∀ (x : ℂ), ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.toSpanSingleton ℂ x) = x • 1 | true |
Pi.opensMeasurableSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {ι : Type u_6} {X : ι → Type u_7} [Countable ι] [t' : (i : ι) → TopologicalSpace (X i)]
[inst : (i : ι) → MeasurableSpace (X i)] [∀ (i : ι), SecondCountableTopology (X i)]
[∀ (i : ι), OpensMeasurableSpace (X i)], OpensMeasurableSpace ((i : ι) → X i) | true |
_private.Lean.Linter.UnusedSimpArgs.0.Lean.Linter.initFn._@.Lean.Linter.UnusedSimpArgs.2198311501._hygCtx._hyg.2 | Lean.Linter.UnusedSimpArgs | IO Unit | false |
Finsupp.sumFinsuppAddEquivProdFinsupp_symm_apply | Mathlib.Data.Finsupp.Basic | ∀ {M : Type u_5} [inst : AddMonoid M] {α : Type u_12} {β : Type u_13} (fg : (α →₀ M) × (β →₀ M)),
Finsupp.sumFinsuppAddEquivProdFinsupp.symm fg = fg.1.sumElim fg.2 | true |
AlgebraicGeometry.Scheme.evaluation.congr_simp | Mathlib.AlgebraicGeometry.ResidueField | ∀ (X : AlgebraicGeometry.Scheme) (U : X.Opens) (x : ↥X) (hx : x ∈ U), X.evaluation U x hx = X.evaluation U x hx | true |
monovary_inv_left₀._simp_1 | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Semifield α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : LinearOrder β] {f : ι → α} {g : ι → β}, StrongLT 0 f → Monovary f⁻¹ g = Antivary f g | false |
Module.End.toContinuousLinearMap._proof_15 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_2} [hnorm : NontriviallyNormedField 𝕜] [inst : CompleteSpace 𝕜] (E : Type u_1)
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : FiniteDimensional 𝕜 E] (x : 𝕜),
(↑LinearMap.toContinuousLinearMap).toFun ((algebraMap 𝕜 (E →ₗ[𝕜] E)) x) =
(↑LinearMap.toContinuousLinearMap).toFun ((algebraMap 𝕜 (E →ₗ[𝕜] E)) x) | false |
Lean.Lsp.CompletionList._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CompletionList | false |
CategoryTheory.Functor.toPseudofunctor_mapComp | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {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] (F : CategoryTheory.Functor C D)
{a b c : CategoryTheory.LocallyDiscrete C} (f : a ⟶ b) (g : b ⟶ c),
F.toPseudofunctor.mapComp f g = CategoryTheory.eqToIso ⋯ | true |
FirstOrder.Language.StrongHomClass.mk._flat_ctor | Mathlib.ModelTheory.Basic | ∀ {L : outParam FirstOrder.Language} {F : Type u_3} {M : outParam (Type u_4)} {N : outParam (Type u_5)}
[inst : FunLike F M N] [inst_1 : L.Structure M] [inst_2 : L.Structure N],
(∀ (φ : F) {n : ℕ} (f : L.Functions n) (x : Fin n → M),
φ (FirstOrder.Language.Structure.funMap f x) = FirstOrder.Language.Structure.funMap f (⇑φ ∘ x)) →
(∀ (φ : F) {n : ℕ} (r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r (⇑φ ∘ x) ↔ FirstOrder.Language.Structure.RelMap r x) →
L.StrongHomClass F M N | false |
_private.Mathlib.Algebra.Category.AlgCat.Basic.0.AlgCat.mk.inj | Mathlib.Algebra.Category.AlgCat.Basic | ∀ {R : Type u} {inst : CommRing R} {carrier : Type v} {isRing : Ring carrier} {isAlgebra : Algebra R carrier}
{carrier_1 : Type v} {isRing_1 : Ring carrier_1} {isAlgebra_1 : Algebra R carrier_1},
{ carrier := carrier, isRing := isRing, isAlgebra := isAlgebra } =
{ carrier := carrier_1, isRing := isRing_1, isAlgebra := isAlgebra_1 } →
carrier = carrier_1 ∧ isRing ≍ isRing_1 ∧ isAlgebra ≍ isAlgebra_1 | true |
MonoidHom.codRestrict_apply | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ (x : M), f x ∈ s) (n : M), (f.codRestrict s h) n = ⟨f n, ⋯⟩ | true |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.ToTerm.toTerm.go | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.Code → Lean.Elab.Term.Do.ToTerm.M Lean.Syntax | true |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.eq_loopyOn_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | false |
NonUnitalSubalgebra.casesOn | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
{motive : NonUnitalSubalgebra R A → Sort u_1} →
(t : NonUnitalSubalgebra R A) →
((toNonUnitalSubsemiring : NonUnitalSubsemiring A) →
(smul_mem' :
∀ (c : R) {x : A}, x ∈ toNonUnitalSubsemiring.carrier → c • x ∈ toNonUnitalSubsemiring.carrier) →
motive { toNonUnitalSubsemiring := toNonUnitalSubsemiring, smul_mem' := smul_mem' }) →
motive t | false |
LowerSet.prod_self_le_prod_self._simp_1 | Mathlib.Order.UpperLower.Prod | ∀ {α : Type u_1} [inst : Preorder α] {s₁ s₂ : LowerSet α}, (s₁ ×ˢ s₁ ≤ s₂ ×ˢ s₂) = (s₁ ≤ s₂) | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_insert._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Set.Ioo_subset_Ioo_right | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b : α}, a₂ ≤ a₁ → Set.Ioo b a₂ ⊆ Set.Ioo b a₁ | true |
Dyadic.le_refl | Init.Data.Dyadic.Basic | ∀ (x : Dyadic), x ≤ x | true |
OrderEmbedding.ofAntisymmetrization._proof_2 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] {a b : Quotient (AntisymmRel.setoid α fun x1 x2 => x1 ≤ x2)},
(Quotient.outRelEmbedding ⋯).toEmbedding a ≤ (Quotient.outRelEmbedding ⋯).toEmbedding b ↔ Quotient.lift₂ LE.le ⋯ a b | false |
_private.Lean.MonadEnv.0.Lean.matchConstInduct._sparseCasesOn_1 | Lean.MonadEnv | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
Stream'.map_tail | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Stream' α), Stream'.map f s.tail = (Stream'.map f s).tail | true |
Lean.Elab.Tactic.evalShow | Lean.Elab.Tactic.Show | Lean.Elab.Tactic.Tactic | true |
TopCat.Presheaf.generateEquivalenceOpensLe_inverse' | Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover | {X : TopCat} →
{ι : Type u_2} →
(U : ι → TopologicalSpace.Opens ↑X) →
{Y : TopologicalSpace.Opens ↑X} →
Y = iSup U →
CategoryTheory.Functor (TopCat.Presheaf.SheafCondition.OpensLeCover U)
(CategoryTheory.ObjectProperty.FullSubcategory fun f =>
(CategoryTheory.Sieve.generate (TopCat.Presheaf.presieveOfCoveringAux U Y)).arrows f.hom) | true |
ConditionallyCompleteLinearOrderedField.inducedMap_inducedMap | Mathlib.Algebra.Order.CompleteField | ∀ (α : Type u_2) (β : Type u_3) (γ : Type u_4) [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : Field β] [inst_4 : ConditionallyCompleteLinearOrder β] [IsStrictOrderedRing β] [inst_6 : Field γ]
[inst_7 : ConditionallyCompleteLinearOrder γ] [IsStrictOrderedRing γ] [Archimedean α] (a : α),
ConditionallyCompleteLinearOrderedField.inducedMap β γ (ConditionallyCompleteLinearOrderedField.inducedMap α β a) =
ConditionallyCompleteLinearOrderedField.inducedMap α γ a | true |
Matrix.coe_ofLinearEquiv_symm | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_7) {α : Type u_11} [inst : Semiring R] [inst_1 : AddCommMonoid α]
[inst_2 : Module R α], ⇑(Matrix.ofLinearEquiv R).symm = ⇑Matrix.of.symm | true |
Lean.reduceNat | Init.Core | ℕ → ℕ | true |
CategoryTheory.Limits.IndObjectPresentation.ofCocone_I | Mathlib.CategoryTheory.Limits.Indization.IndObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type v} [inst_1 : CategoryTheory.SmallCategory I]
[inst_2 : CategoryTheory.IsFiltered I] {F : CategoryTheory.Functor I C}
(c : CategoryTheory.Limits.Cocone (F.comp CategoryTheory.yoneda)) (hc : CategoryTheory.Limits.IsColimit c),
(CategoryTheory.Limits.IndObjectPresentation.ofCocone c hc).I = I | true |
Representation.linearizeOfMulActionIso_apply | Mathlib.RepresentationTheory.Action | ∀ {k : Type u} {G : Type v} [inst : Monoid G] [inst_1 : Semiring k] {H : Type w} [inst_2 : MulAction G H] (f : H →₀ k),
(Representation.linearizeOfMulActionIso k G H) f = f | true |
FreeAddMonoid.reverse.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, FreeAddMonoid.reverse = List.reverse | true |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.RequestOverview.kinds | Lean.Server.ProtocolOverview | Lean.Server.Overview.RequestOverview✝ → Array Lean.Server.Overview.ProtocolExtensionKind✝ | true |
ChangeOfRings.«_aux_Mathlib_Algebra_Category_ModuleCat_ChangeOfRings___macroRules_ChangeOfRings_term_⊗ₜ[_,_]__1» | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | Lean.Macro | false |
selfAdjoint.instOneSubtypeMemAddSubgroup | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} → [inst : Ring R] → [inst_1 : StarRing R] → One ↥(selfAdjoint R) | true |
TwoP.largeCategory._aux_5 | Mathlib.CategoryTheory.Category.TwoP | {X Y Z : TwoP} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | false |
Eq.rec | Init.Prelude | {α : Sort u_1} →
{a : α} → {motive : (a_1 : α) → a = a_1 → Sort u} → motive a ⋯ → {a_1 : α} → (t : a = a_1) → motive a_1 t | false |
MulEquiv.prodUnits.match_1 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] (motive : Mˣ × Nˣ → Prop) (x : Mˣ × Nˣ),
(∀ (u₁ : Mˣ) (u₂ : Nˣ), motive (u₁, u₂)) → motive x | false |
instDecidablePredMemUpperClosure.eq_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} [inst_1 : DecidablePred fun x => ∃ a ∈ s, a ≤ x],
instDecidablePredMemUpperClosure = inst_1 | true |
completeBipartiteGraph._proof_3 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ (V : Type u_1) (W : Type u_2),
Std.Irrefl fun v w => v.isLeft = true ∧ w.isRight = true ∨ v.isRight = true ∧ w.isLeft = true | false |
CategoryTheory.kernelCokernelCompSequence.snakeInput_v₁₂_τ₁ | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z), (CategoryTheory.kernelCokernelCompSequence.snakeInput f g).v₁₂.τ₁ = f | true |
_private.Mathlib.Algebra.Star.NonUnitalSubalgebra.0.NonUnitalStarAlgebra.toNonUnitalSubalgebra_bot._simp_1_2 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {x : A}, (x ∈ ⊥) = (x = 0) | false |
CategoryTheory.Limits.cospanIsoMk._auto_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | Lean.Syntax | false |
_private.Mathlib.Topology.Homotopy.HSpaces.0.unitInterval.qRight_one_left._simp_1_1 | Mathlib.Topology.Homotopy.HSpaces | ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α] [AddRightMono α] [AddRightReflectLE α] (a : α) {b c : α},
(b + a ≤ c + a) = (b ≤ c) | false |
_private.Mathlib.RingTheory.AlgebraicIndependent.Defs.0.isTranscendenceBasis_equiv._simp_1_2 | Mathlib.RingTheory.AlgebraicIndependent.Defs | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {A : Type u_5} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : Algebra R A] (e : ι ≃ ι') {f : ι' → A}, AlgebraicIndependent R (f ∘ ⇑e) = AlgebraicIndependent R f | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ushiftRight_of_lt._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = x) = (¬p → y = x) | false |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitLambdaLet.go._unsafe_rec | Lean.Meta.LetToHave | Lean.LocalContext → Array Lean.Expr → Lean.Expr → List Lean.FVarId → Lean.Meta.LetToHave.M✝ Lean.Meta.LetToHave.Result✝ | false |
CompleteLattice.toConditionallyCompleteLattice | Mathlib.Order.ConditionallyCompleteLattice.Basic | {α : Type u_1} → [CompleteLattice α] → ConditionallyCompleteLattice α | true |
Lean.MVarId.mk.sizeOf_spec | Lean.Expr | ∀ (name : Lean.Name), sizeOf { name := name } = 1 + sizeOf name | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Revert.0.Lean.Elab.Tactic.Do.ProofMode.elabMRevert.match_4 | Lean.Elab.Tactic.Do.ProofMode.Revert | (motive : Lean.MVarId × Lean.Elab.Tactic.Do.ProofMode.MGoal → Sort u_1) →
(__discr : Lean.MVarId × Lean.Elab.Tactic.Do.ProofMode.MGoal) →
((mvar : Lean.MVarId) → (goal : Lean.Elab.Tactic.Do.ProofMode.MGoal) → motive (mvar, goal)) → motive __discr | false |
Std.Net.SocketAddress.v6.noConfusion | Std.Net.Addr | {P : Sort u} →
{addr addr' : Std.Net.SocketAddressV6} →
Std.Net.SocketAddress.v6 addr = Std.Net.SocketAddress.v6 addr' → (addr = addr' → P) → P | false |
LLVM.Target.ptr | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} → LLVM.Target ctx → USize | true |
cfcₙ_const_mul_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 : IsScalarTower R A A]
[inst_11 : SMulCommClass R A A] [instCFCₙ : NonUnitalContinuousFunctionalCalculus R A p] (r : R) (a : A),
autoParam (p a) cfcₙ_const_mul_id._auto_1 → cfcₙ (fun x => r * x) a = r • a | true |
GroupCone.casesOn | Mathlib.Algebra.Order.Group.Cone | {G : Type u_1} →
[inst : CommGroup G] →
{motive : GroupCone G → Sort u} →
(t : GroupCone G) →
((toSubmonoid : Submonoid G) →
(eq_one_of_mem_of_inv_mem' : ∀ {a : G}, a ∈ toSubmonoid.carrier → a⁻¹ ∈ toSubmonoid.carrier → a = 1) →
motive { toSubmonoid := toSubmonoid, eq_one_of_mem_of_inv_mem' := eq_one_of_mem_of_inv_mem' }) →
motive t | false |
CategoryTheory.Limits.isLimitOfHasPullbackOfPreservesLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor C D) →
{X Y Z : C} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
[CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G] →
[inst_3 : CategoryTheory.Limits.HasPullback f g] →
have this := ⋯;
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.PullbackCone.mk (G.map (CategoryTheory.Limits.pullback.fst f g))
(G.map (CategoryTheory.Limits.pullback.snd f g)) this) | true |
Polynomial.toMatrix_sylvesterMap' | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {m n : ℕ} {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n),
(LinearMap.toMatrix (((Polynomial.degreeLT.basis R m).prod (Polynomial.degreeLT.basis R n)).reindex finSumFinEquiv)
(Polynomial.degreeLT.basis R (m + n)))
(f.sylvesterMap g hf hg) =
f.sylvester g m n | true |
Option.instSMul_mathlib.eq_1 | Mathlib.Algebra.Group.Action.Option | ∀ {M : Type u_1} {α : Type u_3} [inst : SMul M α],
Option.instSMul_mathlib = { smul := fun a => Option.map fun x => a • x } | true |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_succ_dist_weak | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {a : ℤ_[p]}
(hnorm : ‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2),
(Polynomial.aeval a) F ≠ 0 →
∀ (n : ℕ),
‖newton_seq_gen✝ hnorm (n + 2) - newton_seq_gen✝¹ hnorm (n + 1)‖ <
‖(Polynomial.aeval a) F‖ / ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ | true |
LieSubalgebra.exists_lieIdeal_coe_eq_iff | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (K : LieSubalgebra R L),
(∃ I, LieIdeal.toLieSubalgebra R L I = K) ↔ ∀ (x y : L), y ∈ K → ⁅x, y⁆ ∈ K | true |
NonUnitalAlgebra.mem_sInf | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {S : Set (NonUnitalSubalgebra R A)} {x : A},
x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p | true |
CategoryTheory.CatCommSq.mk._flat_ctor | Mathlib.CategoryTheory.CatCommSq | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] →
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄] →
{T : CategoryTheory.Functor C₁ C₂} →
{L : CategoryTheory.Functor C₁ C₃} →
{R : CategoryTheory.Functor C₂ C₄} →
{B : CategoryTheory.Functor C₃ C₄} → (T.comp R ≅ L.comp B) → CategoryTheory.CatCommSq T L R B | false |
Matrix.toBlocks_fromBlocks₂₁ | Mathlib.Data.Matrix.Block | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} (A : Matrix n l α) (B : Matrix n m α)
(C : Matrix o l α) (D : Matrix o m α), (Matrix.fromBlocks A B C D).toBlocks₂₁ = C | true |
_private.Mathlib.Tactic.Linter.Whitespace.0.Mathlib.Linter.parallelScanAux | Mathlib.Tactic.Linter.Whitespace | Array Mathlib.Linter.FormatError✝ → String.Slice → String.Slice → Array Mathlib.Linter.FormatError✝¹ | true |
Submodule.span_span_coe_preimage | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s : Set M},
Submodule.span R (Subtype.val ⁻¹' s) = ⊤ | true |
Int.dvd_emod_add_of_dvd_add | Init.Data.Int.Cooper | ∀ {a c d x : ℤ}, a ∣ x + c → a ∣ d → a ∣ x % d + c | true |
SimpleGraph.Subgraph.coeInduceIso._proof_8 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {G' : G.Subgraph} (s : Set V) (h : s ⊆ G'.verts) {a b : ↑(G'.induce s).verts},
(SimpleGraph.induce {v | ↑v ∈ s} G'.coe).Adj
({
toFun := fun x =>
match x with
| ⟨v, hv⟩ => ⟨⟨v, ⋯⟩, hv⟩,
invFun := fun x =>
match x with
| ⟨v, hv⟩ => ⟨↑v, hv⟩,
left_inv := ⋯, right_inv := ⋯ }
a)
({
toFun := fun x =>
match x with
| ⟨v, hv⟩ => ⟨⟨v, ⋯⟩, hv⟩,
invFun := fun x =>
match x with
| ⟨v, hv⟩ => ⟨↑v, hv⟩,
left_inv := ⋯, right_inv := ⋯ }
b) ↔
(G'.induce s).coe.Adj a b | false |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map_id._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | Lean.Syntax | false |
ClosedEmbeddingContinuousFunctionalCalculus.recOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | {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 : TopologicalSpace A] →
[inst_8 : Algebra R A] →
{motive : ClosedEmbeddingContinuousFunctionalCalculus R A p → Sort u} →
(t : ClosedEmbeddingContinuousFunctionalCalculus R A p) →
([toContinuousFunctionalCalculus : ContinuousFunctionalCalculus R A p] →
(isClosedEmbedding : ∀ (a : A) (ha : p a), Topology.IsClosedEmbedding ⇑(cfcHom ha)) →
motive ⋯) →
motive t | false |
Std.Time.PlainTime.ofSeconds | Std.Time.Time.PlainTime | Std.Time.Second.Offset → Std.Time.PlainTime | true |
OrderRingIso.noConfusion | Mathlib.Algebra.Order.Hom.Ring | {P : Sort u} →
{α : Type u_6} →
{β : Type u_7} →
{inst : Mul α} →
{inst_1 : Add α} →
{inst_2 : Mul β} →
{inst_3 : Add β} →
{inst_4 : LE α} →
{inst_5 : LE β} →
{t : α ≃+*o β} →
{α' : Type u_6} →
{β' : Type u_7} →
{inst' : Mul α'} →
{inst'_1 : Add α'} →
{inst'_2 : Mul β'} →
{inst'_3 : Add β'} →
{inst'_4 : LE α'} →
{inst'_5 : LE β'} →
{t' : α' ≃+*o β'} →
α = α' →
β = β' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
inst_4 ≍ inst'_4 →
inst_5 ≍ inst'_5 → t ≍ t' → OrderRingIso.noConfusionType P t t' | false |
ENNReal.measurableSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | MeasurableSpace ENNReal | true |
_private.Mathlib.Algebra.QuadraticDiscriminant.0.discrim_eq_zero_iff._simp_1_1 | Mathlib.Algebra.QuadraticDiscriminant | ∀ {α : Sort u_1} {a' : α}, (∃! a, a = a') = True | false |
CategoryTheory.Localization.lift₃NatTrans | Mathlib.CategoryTheory.Localization.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{D₁ : Type u_6} →
{D₂ : Type u_7} →
{D₃ : Type u_8} →
{E : Type u_13} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] →
[inst_3 : CategoryTheory.Category.{v_4, u_6} D₁] →
[inst_4 : CategoryTheory.Category.{v_5, u_7} D₂] →
[inst_5 : CategoryTheory.Category.{v_6, u_8} D₃] →
[inst_6 : CategoryTheory.Category.{v_13, u_13} E] →
(L₁ : CategoryTheory.Functor C₁ D₁) →
(L₂ : CategoryTheory.Functor C₂ D₂) →
(L₃ : CategoryTheory.Functor C₃ D₃) →
(W₁ : CategoryTheory.MorphismProperty C₁) →
(W₂ : CategoryTheory.MorphismProperty C₂) →
(W₃ : CategoryTheory.MorphismProperty C₃) →
[L₁.IsLocalization W₁] →
[L₂.IsLocalization W₂] →
[L₃.IsLocalization W₃] →
[W₁.ContainsIdentities] →
[W₂.ContainsIdentities] →
[W₃.ContainsIdentities] →
(F₁ F₂ :
CategoryTheory.Functor C₁
(CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ E))) →
(F₁' F₂' :
CategoryTheory.Functor D₁
(CategoryTheory.Functor D₂ (CategoryTheory.Functor D₃ E))) →
[CategoryTheory.Localization.Lifting₃ L₁ L₂ L₃ W₁ W₂ W₃ F₁
F₁'] →
[CategoryTheory.Localization.Lifting₃ L₁ L₂ L₃ W₁ W₂ W₃ F₂
F₂'] →
(F₁ ⟶ F₂) → (F₁' ⟶ F₂') | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Mathlib.Tactic.DefEqAbuse.stripHeaderEmoji | Mathlib.Tactic.DefEqAbuse | String → Option Lean.TraceResult → String | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.