name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
OrderDual.instCommMonoid._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : CommMonoid α] (a b : αᵒᵈ), a * b = b * a | null | false |
Filter.TendstoCofinite.finite_preimage | Mathlib.Order.Filter.TendstoCofinite | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [Filter.TendstoCofinite f] {s : Set β}, s.Finite → (f ⁻¹' s).Finite | null | true |
CategoryTheory.Comma.colimitAuxiliaryCocone | Mathlib.CategoryTheory.Limits.Comma | {J : Type w} →
[inst : CategoryTheory.Category.{w', w} J] →
{A : Type u₁} →
[inst_1 : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_3 : CategoryTheory.Category.{v₃, u₃} T] →
... | (Implementation). An auxiliary cocone which is useful in order to construct colimits
in the comma category. | true |
Lean.Meta.SimpTheorems.addLetDeclToUnfold | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Meta.SimpTheorems → Lean.FVarId → Lean.Meta.SimpTheorems | null | true |
Valued.mk.noConfusion | Mathlib.Topology.Algebra.Valued.ValuationTopology | {R : Type u} →
{inst : Ring R} →
{Γ₀ : outParam (Type v)} →
{inst_1 : LinearOrderedCommGroupWithZero Γ₀} →
{P : Sort u_1} →
{toUniformSpace : UniformSpace R} →
{toIsUniformAddGroup : IsUniformAddGroup R} →
{v : Valuation R Γ₀} →
{is_topological_val... | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.parallelepiped_single._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | null | false |
GeneralSchauderBasis.mk | Mathlib.Analysis.Normed.Module.Bases | {β : Type u_3} →
{𝕜 : Type u_4} →
{X : Type u_5} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup X] →
[inst_2 : NormedSpace 𝕜 X] →
{L : SummationFilter β} →
(basis : β → X) →
(coord : β → StrongDual 𝕜 X) →
... | null | true |
AddEquiv.op_symm_apply_symm_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_3} {β : Type u_4} [inst : Add α] [inst_1 : Add β] (f : αᵃᵒᵖ ≃+ βᵃᵒᵖ) (a : β),
(AddEquiv.op.symm f).symm a = (AddOpposite.unop ∘ ⇑f.symm ∘ AddOpposite.op) a | null | true |
AddGroupSeminorm.instIsScalarTowerOfReal | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {R : Type u_1} {R' : Type u_2} {E : Type u_3} [inst : AddGroup E] [inst_1 : SMul R ℝ] [inst_2 : SMul R NNReal]
[inst_3 : IsScalarTower R NNReal ℝ] [inst_4 : SMul R' ℝ] [inst_5 : SMul R' NNReal]
[inst_6 : IsScalarTower R' NNReal ℝ] [inst_7 : SMul R R'] [IsScalarTower R R' ℝ],
IsScalarTower R R' (AddGroupSeminorm... | null | true |
ContinuousLinearMap.sSup_unitClosedBall_eq_norm | Mathlib.Analysis.Normed.Operator.NNNorm | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : DenselyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : E →SL[σ₁₂... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast._proof_17 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w : ℕ) (eaig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit)
(evec : eaig.RefVec w),
aig.decls.size ≤ { aig := eaig, vec := evec }.aig.decls.size →
aig.decls.size ≤ (Std.Tactic.BVDecide.BVExpr.bitblast.blastClz eaig evec).aig.decls.size | null | false |
MeasureTheory.OuterMeasure.ofFunction | Mathlib.MeasureTheory.OuterMeasure.OfFunction | {α : Type u_1} → (m : Set α → ENNReal) → m ∅ = 0 → MeasureTheory.OuterMeasure α | Given any function `m` assigning measures to sets satisfying `m ∅ = 0`, there is
a unique maximal outer measure `μ` satisfying `μ s ≤ m s` for all `s : Set α`. | true |
SkewPolynomial.erase_same | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] (p : SkewPolynomial R) (n : ℕ), (SkewPolynomial.erase n p).coeff n = 0 | null | true |
Std.HashMap.get!_erase | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited β] {k a : α}, (m.erase k).get! a = if (k == a) = true then default else m.get! a | null | true |
ZeroAtInftyContinuousMap.instNonUnitalCommCStarAlgebra | Mathlib.Analysis.CStarAlgebra.ContinuousMap | {α : Type u_1} →
{A : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : NonUnitalCommCStarAlgebra A] → NonUnitalCommCStarAlgebra (ZeroAtInftyContinuousMap α A) | null | true |
String.data_push | Init.Data.String.Basic | ∀ {s : String} (c : Char), (s.push c).toList = s.toList ++ [c] | null | true |
BoundedVariationOn.exists_tendsto_atBot | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {M : Type u_3} [inst_1 : PseudoEMetricSpace M] [CompleteSpace M]
[hM : Nonempty M] {f : α → M} {s : Set α},
BoundedVariationOn f s → ∃ l, Filter.Tendsto f (Filter.principal s ⊓ Filter.atBot) (nhds l) | A bounded variation function has a limit at `-∞`. | true |
IsDedekindDomain.primesOverEquivPrimesOver | Mathlib.RingTheory.Localization.AtPrime.Extension | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(p : Ideal R) →
[inst_3 : p.IsPrime] →
(Rₚ : Type u_3) →
[inst_4 : CommRing Rₚ] →
[inst_5 : Algebra R Rₚ] →
... | For `R ⊆ S` an extension of Dedekind domains and `p` a prime ideal of `R`, the bijection
between the primes of `S` over `p` and the primes over the maximal ideal of `Rₚ` in `Sₚ` where
`Rₚ` and `Sₚ` are resp. the localizations of `R` and `S` at the complement of `p`.
| true |
CategoryTheory.Adjunction.sheafPushforwardContinuous._proof_5 | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G)
(J : CategoryTheory.GrothendieckTopology C) (... | null | false |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.not_even_iff._proof_1_1 | Mathlib.Algebra.Group.Nat.Even | ∀ {n : ℕ}, ¬Even n ↔ n % 2 = 1 | null | false |
Lean.KeyedDeclsAttribute.mk.noConfusion | Lean.KeyedDeclsAttribute | {γ : Type} →
{P : Sort u} →
{defn : Lean.KeyedDeclsAttribute.Def γ} →
{tableRef : IO.Ref (Lean.KeyedDeclsAttribute.Table γ)} →
{ext : Lean.KeyedDeclsAttribute.Extension γ} →
{defn' : Lean.KeyedDeclsAttribute.Def γ} →
{tableRef' : IO.Ref (Lean.KeyedDeclsAttribute.Table γ)} →
... | null | false |
Int16.toBitVec | Init.Data.SInt.Basic | Int16 → BitVec 16 | Obtain the `BitVec` that contains the 2's complement representation of the `Int16`.
| true |
Int.emod_add_ediv_mul | Init.Data.Int.DivMod.Bootstrap | ∀ (a b : ℤ), a % b + a / b * b = a | null | true |
RingHom.finitePresentation_respectsIso | Mathlib.RingTheory.RingHom.FinitePresentation | RingHom.RespectsIso @RingHom.FinitePresentation | Being finitely-presented respects isomorphisms. | true |
Topology.IsQuotientMap.of_comp | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
Continuous f → Continuous g → Topology.IsQuotientMap (g ∘ f) → Topology.IsQuotientMap g | null | true |
NonAssocRing.ctorIdx | Mathlib.Algebra.Ring.Defs | {α : Type u_1} → NonAssocRing α → ℕ | null | false |
CategoryTheory.uliftYonedaEquiv_symm_comp_assoc | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F G : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁))}
{X : Cᵒᵖ} (x : F.obj X) (f : F ⟶ G) {Z : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁))} (h : G ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.uliftYonedaEquiv.symm x) (CategoryTheory.CategoryStr... | null | true |
IsRCLikeNormedField.casesOn | Mathlib.Analysis.RCLike.Basic | {𝕜 : Type u_3} →
[hk : NormedField 𝕜] →
{motive : IsRCLikeNormedField 𝕜 → Sort u} →
(t : IsRCLikeNormedField 𝕜) → ((out : ∃ h, hk = h.toNormedField) → motive ⋯) → motive t | null | false |
Polynomial.eventually_atBot_not_isRoot | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P : Polynomial 𝕜),
P ≠ 0 → ∀ᶠ (x : 𝕜) in Filter.atBot, ¬P.IsRoot x | null | true |
Finsupp.semilatticeInf._proof_4 | Mathlib.Order.Preorder.Finsupp | ∀ {ι : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : SemilatticeInf M] (_f _g _i : ι →₀ M),
_f ≤ _g → _f ≤ _i → ∀ (s : ι), _f s ≤ _g s ⊓ _i s | null | false |
Std.Tactic.BVDecide.Normalize.UInt16.toBitVec_ite | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {c : Prop} {t e : UInt16} [inst : Decidable c], (if c then t else e).toBitVec = if c then t.toBitVec else e.toBitVec | null | true |
hasFDerivWithinAt_closure_of_tendsto_fderiv | Mathlib.Analysis.Calculus.FDeriv.Extend | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {f : E → F} {s : Set E} {x : E} {f' : E →L[ℝ] F},
DifferentiableOn ℝ f s →
Convex ℝ s →
IsOpen s →
(∀ y ∈ closure s, ContinuousWithinAt f s y) →
... | If a function `f` is differentiable in a convex open set and continuous on its closure, and its
derivative converges to a limit `f'` at a point on the boundary, then `f` is differentiable there
with derivative `f'`. | true |
Ideal.sInf_isPrime_of_isChain | Mathlib.RingTheory.Ideal.Maximal | ∀ {α : Type u} [inst : Semiring α] {s : Set (Ideal α)},
s.Nonempty → IsChain (fun x1 x2 => x1 ≤ x2) s → (∀ p ∈ s, p.IsPrime) → (sInf s).IsPrime | null | true |
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functorToMonoOver._proof_4 | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : C} [inst_1 : CategoryTheory.Abelian C]
(hG : CategoryTheory.IsSeparator G) {X : C} [inst_2 : CategoryTheory.IsGrothendieckAbelian.{u_3, u_1, u_2} C]
(A₀ : CategoryTheory.Subobject X) (J : Type u_3) [inst_3 : LinearOrder J] [inst_4 : OrderBot J] [in... | null | false |
SimpleGraph.chromaticNumber_sum | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_3} {W : Type u_5} {G : SimpleGraph V} {H : SimpleGraph W},
(G ⊕g H).chromaticNumber = max G.chromaticNumber H.chromaticNumber | null | true |
Profinite.NobelingProof.Products.evalCons | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u_1} [inst : LinearOrder I] {C : Set (I → Bool)} {l : List I} {a : I}
(hla : List.IsChain (fun x1 x2 => x1 > x2) (a :: l)),
Profinite.NobelingProof.Products.eval C ⟨a :: l, hla⟩ =
Profinite.NobelingProof.e C a * Profinite.NobelingProof.Products.eval C ⟨l, ⋯⟩ | null | true |
_private.Batteries.Tactic.Congr.0.Batteries.Tactic._aux_Batteries_Tactic_Congr___macroRules_Batteries_Tactic_congrConfigWith_1.match_6 | Batteries.Tactic.Congr | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.config) → Sort u_1) →
(cfg : Option (Lean.TSyntax `Lean.Parser.Tactic.config)) →
(Unit → motive none) → ((cfg : Lean.TSyntax `Lean.Parser.Tactic.config) → motive (some cfg)) → motive cfg | null | false |
Quaternion.im_sub | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a b : Quaternion R), (a - b).im = a.im - b.im | null | true |
AddMonCat.addMonoidObj.eq_1 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J AddMonCat) (j : J),
AddMonCat.addMonoidObj F j = (F.obj j).str | null | true |
Set.mulIndicator_range_comp | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] {ι : Sort u_5} (f : ι → α) (g : α → M),
(Set.range f).mulIndicator g ∘ f = g ∘ f | null | true |
Std.Sat.AIG.mkGateCached.go_le_size | Std.Sat.AIG.CachedLemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (input : aig.BinaryInput),
aig.decls.size ≤ (Std.Sat.AIG.mkGateCached.go aig input).aig.decls.size | null | true |
AddSubmonoid.center.addCommMonoid'._proof_6 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : AddZeroClass M] (a b : ↥(AddSubsemigroup.center M)), a + b = b + a | null | false |
Submodule.instIsOrderedAddMonoid | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsOrderedAddMonoid (Submodule R M) | null | true |
CategoryTheory.Abelian.AbelianStruct.cokernelCofork | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X Y : C} → {f : X ⟶ Y} → CategoryTheory.Abelian.AbelianStruct f → CategoryTheory.Limits.CokernelCofork f | a colimit cokernel cofork of `f` | true |
_private.Lean.Declaration.0.Lean.instBEqReducibilityHints.beq._sparseCasesOn_2 | Lean.Declaration | {motive : Lean.ReducibilityHints → Sort u} →
(t : Lean.ReducibilityHints) →
motive Lean.ReducibilityHints.abbrev → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Std.DTreeMap.Raw.foldrM_eq_foldrM_toArray | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} {δ : Type w}
{m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {f : (a : α) → β a → δ → m δ} {init : δ},
Std.DTreeMap.Raw.foldrM f init t = Array.foldrM (fun a b => f a.fst a.snd b) init t.toArray | null | true |
_private.Mathlib.Algebra.Group.Defs.0.inv_eq_of_mul | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : Group G] {a b : G}, a * b = 1 → a⁻¹ = b | null | true |
BddAbove.image2_bddBelow | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {f : α → β → γ}
{s : Set α} {t : Set β},
(∀ (b : β), Antitone (Function.swap f b)) →
(∀ (a : α), Antitone (f a)) → BddAbove s → BddAbove t → BddBelow (Set.image2 f s t) | null | true |
LinearMap.nondegenerate_toMatrix₂'_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} {m : Type u_12} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m]
[inst_3 : DecidableEq n] [inst_4 : Fintype n] {B : (m → R) →ₗ[R] (n → R) →ₗ[R] R},
((LinearMap.toMatrix₂' R) B).Nondegenerate = B.Nondegenerate | null | false |
AdjoinRoot.instField._proof_13 | Mathlib.RingTheory.AdjoinRoot | ∀ {K : Type u_1} [inst : Field K], IsScalarTower ℚ K K | null | false |
_private.Mathlib.Topology.Separation.Hausdorff.0.T2Quotient.instT2Space._simp_2 | Mathlib.Topology.Separation.Hausdorff | ∀ {α : Sort u_1} {r : Setoid α} {x y : α}, (⟦x⟧ = ⟦y⟧) = r x y | null | false |
HahnEmbedding.Seed.toArchimedeanStrata | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
... | null | true |
Rat.nnabs._proof_1 | Mathlib.Data.NNRat.Defs | ∀ (x : ℚ), 0 ≤ |x| | null | false |
SubAddAction.ofFixingAddSubgroup.append._proof_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {α : Type u_1} {s : Set α} [Finite ↑s], Nonempty (Fin s.ncard ≃ ↑s) | null | false |
Subrepresentation.coe_sup._simp_1 | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : Semiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} (ρ₁ ρ₂ : Subrepresentation ρ), ↑ρ₁ + ↑ρ₂ = ↑(ρ₁ ⊔ ρ₂) | null | false |
IsTopologicalGroup.mulInvClosureNhd.mk | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : TopologicalSpace G] {T W : Set G} [inst_1 : Group G],
T ∈ nhds 1 → T⁻¹ = T → IsOpen T → W * T ⊆ W → IsTopologicalGroup.mulInvClosureNhd T W | null | true |
_private.Batteries.Data.List.Lemmas.0.List.foldrIdx_start._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_2} {α_1 : Type u_1} {i : α_1} {f : ℕ → α → α_1 → α_1} {s : ℕ},
List.foldrIdx f i [] s = List.foldrIdx (fun x => f (x + s)) i [] | null | false |
Matrix.eq_zero_of_forall_pow_sum_mul_pow_eq_zero | Mathlib.LinearAlgebra.Vandermonde | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [IsDomain R] {f v : Fin n → R},
Function.Injective f → (∀ (i : Fin n), ∑ j, v j * f j ^ ↑i = 0) → v = 0 | null | true |
IsPurelyInseparable.algebraMap_elemReduct_eq | Mathlib.FieldTheory.PurelyInseparable.Exponent | ∀ (K : Type u_2) {L : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : IsPurelyInseparable K L] (a : L),
(algebraMap K L) (IsPurelyInseparable.elemReduct K a) = a ^ ringExpChar K ^ IsPurelyInseparable.elemExponent K a | null | true |
TopCat.Presheaf.stalkFunctor_preserves_mono | Mathlib.Topology.Sheaves.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C] {X : TopCat}
{FC : C → C → Type u_1} {CC : C → Type v} [inst_2 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)]
[instCC : CategoryTheory.ConcreteCategory C FC]
[CategoryTheory.Limits.PreservesFilteredColimits (Cat... | null | true |
CategoryTheory.InjectiveResolution.ofCocomplex_d_0_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] (Z : C),
(CategoryTheory.InjectiveResolution.ofCocomplex Z).d 0 1 = CategoryTheory.Injective.d (CategoryTheory.Injective.ι Z) | null | true |
Mathlib.Tactic.Bicategory.Context._sizeOf_1 | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Mathlib.Tactic.Bicategory.Context → ℕ | null | false |
_private.Lean.Environment.0.Lean.Environment.instBEqRealizeConstKey.beq | Lean.Environment | Lean.Environment.RealizeConstKey✝ → Lean.Environment.RealizeConstKey✝ → Bool | null | true |
RootPairing.GeckConstruction.equivLieAlgebra._proof_16 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {K : Type u_1} [inst : Field K] [inst_1 : CharZero K] [inst_2 : IsAlgClosed K] {L : Type u_2} [inst_3 : LieRing L]
[inst_4 : LieAlgebra K L] [inst_5 : FiniteDimensional K L] [inst_6 : LieAlgebra.IsSimple K L] (H : LieSubalgebra K L)
[inst_7 : H.IsCartanSubalgebra], (LieAlgebra.IsKilling.rootSystem H).IsIrreducibl... | null | false |
CategoryTheory.Limits.Cone.extendComp._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor J C} (s : CategoryTheory.Limits.Cone F)
{X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt) (j : J),
(s.extend (CategoryTheory.CategoryStruct.comp f g)).π.app j =
Category... | null | false |
LocallyConstant.congrRight | Mathlib.Topology.LocallyConstant.Basic | {X : Type u_1} →
{Y : Type u_2} → {Z : Type u_3} → [inst : TopologicalSpace X] → Y ≃ Z → LocallyConstant X Y ≃ LocallyConstant X Z | The equivalence between `LocallyConstant X Y` and `LocallyConstant X Z` given an
equivalence `Y ≃ Z`
| true |
_private.Mathlib.Topology.Order.Basic.0.instIsCountablyGenerated_atBot.match_1 | Mathlib.Topology.Order.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Set α) (motive : BddBelow s → Prop) (x : BddBelow s),
(∀ (x : α) (hx : x ∈ lowerBounds s), motive ⋯) → motive x | null | false |
ContMDiffWithinAt.mul | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞}
{G : Type u_4} [inst_4 : Mul G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] {E' :... | null | true |
CategoryTheory.Functor.Braided.toMonoidal_injective | 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 : CategoryThe... | null | true |
DyckWord.insidePart._proof_2 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord) (h : ¬p = 0), p.take (p.firstReturn + 1) ⋯ ≠ 0 | null | false |
NormedAddCommGroup.toCompl._proof_1 | Mathlib.Analysis.Normed.Group.HomCompletion | ∀ {G : Type u_1} [inst : SeminormedAddCommGroup G] (v : G), ‖↑v‖ ≤ 1 * ‖v‖ | null | false |
ProbabilityTheory.IndepFun.process_indepFun_process₀ | Mathlib.Probability.Independence.Process.Basic | ∀ {S : Type u_1} {Ω : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {T : Type u_4} {𝓧 : S → Type u_5}
{𝓨 : T → Type u_6} [inst : (i : S) → MeasurableSpace (𝓧 i)] [inst_1 : (j : T) → MeasurableSpace (𝓨 j)]
{X : (i : S) → Ω → 𝓧 i} {Y : (j : T) → Ω → 𝓨 j},
(∀ (i : S), AEMeasurable (X i) P) →... | Two stochastic processes $(X_s)_{s \in S}$ and $(Y_t)_{t \in T}$ are independent if
for all $s_1, ..., s_p \in S$ and $t_1, ..., t_q \in T$ the two families
$(X_{s_1}, ..., X_{s_p})$ and $(Y_{t_1}, ..., Y_{t_q})$ are independent.
This version only requires a.e.-measurability. | true |
_private.Aesop.Saturate.0.Aesop.Stateful.Queue | Aesop.Saturate | Type | null | true |
Equiv.Perm.isThreeCycle_swap_mul_swap_same | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {a b c : α},
a ≠ b → a ≠ c → b ≠ c → (Equiv.swap a b * Equiv.swap a c).IsThreeCycle | null | true |
Lean.Parser.Command.eval | Lean.Parser.Command | Lean.Parser.Parser | `#eval e` evaluates the expression `e` by compiling it and running the compiled code. It then
prints the resulting value.
* The command attempts to use `ToExpr`, `Repr`, or `ToString` instances to print the result.
* If `e` is a monadic value of type `m ty`, then the command tries to adapt the monad `m`
to one of th... | true |
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.allCombinations.go.eq_def | Lean.Elab.PreDefinition.Structural.FindRecArg | ∀ {α : Type u_1} (xss : Array (Array α)) (i : ℕ) (acc : Array α),
Lean.Elab.Structural.allCombinations.go✝ xss i acc =
if h : i < xss.size then
Array.flatMap (fun x => Lean.Elab.Structural.allCombinations.go✝ xss (i + 1) (acc.push x)) xss[i]
else #[acc] | null | true |
ZMod.intCast_cast_add | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} (x y : ZMod n), (x + y).cast = (x.cast + y.cast) % ↑n | null | true |
CategoryTheory.Pretriangulated.unop_distinguished | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C],
∀ T ∈ Categor... | null | true |
WeierstrassCurve.Affine.polynomial_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} [inst : CommRing R] {W : WeierstrassCurve.Affine R} [Nontrivial R], W.polynomial ≠ 0 | null | true |
CategoryTheory.ComposableArrows.map'_comp._auto_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
SchwartzMap.instModule._proof_6 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_3} {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] (x : SchwartzMap E F), 0 • x = 0 | null | false |
Batteries.PairingHeap.ofList | Batteries.Data.PairingHeap | {α : Type u} → (le : α → α → Bool) → List α → Batteries.PairingHeap α le | `O(n log n)`. Construct a heap from a list by inserting all the elements. | true |
Irreducible.prime | Mathlib.Algebra.Prime.Defs | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [DecompositionMonoid M] {a : M}, Irreducible a → Prime a | null | true |
Lean.Elab.instLEHoverableInfoPrio | Lean.Elab.InfoTree.Util | LE Lean.Elab.HoverableInfoPrio | null | true |
NonemptyInterval.fst_mul | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : Mul α] [inst_2 : MulLeftMono α] [inst_3 : MulRightMono α]
(s t : NonemptyInterval α), (s * t).toProd.1 = s.toProd.1 * t.toProd.1 | null | true |
List.next_eq_getElem | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α} (ha : a ∈ l),
l.next a ha = l[(List.idxOf a l + 1) % l.length] | null | true |
ZSpan.fract_fract | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] (m : E), ZSpan.fract b (ZSpan.fract b m) = ZSpan.fract b m | null | true |
CategoryTheory.uliftYoneda_obj_map | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C) {X_1 Y : Cᵒᵖ} (f : X_1 ⟶ Y),
(CategoryTheory.uliftYoneda.{w, v₁, u₁}.obj X).map f =
TypeCat.ofHom fun x => { down := CategoryTheory.CategoryStruct.comp f.unop x.down } | null | true |
CategoryTheory.Limits.Cocone.w_assoc | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {j j' : J} (f : j' ⟶ j) {Z : C} (h : c.pt ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.co... | null | true |
ModuleCat.semilinearMapAddEquiv._proof_5 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_2} {S : Type u_3} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) (M : ModuleCat R) (N : ModuleCat S),
Function.RightInverse (fun g => { toFun := ⇑(CategoryTheory.ConcreteCategory.hom g), map_add' := ⋯, map_smul' := ⋯ })
fun g => ModuleCat.ofHom { toFun := ⇑g, map_add' := ⋯, map_smul' := ⋯ } | null | false |
Finset.commMonoid.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : CommMonoid α],
Finset.commMonoid = Function.Injective.commMonoid SetLike.coe ⋯ ⋯ ⋯ ⋯ | null | true |
_private.Mathlib.Data.Finsupp.Order.0.Finsupp.embDomain_le_embDomain_iff_le._simp_1_1 | Mathlib.Data.Finsupp.Order | ∀ {ι : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : LE M] {f g : ι →₀ M}, (f ≤ g) = ∀ (i : ι), f i ≤ g i | null | false |
_private.Mathlib.Algebra.BigOperators.WithTop.0.WithTop.prod_eq_top._simp_1_1 | Mathlib.Algebra.BigOperators.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, (a ∈ s.erase b) = (a ≠ b ∧ a ∈ s) | null | false |
continuousAt_matrix_inv | Mathlib.Topology.Instances.Matrix | ∀ {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace R] [inst_1 : Fintype n] [inst_2 : DecidableEq n]
[inst_3 : CommRing R] [IsTopologicalRing R] (A : Matrix n n R),
ContinuousAt Ring.inverse A.det → ContinuousAt Inv.inv A | When `Ring.inverse` is continuous at the determinant (such as in a `NormedRing`, or a
topological field), so is `Matrix.inv`. | true |
_private.Mathlib.Analysis.MeanInequalities.0.NNReal.Lr_le_Lp_mul_Lq._simp_1_4 | Mathlib.Analysis.MeanInequalities | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.Compacts.instLocallyConnectedSpace._proof_10 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (u : Set (Set α)),
∀ f ∈ Set.univ.pi fun U => {K | (↑K).Nonempty ∧ (↑K).Finite ∧ ↑K ⊆ ↑U}, ∀ (i : { x // x ∈ u }), (↑(f i)).Finite | null | false |
Std.DTreeMap.Internal.Impl.foldlM | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
{δ : Type w} →
{m : Type w → Type u_1} → [Monad m] → (δ → (a : α) → β a → m δ) → δ → Std.DTreeMap.Internal.Impl α β → m δ | Folds the given function over the mappings in the tree in ascending order. | true |
_private.Mathlib.Analysis.Convex.Side.0.AffineSubspace.wSameSide_self_iff.match_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_2} {V : Type u_3} {P : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] {s : AffineSubspace R P} (motive : (↑s).Nonempty → Prop) (x : (↑s).Nonempty),
(∀ (p : P) (hp : p ∈ ↑s), motive ⋯) → motive x | null | false |
MulAction.equivSubgroupOrbitsSetoidComap._proof_10 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ {G : Type u_2} {X : Type u_1} [inst : Group G] [inst_1 : MulAction G X] (H : Subgroup G)
(ω : Quotient (MulAction.orbitRel G X)),
Function.RightInverse (fun q => q.liftOn' (fun x => ⟦⟨↑x, ⋯⟩⟧) ⋯) fun q => Quotient.liftOn' q (fun x => ⟦⟨↑x, ⋯⟩⟧) ⋯ | null | false |
Subsemiring.subtype_apply | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} [inst : NonAssocSemiring R] {s : Subsemiring R} (x : ↥s), s.subtype x = ↑x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.