name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matrix.SeparatingLeft.separatingRight | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {n : Type u_1} {A : Type u_4} [inst : CommRing A] [IsDomain A] {M : Matrix n n A} [inst_2 : Finite n],
M.SeparatingLeft → M.SeparatingRight | **Alias** of the forward direction of `Matrix.separatingLeft_iff_separatingRight`. | true |
Array.map_eq_append_iff | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {ys zs : Array β} {f : α → β},
Array.map f xs = ys ++ zs ↔ ∃ as bs, xs = as ++ bs ∧ Array.map f as = ys ∧ Array.map f bs = zs | null | true |
MeasureTheory.eLpNormLESNormFDerivOfEqInnerConst.eq_1 | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | ∀ {E : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E]
[inst_3 : BorelSpace E] [inst_4 : FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [inst_5 : μ.IsAddHaarMeasure]
(p : ℝ),
MeasureTheory.eLpNormLESNormFDerivOfEqInnerConst μ p =
MeasureTheory.eLpNormLESNo... | null | true |
CategoryTheory.Limits.ReflectsFilteredColimitsOfSize.casesOn | Mathlib.CategoryTheory.Limits.Preserves.Filtered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.ReflectsFilteredColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F → Sort u} →
(t : CategoryThe... | null | false |
instDecidableStrictAntiOnOfForallForallMemSetForallForallForallLt | Mathlib.Order.Monotone.Defs | {α : Type u} →
{β : Type v} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
{f : α → β} → {s : Set α} → [i : Decidable (∀ a ∈ s, ∀ b ∈ s, a < b → f b < f a)] → Decidable (StrictAntiOn f s) | null | true |
Std.TreeMap.getElem?_insertMany_list.match_1 | Std.Data.TreeMap.Lemmas | {α : Type u_1} →
{β : Type u_2} → (motive : α × β → Sort u_3) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x | null | false |
MeasureTheory.memLp_congr_norm | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {E : Type u_5} {F : Type u_6} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] {f : α → E} {g : α → F},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AEStronglyMeasurable g μ →
(∀ᵐ (a : α) ∂μ, ‖f a‖... | null | true |
Filter.iSup_inf_principal | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {ι : Sort x} (f : ι → Filter α) (s : Set α),
⨆ i, f i ⊓ Filter.principal s = (⨆ i, f i) ⊓ Filter.principal s | null | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.LinearMap.iSupIndep_map.match_1_3 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u_4} {R : Type u_2} {M : Type u_3} {M' : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M') {m : ι → Submodule R M}
(i : ι) (x : M) (motive : f x ∈ ↑(Submodule.map f (⨆ i_1, ⨆ (_ : i_1 ≠ i), m i_1)) → Prop)
... | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.letId.formatter_53 | Lean.Parser.Term | IO Unit | null | false |
Quiver.Path.rec.eq._@.Mathlib.Combinatorics.Quiver.Path.3963176020._hygCtx._hyg.4 | Mathlib.Combinatorics.Quiver.Path | @Quiver.Path.rec = @Quiver.Path.rec✝ | null | false |
Units.ctorIdx | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → {inst : Monoid α} → αˣ → ℕ | null | false |
Aesop.UnsafeQueueEntry.unsafeRule.elim | Aesop.Tree.UnsafeQueue | {motive : Aesop.UnsafeQueueEntry → Sort u} →
(t : Aesop.UnsafeQueueEntry) →
t.ctorIdx = 0 →
((r : Aesop.IndexMatchResult Aesop.UnsafeRule) → motive (Aesop.UnsafeQueueEntry.unsafeRule r)) → motive t | null | false |
Function.Embedding.toEmbedding_equivOfFiniteSelfEmbedding | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} [inst : Finite α] (e : α ↪ α), e.equivOfFiniteSelfEmbedding.toEmbedding = e | null | true |
Interval.length.match_1 | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_1} →
[inst : PartialOrder α] →
(motive : Interval α → Sort u_2) →
(x : Interval α) → (Unit → motive none) → ((s : NonemptyInterval α) → motive (some s)) → motive x | null | false |
Std.TreeMap.Raw.foldl | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} → {cmp : α → α → Ordering} → {δ : Type w} → (δ → α → β → δ) → δ → Std.TreeMap.Raw α β cmp → δ | Folds the given function over the mappings in the map in ascending order. | true |
CategoryTheory.InjectiveResolution.ι | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{Z : C} → (self : CategoryTheory.InjectiveResolution Z) → (CochainComplex.single₀ C).obj Z ⟶ self.cocomplex | the morphism from the single cochain complex with `Z` in degree `0` | true |
Ordinal.veblen_right_strictMono | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), StrictMono (Ordinal.veblen o) | null | true |
Lean.hasAssignedLevelMVar._f | Lean.MetavarContext | {m : Type → Type} → [Monad m] → [Lean.MonadMCtx m] → (x : Lean.Level) → Lean.Level.below x → m Bool | null | false |
ModuleFilterBasis.instInhabitedOfDiscreteTopology | Mathlib.Topology.Algebra.FilterBasis | {R : Type u_1} →
{M : Type u_2} →
[inst : Semiring R] →
[inst_1 : TopologicalSpace R] →
[inst_2 : AddCommGroup M] → [inst_3 : Module R M] → [DiscreteTopology R] → Inhabited (ModuleFilterBasis R M) | If `R` is discrete then the trivial additive group filter basis on any `R`-module is a
module filter basis. | true |
Function.Injective.coframeMinimalAxioms | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {β : Type v} [inst : CompleteLattice α] [inst_1 : CompleteLattice β],
Order.Coframe.MinimalAxioms β →
∀ (f : α → β),
(∀ {x y : α}, f y ≤ f x ↔ y ≤ x) →
(∀ (a b : α), f (a ⊔ b) = f a ⊔ f b) →
(∀ (s : Set α), f (sInf s) = ⨅ a ∈ s, f a) → Order.Coframe.MinimalAxioms α | **Alias** of `Function.coframeMinimalAxioms`.
---
Pullback an `Order.Coframe.MinimalAxioms` along a function. | true |
CategoryTheory.Abelian.SpectralObject.δToCycles_cyclesIso_inv_assoc | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
Std.ExtTreeSet.max?_eq_none_iff._simp_1 | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp], (t.max? = none) = (t = ∅) | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Limits.Cokernels.0.CategoryTheory.Limits.CokernelCofork.tensor._simp_1 | Mathlib.CategoryTheory.Monoidal.Limits.Cokernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y : C}
(f : W ⟶ X) (g : X ⟶ Y) (Z : C) {Z_1 : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z)
... | null | false |
CategoryTheory.TwoSquare.structuredArrowRightwardsOpEquivalence.functor._proof_5 | Mathlib.CategoryTheory.GuitartExact.Opposite | ∀ {C₁ : Type u_8} {C₂ : Type u_4} {C₃ : Type u_6} {C₄ : Type u_2} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
[inst_3 : CategoryTheory.Category.{u_1, u_2} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.F... | null | false |
Affine.Simplex.volume_eq_volume_real_closedInterior | Mathlib.Geometry.Euclidean.Volume.MeasureSimplex | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {n : ℕ} [inst_2 : MeasurableSpace V]
[inst_3 : BorelSpace V] [inst_4 : FiniteDimensional ℝ V],
Module.finrank ℝ V = n → ∀ (s : Affine.Simplex ℝ V n), s.volume = MeasureTheory.volume.real s.closedInterior | `Affine.Simplex.volume` is equal to the Lebesgue measure of the closed interior. | true |
MonadState.mk | Init.Prelude | {σ : outParam (Type u)} →
{m : Type u → Type v} → m σ → (σ → m PUnit.{u + 1}) → ({α : Type u} → (σ → α × σ) → m α) → MonadState σ m | null | true |
_private.Mathlib.RingTheory.MvPolynomial.Homogeneous.0.Ideal.span_eq_map_homogeneousSubmodule._simp_1_1 | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | null | false |
CategoryTheory.Cat.Hom.toNatIso._proof_2 | Mathlib.CategoryTheory.Category.Cat | ∀ {X Y : CategoryTheory.Cat} {F G : X ⟶ Y} (e : F ≅ G),
{ toNatTrans := CategoryTheory.CategoryStruct.comp e.inv.toNatTrans e.hom.toNatTrans }.toNatTrans =
{ toNatTrans := CategoryTheory.CategoryStruct.id G.toFunctor }.toNatTrans | null | false |
DirectSum.gMulLHom._proof_3 | Mathlib.Algebra.DirectSum.Algebra | ∀ {ι : Type u_3} (R : Type u_1) (A : ι → Type u_2) [inst : CommSemiring R] [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : (i : ι) → Module R (A i)] [inst_3 : AddMonoid ι] {i j : ι}, SMulCommClass R R (A (i + j)) | null | false |
_private.Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv.0.GenContFract.squashSeq.match_1.splitter | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | {K : Type u_1} →
(motive : Option (GenContFract.Pair K) × Option (GenContFract.Pair K) → Sort u_2) →
(x : Option (GenContFract.Pair K) × Option (GenContFract.Pair K)) →
((gp_n gp_succ_n : GenContFract.Pair K) → motive (some gp_n, some gp_succ_n)) →
((x : Option (GenContFract.Pair K) × Option (GenCon... | null | true |
QuadraticAlgebra.instAddCommGroupWithOne._proof_2 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : AddCommGroupWithOne R] (n : ℕ), QuadraticAlgebra.C ↑(Int.negSucc n) = -↑(n + 1) | null | false |
LieAlgebra.LieEquiv.ofCoboundary._proof_5 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(c c' : ↥(LieModule.Cohomology.twoCocycle R L M)) (x : LieModule.Cohomology.oneCochain R L M) (m :... | null | false |
List.reverse_ne_nil_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, xs.reverse ≠ [] ↔ xs ≠ [] | null | true |
Lean.Compiler.LCNF.TrivialStructureInfo.noConfusion | Lean.Compiler.LCNF.Irrelevant | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.TrivialStructureInfo} →
t = t' → Lean.Compiler.LCNF.TrivialStructureInfo.noConfusionType P t t' | null | false |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.isMulFreimanHom_two._simp_1_1 | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_1} {s : Multiset α}, (s.card = 2) = ∃ x y, s = {x, y} | null | false |
Nat.pow_eq_sum_stirlingSecond_mul_descFactorial | Mathlib.Combinatorics.Enumerative.Stirling | ∀ (n k : ℕ), n ^ k = ∑ j ∈ Finset.range (k + 1), k.stirlingSecond j * n.descFactorial j | Every power `n ^ k` is a linear combination of the descending factorials `n.descFactorial j`
with the Stirling numbers of the second kind `stirlingSecond k j` as coefficients. | true |
CategoryTheory.FreeBicategory.Hom₂.mk | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{a b : CategoryTheory.FreeBicategory B} → {f g : a ⟶ b} → CategoryTheory.FreeBicategory.Hom₂ f g → (f ⟶ g) | `Hom₂.mk η` is an abbreviation for `Quot.mk Rel η`. | true |
_private.Mathlib.Analysis.Convex.Between.0.Wbtw.trans_left_right._simp_1_4 | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (r s : R) (y : M),
r • y - s • y = (r - s) • y | null | false |
Std.Time.WallTime.addDuration | Std.Time.DateTime.WallTime | Std.Time.WallTime → Std.Time.Duration → Std.Time.WallTime | Adds a `Duration` to the given `WallTime`.
| true |
Algebra.Generators.ofAlgHom.congr_simp | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {I : Type u_1}
(f f_1 : MvPolynomial I R →ₐ[R] S) (e_f : f = f_1) (h : Function.Surjective ⇑f),
Algebra.Generators.ofAlgHom f h = Algebra.Generators.ofAlgHom f_1 ⋯ | null | true |
ModuleCat.ExtendRestrictScalarsAdj.Unit.map | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
(f : R →+* S) → {X : ModuleCat R} → X ⟶ ((ModuleCat.extendScalars f).comp (ModuleCat.restrictScalars f)).obj X | For any `R`-module X, there is a natural `R`-linear map from `X` to `X ⨂ S` by sending `x ↦ x ⊗ 1`
| true |
TestFunction.mkCLM.congr_simp | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_4} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n : ℕ∞} {V : Type u_6} [inst_6 : AddCommGroup V]
[in... | null | true |
CategoryTheory.HalfBraiding.naturality._autoParam | Mathlib.CategoryTheory.Monoidal.Center | Lean.Syntax | null | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.RCasesPatt.tuple₁Core.match_1 | Lean.Elab.Tactic.RCases | (motive : List Lean.Elab.Tactic.RCases.RCasesPatt → Sort u_1) →
(x : List Lean.Elab.Tactic.RCases.RCasesPatt) →
(Unit → motive []) →
((ref : Lean.Syntax) → motive [Lean.Elab.Tactic.RCases.RCasesPatt.tuple ref []]) →
((ref : Lean.Syntax) →
(ps : List Lean.Elab.Tactic.RCases.RCasesPatt) → ... | null | false |
Lean.Server.RequestCancellationToken.ctorIdx | Lean.Server.RequestCancellation | Lean.Server.RequestCancellationToken → ℕ | null | false |
Convex.integral_mem | Mathlib.Analysis.Convex.Integral | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[CompleteSpace E] {μ : MeasureTheory.Measure α} {s : Set E} {f : α → E} [MeasureTheory.IsProbabilityMeasure μ],
Convex ℝ s → IsClosed s → (∀ᵐ (x : α) ∂μ, f x ∈ s) → MeasureTheory.Integrable f μ → ∫ (x :... | If `μ` is a probability measure on `α`, `s` is a convex closed set in `E`, and `f` is an
integrable function sending `μ`-a.e. points to `s`, then the expected value of `f` belongs to `s`:
`∫ x, f x ∂μ ∈ s`. See also `Convex.sum_mem` for a finite sum version of this lemma. | true |
UpperHalfPlane.coe_J_smul | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (τ : UpperHalfPlane), ↑(UpperHalfPlane.J • τ) = -(starRingEnd ℂ) ↑τ | null | true |
ZFSet.nonempty_of_mem | Mathlib.SetTheory.ZFC.Basic | ∀ {x u : ZFSet.{u_1}}, x ∈ u → u.Nonempty | null | true |
Equiv.sigmaSubtype._proof_5 | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_1} {β : α → Type u_2} (a : α) (x : { s // s.fst = a }) (a_1 : Sigma β) (h : a_1.fst = a),
(fun b => ⟨⟨a, b⟩, ⋯⟩)
((fun x =>
match x with
| ⟨⟨fst, b⟩, h⟩ => h ▸ b)
⟨a_1, h⟩) =
⟨a_1, h⟩ | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.σ₀Iter_coe_eq_of_le._proof_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (i : ℕ) {n m : ℕ}, n + i = m → n + i = m | null | false |
finsum_mul' | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {R : Type u_7} [inst : NonUnitalNonAssocSemiring R] (f : α → R) (r : R),
Function.HasFiniteSupport f → (∑ᶠ (a : α), f a) * r = ∑ᶠ (a : α), f a * r | For functions with finite support, multiplication commutes with finsums. See `finsum_mul` for a
statement assuming that `R` has no zero divisors.
| true |
PUnit.mulSemiringAction._proof_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : Semiring R] (r : R), r • 1 = 1 | null | false |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_11 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor C (Type u_3)) {X : C}
(x : F.obj X) {X_1 Y : CategoryTheory.Over (F.elementsMk X x)} (f : X_1 ⟶ Y),
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Over.Hom.left f) Y.hom).hom = X_1.hom.hom | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.typeOf._regBuiltin.Lean.Parser.Term.typeOf.declRange_3 | Lean.Parser.Term | IO Unit | null | false |
AlgebraicGeometry.Scheme.Modules.restrictFunctorId_inv_app_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {M : X.Modules} {U : X.Opens},
AlgebraicGeometry.Scheme.Modules.Hom.app (AlgebraicGeometry.Scheme.Modules.restrictFunctorId.inv.app M) U =
M.presheaf.map (CategoryTheory.eqToHom ⋯).op | null | true |
Function.graph | Mathlib.Basic.Rel | {α : Type u_1} → {β : Type u_2} → (α → β) → SetRel α β | The graph of a function as a relation. | true |
CategoryTheory.Limits.IsLimit.pushout_zero_ext | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Connected | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsConnected J] {C : Type u}
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_4 : CategoryTheory.Limits.HasPushouts C] [inst_5 : CategoryTheory.Limits.HasLimitsOfShape J C]
[CategoryTheory... | Detecting vanishing of a morphism factoring through a connected limit by pushing out along the
projections of the limit. | true |
CategoryTheory.Monad.MonadicityInternal.instHasColimitWalkingParallelPairParallelPairMapAppCounitObjOfHasCoequalizerAA | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G)
[∀ (A : adj.toMonad.Algebra), CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] (B : D)... | null | true |
Quiver.homOfEq_trans | Mathlib.Combinatorics.Quiver.Basic | ∀ {V : Type u_1} [inst : Quiver V] {X Y X' Y' : V} (f : X ⟶ Y) (hX : X = X') (hY : Y = Y') {X'' Y'' : V}
(hX' : X' = X'') (hY' : Y' = Y''), Quiver.homOfEq (Quiver.homOfEq f hX hY) hX' hY' = Quiver.homOfEq f ⋯ ⋯ | null | true |
MonCat.monoidObj.eq_1 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J MonCat) (j : J),
MonCat.monoidObj F j = (F.obj j).str | null | true |
CategoryTheory.ComposableArrows.naturality'._auto_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
_private.Mathlib.GroupTheory.GroupAction.Primitive.0.MulAction.IsPreprimitive.exists_mem_smul_and_notMem_smul._simp_1_3 | Mathlib.GroupTheory.GroupAction.Primitive | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
String.Slice.Pos.Splits.rec | Init.Data.String.Lemmas.Splits | {s : String.Slice} →
{p : s.Pos} →
{t₁ t₂ : String} →
{motive : p.Splits t₁ t₂ → Sort u} →
((eq_append : s.copy = t₁ ++ t₂) → (offset_eq_rawEndPos : p.offset = t₁.rawEndPos) → motive ⋯) →
(t : p.Splits t₁ t₂) → motive t | null | false |
Std.TreeSet.Raw.get!_insertMany_list_of_not_mem_of_contains_eq_false | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp] [inst_2 : Inhabited α],
t.WF → ∀ {l : List α} {k : α}, k ∉ t → l.contains k = false → (t.insertMany l).get! k = default | null | true |
String.Pos.Raw.isValidForSlice_iff_exists_append | Init.Data.String.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw},
String.Pos.Raw.IsValidForSlice s p ↔ ∃ t₁ t₂, s.copy = t₁ ++ t₂ ∧ p = t₁.rawEndPos | null | true |
LinearEquiv.det_baseChange | Mathlib.LinearAlgebra.Charpoly.BaseChange | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Free R M]
[Module.Finite R M] (A : Type u_3) [inst_5 : CommRing A] [inst_6 : Algebra R A] (f : M ≃ₗ[R] M),
LinearEquiv.det (LinearEquiv.baseChange R A M M f) = (Units.map ↑(algebraMap R A)) (LinearEquiv.det f... | null | true |
_private.Mathlib.Computability.Primrec.List.0.Primrec.list_set.match_1_1 | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} (motive : ℕ × α → Prop) (x : ℕ × α), (∀ (n : ℕ) (v : α), motive (n, v)) → motive x | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_15 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i + 1 ≤ (List.findIdxs p (head :: tail) s).length → i < (List.findIdxs p (head :: tail) s).length | null | false |
Filter.CardinalGenerateSets.below | Mathlib.Order.Filter.CardinalInter | {α : Type u} →
{c : Cardinal.{u}} →
{g : Set (Set α)} →
{motive : (a : Set α) → Filter.CardinalGenerateSets g a → Prop} →
{a : Set α} → Filter.CardinalGenerateSets g a → Prop | null | true |
MeasureTheory.L1.SimpleFunc.integralCLM'._proof_2 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ (α : Type u_1) (E : Type u_2) (𝕜 : Type u_3) [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
(μ : MeasureTheory.Measure α) [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E]
[inst_4 : NormedSpace ℝ E] [inst_5 : SMulCommClass ℝ 𝕜 E] (f : ↥(α →₁ₛ[μ] E)),
‖{ toFun := MeasureTheor... | null | false |
CommGroup.torsion.eq_1 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : CommGroup G], CommGroup.torsion G = { toSubmonoid := CommMonoid.torsion G, inv_mem' := ⋯ } | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_mul._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {R : Type u} [inst : Semiring R] [inst_1 : PartialOrder R] [ExistsAddOfLE R] [MulPosStrictMono R]
[AddRightStrictMono R] [AddRightReflectLT R] {a b : R}, a < 0 → b < 0 → (0 < a * b) = True | null | false |
MulEquiv.withZero._proof_2 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_2} {β : Type u_1} [inst : Group α] [inst_1 : Group β] (e : α ≃* β) (x : WithZero β),
(WithZero.map' ↑e) ((WithZero.map' ↑e.symm) x) = x | null | false |
CategoryTheory.Functor.LaxRightLinear.μᵣ_unitality._autoParam | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | Lean.Syntax | null | false |
HomologicalComplex.mapBifunctorDesc | Mathlib.Algebra.Homology.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[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} D] →
{I₁ : Type u_4} →
{I₂ : Type u_5} →
{J : Type... | Constructor for morphisms from `(mapBifunctor K₁ K₂ F c).X j`. | true |
Std.Time.Day.Ordinal.instInhabitedOfYear._proof_1 | Std.Time.Date.Unit.Day | 1 ≤ 1 | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertEntry_perm_filter._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, (a :: l₁).Perm (a :: l₂) = l₁.Perm l₂ | null | false |
CategoryTheory.MonoidalCategory.DayConvolution.mk | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{F G : CategoryTheory.Functor C V} →
(convol... | null | true |
midpoint_le_right._simp_1 | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : IsStrictOrderedRing k]
[inst_3 : AddCommGroup E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] [inst_6 : Module k E]
[IsStrictOrderedModule k E] [PosSMulReflectLE k E] {a b : E}, (midpoint k a b ≤ b) = (a ≤ b) | null | false |
_private.Lean.Elab.BuiltinCommand.0.Lean.Elab.Command.elabExit._regBuiltin.Lean.Elab.Command.elabExit_1 | Lean.Elab.BuiltinCommand | IO Unit | null | false |
AlternatingMap.mkContinuousLinear_norm_le_max | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {G : Type wG} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : SeminormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : Fintype... | null | true |
CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit_inv | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {kf : CategoryTheory.Limits.KernelFork f}
{kf' : CategoryTheory.Limits.KernelFork f'} (hf : CategoryTheory.Limits.IsLimit kf)
(hf' : CategoryTheory.Limits.I... | null | true |
MvPolynomial.bind₂_monomial | Mathlib.Algebra.MvPolynomial.Monad | ∀ {σ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
(f : R →+* MvPolynomial σ S) (d : σ →₀ ℕ) (r : R),
(MvPolynomial.bind₂ f) ((MvPolynomial.monomial d) r) = f r * (MvPolynomial.monomial d) 1 | null | true |
isMin_bot | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α], IsMin ⊥ | null | true |
_private.Lean.Meta.Tactic.Intro.0.Lean.Meta.mkAuxNameImp.match_1 | Lean.Meta.Tactic.Intro | (motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) →
(Unit → motive []) → ((n : Lean.Name) → (rest : List Lean.Name) → motive (n :: rest)) → motive x | null | false |
LinearMap.IsSymmetric.diagonalization_apply_self_apply | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E} [inst_3 : FiniteDimensional 𝕜 E] (hT : T.IsSymmetric) (v : E) (μ : Module.End.Eigenvalues T),
(hT.diagonalization (T v)).ofLp μ = ↑T 1 μ • (hT.diagonalization v).ofLp μ | *Diagonalization theorem*, *spectral theorem*; version 1: A self-adjoint operator `T` on a
finite-dimensional inner product space `E` acts diagonally on the decomposition of `E` into the
direct sum of the eigenspaces of `T`. | true |
HeytAlg.instConcreteCategoryHeytingHomCarrier._proof_3 | Mathlib.Order.Category.HeytAlg | ∀ {X : HeytAlg} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x | null | false |
_private.Mathlib.Condensed.Light.EffectiveEpi.0.instIsRegularEpiCategoryLightCondSet._proof_1 | Mathlib.Condensed.Light.EffectiveEpi | CategoryTheory.IsRegularEpiCategory LightCondSet | null | false |
_private.Mathlib.CategoryTheory.Presentable.OrthogonalReflection.0.CategoryTheory.MorphismProperty.isClosedUnderCardinalFilteredColimits_isLocal.match_1_1 | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (W : CategoryTheory.MorphismProperty C) (J : Type u_1)
(x : CategoryTheory.SmallCategory J) (Z : C) (motive : W.isLocal.colimitsOfShape J Z → Prop)
(x_1 : W.isLocal.colimitsOfShape J Z), (∀ (p : W.isLocal.ColimitOfShape J Z), motive ⋯) → motive x_1 | null | false |
CategoryTheory.MorphismProperty.Over.pullbackCongr_hom_app_left_fst_assoc | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] {X Y : T} {f : X ⟶ Y} [inst_2 : P.HasPullbacksAlong f] {g : X ⟶ Y}
[inst_3 : P.IsStableUnderBaseChangeAlong f] [inst_4 : Q.IsStableUnderBaseChange] (h : f = g) (A : P.Over Q Y) {Z :... | null | true |
Std.TreeSet.mem_insert_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α}, k ∈ t.insert k | null | true |
_private.Init.Data.Array.Erase.0.Array.mem_eraseIdx_iff_getElem._simp_1_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} {x : α} {l : List α} {k : ℕ}, (x ∈ l.eraseIdx k) = ∃ i, ∃ (h : i < l.length), i ≠ k ∧ l[i] = x | null | false |
Option.WeakPseudoEMetricSpace.OfIsOpenEmbedding._proof_2 | Mathlib.Topology.EMetricSpace.Weak | ∀ {α : Type u_1} [t : TopologicalSpace α] [m : WeakPseudoEMetricSpace α] [inst : EDist (Option α)],
inst = Option.toEDist → ∀ (x y : Option α), edist x y = edist y x | null | false |
MeasureTheory.Measure.IsHaarMeasure.mk._flat_ctor | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_3} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : MeasurableSpace G]
{μ : MeasureTheory.Measure G},
(∀ ⦃K : Set G⦄, IsCompact K → μ K < ⊤) →
(∀ (g : G), MeasureTheory.Measure.map (fun x => g * x) μ = μ) →
(∀ (U : Set G), IsOpen U → U.Nonempty → μ U ≠ 0) → μ.IsHaarMeasure | null | false |
_private.Mathlib.Algebra.Algebra.Unitization.0.Unitization.isSelfAdjoint_inr._simp_1_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x = (star x = x) | null | false |
_private.Mathlib.Lean.Meta.Simp.0.Lean.Meta.Simp.withoutTheorems.match_1 | Mathlib.Lean.Meta.Simp | {α : Type} →
(motive : α × Lean.Meta.Simp.State → Sort u_1) →
(x : α × Lean.Meta.Simp.State) → ((x : α) → (s : Lean.Meta.Simp.State) → motive (x, s)) → motive x | null | false |
Nat.Partrec.Code.eval_eq_rfindOpt | Mathlib.Computability.PartrecCode | ∀ (c : Nat.Partrec.Code) (n : ℕ), c.eval n = Nat.rfindOpt fun k => Nat.Partrec.Code.evaln k c n | null | true |
_private.Mathlib.RingTheory.Jacobson.Ring.0.IsLocalization.isMaximal_iff_isMaximal_disjoint._simp_1_2 | Mathlib.RingTheory.Jacobson.Ring | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
SSet.stdSimplex.objMk₁_of_castSucc_lt | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplexOne | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)), j.castSucc < i → (SSet.stdSimplex.objMk₁ i) j = 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.