name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
AlgebraicGeometry.Scheme.basicOpen_restrict | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {V U : X.Opens} (i : V ⟶ U) (f : ↑(X.presheaf.obj (Opposite.op U))),
X.basicOpen (TopCat.Presheaf.restrict f i) ≤ X.basicOpen f |
CategoryTheory.Pretriangulated.instHasFiniteCoproducts | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
CategoryTheory.Limits.HasFiniteCoproducts C |
Std.DTreeMap.Const.getKey?_insertMany_list_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
k ∈ List.map Prod.fst l → (Std.DTreeMap.Const.insertMany t l).getKey? k' = some k |
ProbabilityTheory.complexMGF_id_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (z : ℂ),
ProbabilityTheory.complexMGF id (ProbabilityTheory.gaussianReal μ v) z = Complex.exp (z * ↑μ + ↑↑v * z ^ 2 / 2) |
intervalIntegral.measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_le | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {ι : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a : ℝ} {c : E}
{l l' : Filter ℝ} {lt : Filter ι} {μ : MeasureTheory.Measure ℝ} {u v : ι → ℝ} [MeasureTheory.IsLocallyFiniteMeasure μ]
[CompleteSpace E] [intervalIntegral.FTCFilter a l l'],
StronglyMeasurableAtFilter f l' μ →
Filter.Tendsto f (l' ⊓ MeasureTheory.ae μ) (nhds c) →
Filter.Tendsto u lt l →
Filter.Tendsto v lt l →
u ≤ᶠ[lt] v →
(fun t => ∫ (x : ℝ) in u t..v t, f x ∂μ - μ.real (Set.Ioc (u t) (v t)) • c) =o[lt] fun t =>
μ.real (Set.Ioc (u t) (v t)) |
Matroid.freeOn.eq_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (E : Set α), Matroid.freeOn E = (Matroid.loopyOn E)✶ |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems.isErased | Lean.Elab.Tactic.Do.Attr | Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems → Lean.Elab.Tactic.Do.SpecAttr.SpecProof → Bool |
PSigma.Lex.preorder._proof_4 | Mathlib.Data.PSigma.Order | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : Preorder ι] [inst_1 : (i : ι) → Preorder (α i)] (a b : Σₗ' (i : ι), α i),
a < b ↔ a ≤ b ∧ ¬b ≤ a |
«command#long_names_» | Mathlib.Util.LongNames | Lean.ParserDescr |
OrderedFinpartition.eraseMiddle._proof_11 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (hc : Set.range (c.emb 0) ≠ {0}) (i j : Fin c.length),
i < j →
(fun m =>
if h : m = c.index 0 then
(c.emb m
(Fin.cast ⋯ ⟨Function.update c.partSize (c.index 0) (c.partSize (c.index 0) - 1) m - 1, ⋯⟩.succ)).pred
⋯
else
(c.emb m (Fin.cast ⋯ ⟨Function.update c.partSize (c.index 0) (c.partSize (c.index 0) - 1) m - 1, ⋯⟩)).pred
⋯)
i <
(fun m =>
if h : m = c.index 0 then
(c.emb m
(Fin.cast ⋯ ⟨Function.update c.partSize (c.index 0) (c.partSize (c.index 0) - 1) m - 1, ⋯⟩.succ)).pred
⋯
else
(c.emb m (Fin.cast ⋯ ⟨Function.update c.partSize (c.index 0) (c.partSize (c.index 0) - 1) m - 1, ⋯⟩)).pred
⋯)
j |
Sub.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : Sub α} → {α' : Type u} → {t' : Sub α'} → α = α' → t ≍ t' → Sub.noConfusionType P t t' |
BooleanAlgebra.recOn | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} →
{motive : BooleanAlgebra α → Sort u_1} →
(t : BooleanAlgebra α) →
([toDistribLattice : DistribLattice α] →
[toCompl : Compl α] →
[toSDiff : SDiff α] →
[toHImp : HImp α] →
[toTop : Top α] →
[toBot : Bot α] →
(inf_compl_le_bot : ∀ (x : α), x ⊓ xᶜ ≤ ⊥) →
(top_le_sup_compl : ∀ (x : α), ⊤ ≤ x ⊔ xᶜ) →
(le_top : ∀ (a : α), a ≤ ⊤) →
(bot_le : ∀ (a : α), ⊥ ≤ a) →
(sdiff_eq : ∀ (x y : α), x \ y = x ⊓ yᶜ) →
(himp_eq : ∀ (x y : α), x ⇨ y = y ⊔ xᶜ) →
motive
{ toDistribLattice := toDistribLattice, toCompl := toCompl, toSDiff := toSDiff,
toHImp := toHImp, toTop := toTop, toBot := toBot,
inf_compl_le_bot := inf_compl_le_bot, top_le_sup_compl := top_le_sup_compl,
le_top := le_top, bot_le := bot_le, sdiff_eq := sdiff_eq, himp_eq := himp_eq }) →
motive t |
RingHom.liftOfRightInverse_comp | Mathlib.RingTheory.Ideal.Maps | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : Ring A] [inst_1 : Ring B] [inst_2 : Ring C] (f : A →+* B)
(f_inv : B → A) (hf : Function.RightInverse f_inv ⇑f) (g : { g // RingHom.ker f ≤ RingHom.ker g }),
((f.liftOfRightInverse f_inv hf) g).comp f = ↑g |
LinearMap.extendScalarsOfIsLocalizationEquiv._proof_8 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_3} [inst : CommSemiring R] (A : Type u_4) [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {M : Type u_1}
{N : Type u_2} [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [IsScalarTower R A M]
[inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : Module A N] [IsScalarTower R A N],
LinearMap.CompatibleSMul M N R A |
Int.Linear.Poly.insert | Init.Data.Int.Linear | ℤ → Int.Linear.Var → Int.Linear.Poly → Int.Linear.Poly |
_private.Mathlib.Topology.Category.CompHaus.EffectiveEpi.0.CompHaus.effectiveEpiFamily_tfae.match_1_1 | Mathlib.Topology.Category.CompHaus.EffectiveEpi | ∀ {α : Type} [inst : Finite α] {B : CompHaus} (X : α → CompHaus) (π : (a : α) → X a ⟶ B)
(motive : CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π) → Prop)
(x : CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π)),
(∀ (x : CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π)), motive x) → motive x |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.empty_isBase_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (M : Matroid α), M.3 ∅ = True |
IsContDiffImplicitAt.implicitFunctionData | Mathlib.Analysis.Calculus.ImplicitContDiff | {𝕜 : Type u_1} →
[inst : RCLike 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : CompleteSpace E] →
{F : Type u_3} →
[inst_4 : NormedAddCommGroup F] →
[inst_5 : NormedSpace 𝕜 F] →
[inst_6 : CompleteSpace F] →
{G : Type u_4} →
[inst_7 : NormedAddCommGroup G] →
[inst_8 : NormedSpace 𝕜 G] →
[inst_9 : CompleteSpace G] →
{n : WithTop ℕ∞} →
{f : E × F → G} →
{f' : E × F →L[𝕜] G} →
{a : E × F} → IsContDiffImplicitAt n f f' a → ImplicitFunctionData 𝕜 (E × F) E G |
CategoryTheory.shrinkYonedaMonObjObjEquiv._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.ShrinkYoneda | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] {M : CategoryTheory.Mon C} {Y : Cᵒᵖ},
Small.{u_1, u_2} ↑((CategoryTheory.yonedaMon.obj M).obj Y) |
_private.Mathlib.AlgebraicTopology.DoldKan.Degeneracies.0.AlgebraicTopology.DoldKan.σ_comp_P_eq_zero._simp_1_5 | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True |
Tactic.NormNum.int_lcm_helper | Mathlib.Tactic.NormNum.GCD | ∀ {x y : ℤ} {x' y' d : ℕ}, x.natAbs = x' → y.natAbs = y' → x'.lcm y' = d → x.lcm y = d |
IsZGroup.isCyclic_commutator | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ (G : Type u_1) [inst : Group G] [Finite G] [IsZGroup G], IsCyclic ↥(commutator G) |
CategoryTheory.Limits.limit.isLimit | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasLimit F] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.limit.cone F) |
LinearMap.compMultilinearMap_add | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃]
[inst_4 : (i : ι) → Module R (M₁ i)] [inst_5 : Module R M₂] [inst_6 : Module R M₃] (g : M₂ →ₗ[R] M₃)
(f₁ f₂ : MultilinearMap R M₁ M₂), g.compMultilinearMap (f₁ + f₂) = g.compMultilinearMap f₁ + g.compMultilinearMap f₂ |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.instNoMinOrderElemIio.match_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α} (a_1 : ↑(Set.Iio a)) (motive : (∃ b, b < ↑a_1) → Prop) (x : ∃ b, b < ↑a_1),
(∀ (b : α) (hb : b < ↑a_1), motive ⋯) → motive x |
BitVec.ushiftRight_and_distrib | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w) (n : ℕ), (x &&& y) >>> n = x >>> n &&& y >>> n |
ENNReal.toReal_eq_toReal_iff' | Mathlib.Data.ENNReal.Basic | ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ ⊤ → (x.toReal = y.toReal ↔ x = y) |
List.zipWithM.loop | Init.Data.List.Control | {m : Type u → Type v} →
[Monad m] → {α : Type w} → {β : Type x} → {γ : Type u} → (α → β → m γ) → List α → List β → Array γ → m (List γ) |
_private.Mathlib.MeasureTheory.Integral.CircleIntegral.0.circleIntegrable_sub_inv_iff._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) |
GradedRing.projZeroRingHom'_surjective | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddCommMonoid ι]
[inst_3 : PartialOrder ι] [inst_4 : CanonicallyOrderedAdd ι] [inst_5 : SetLike σ A] [inst_6 : AddSubmonoidClass σ A]
(𝒜 : ι → σ) [inst_7 : GradedRing 𝒜], Function.Surjective ⇑(GradedRing.projZeroRingHom' 𝒜) |
factorPowSucc.isUnit_of_isUnit_image | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {R : Type u_3} [inst : CommRing R] {I : Ideal R} {n : ℕ},
n > 0 → ∀ {a : R ⧸ I ^ (n + 1)}, IsUnit ((Ideal.Quotient.factorPow I ⋯) a) → IsUnit a |
Filter.tendstoIxxClass_principal | Mathlib.Order.Filter.Interval | ∀ {α : Type u_1} {s t : Set α} {Ixx : α → α → Set α},
Filter.TendstoIxxClass Ixx (Filter.principal s) (Filter.principal t) ↔ ∀ x ∈ s, ∀ y ∈ s, Ixx x y ⊆ t |
optParam | Init.Prelude | (α : Sort u) → α → Sort u |
Std.Slice.Internal.SubarrayData.stop_le_array_size | Init.Data.Array.Subarray | ∀ {α : Type u} (self : Std.Slice.Internal.SubarrayData α), self.stop ≤ self.array.size |
CategoryTheory.GrothendieckTopology.W_eq_inverseImage_isomorphisms | Mathlib.CategoryTheory.Sites.Localization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_2) [inst_1 : CategoryTheory.Category.{v_2, u_2} A] [inst_2 : CategoryTheory.HasWeakSheafify J A],
J.W =
(CategoryTheory.MorphismProperty.isomorphisms (CategoryTheory.Sheaf J A)).inverseImage
(CategoryTheory.presheafToSheaf J A) |
OrthogonalIdempotents.mul_sum_of_mem | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} [inst : Semiring R] {I : Type u_3} {e : I → R},
OrthogonalIdempotents e → ∀ {i : I} {s : Finset I}, i ∈ s → e i * ∑ j ∈ s, e j = e i |
CategoryTheory.Enriched.HasConicalLimitsOfSize.hasConicalLimitsOfShape._autoParam | Mathlib.CategoryTheory.Enriched.Limits.HasConicalLimits | Lean.Syntax |
Mathlib.Tactic.BicategoryLike.NormalExpr.nodesAux | Mathlib.Tactic.Widget.StringDiagram | {ρ : Type} →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
ℕ →
Mathlib.Tactic.BicategoryLike.NormalExpr →
Mathlib.Tactic.BicategoryLike.CoherenceM ρ (List (List Mathlib.Tactic.Widget.StringDiagram.Node)) |
Mathlib.Tactic.GCongr.GCongrKey.recOn | Mathlib.Tactic.GCongr.Core | {motive : Mathlib.Tactic.GCongr.GCongrKey → Sort u} →
(t : Mathlib.Tactic.GCongr.GCongrKey) →
((relName head : Lean.Name) → (arity : ℕ) → motive { relName := relName, head := head, arity := arity }) → motive t |
_private.Lean.Meta.RecursorInfo.0.Lean.Meta.getNumParams | Lean.Meta.RecursorInfo | Array Lean.Expr → Lean.Expr → ℕ → ℕ |
CategoryTheory.Arrow.equivSigma | Mathlib.CategoryTheory.Comma.Arrow | (T : Type u) → [inst : CategoryTheory.Category.{v, u} T] → CategoryTheory.Arrow T ≃ (X : T) × (Y : T) × (X ⟶ Y) |
AlgebraNorm.mk.inj | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_1} {inst : SeminormedCommRing R} {S : Type u_2} {inst_1 : Ring S} {inst_2 : Algebra R S}
{toRingNorm : RingNorm S} {smul' : ∀ (a : R) (x : S), toRingNorm.toFun (a • x) = ‖a‖ * toRingNorm.toFun x}
{toRingNorm_1 : RingNorm S} {smul'_1 : ∀ (a : R) (x : S), toRingNorm_1.toFun (a • x) = ‖a‖ * toRingNorm_1.toFun x},
{ toRingNorm := toRingNorm, smul' := smul' } = { toRingNorm := toRingNorm_1, smul' := smul'_1 } →
toRingNorm = toRingNorm_1 |
ContinuousAlternatingMap.curryLeft_add | Mathlib.Analysis.Normed.Module.Alternating.Curry | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ}
(f g : E [⋀^Fin (n + 1)]→L[𝕜] F), (f + g).curryLeft = f.curryLeft + g.curryLeft |
cantorToTernary | Mathlib.Topology.Instances.CantorSet | ℝ → Stream' (Fin 3) |
Vector.extract_eq_pop | Init.Data.Vector.Extract | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {stop : ℕ} (h : stop = n - 1), xs.extract 0 stop = Vector.cast ⋯ xs.pop |
TensorPower.gmonoid._proof_2 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (n : ℕ)
(a : GradedMonoid fun i => TensorPower R i M),
GradedMonoid.mk (n.succ • a.fst) (GradedMonoid.GMonoid.gnpowRec n.succ a.snd) =
⟨n • a.fst, GradedMonoid.GMonoid.gnpowRec n a.snd⟩ * a |
_private.Lean.Elab.App.0.Lean.Elab.Term.mergeFailures.match_1 | Lean.Elab.App | (motive : Lean.Elab.Term.TermElabResult Lean.Expr → Sort u_1) →
(x : Lean.Elab.Term.TermElabResult Lean.Expr) →
((ex : Lean.Exception) → (a : Lean.Elab.Term.SavedState) → motive (EStateM.Result.error ex a)) →
((x : Lean.Elab.Term.TermElabResult Lean.Expr) → motive x) → motive x |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.h | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof |
TensorProduct.tmul_neg | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} {P : Type u_4} [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup P] [inst_3 : Module R M] [inst_4 : Module R P] (m : M) (p : P), m ⊗ₜ[R] (-p) = -m ⊗ₜ[R] p |
Stream'.WSeq.seq_destruct_think | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (s : Stream'.WSeq α), Stream'.Seq.destruct s.think = some (none, s) |
Polynomial.trinomial | Mathlib.Algebra.Polynomial.UnitTrinomial | {R : Type u_1} → [inst : Semiring R] → ℕ → ℕ → ℕ → R → R → R → Polynomial R |
MeasureTheory.setLAverage_congr_fun | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {f g : α → ENNReal},
MeasurableSet s → Set.EqOn f g s → ⨍⁻ (x : α) in s, f x ∂μ = ⨍⁻ (x : α) in s, g x ∂μ |
TopCat.instCategory._proof_2 | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat} (f : X.Hom Y), { hom' := { hom' := ContinuousMap.id ↑Y }.hom'.comp f.hom' } = f |
List.sym2_eq_nil_iff | Mathlib.Data.List.Sym | ∀ {α : Type u_1} {xs : List α}, xs.sym2 = [] ↔ xs = [] |
Fix.mk._flat_ctor | Mathlib.Control.Fix | {α : Type u_3} → ((α → α) → α) → Fix α |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.diff.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β),
m₁.diff m₂ =
if (↑m₁).size ≤ (↑m₂).size then Std.DHashMap.Internal.Raw₀.filter (fun k x => !m₂.contains k) m₁
else ↑(m₁.eraseManyEntries ↑m₂) |
Primrec.list_head? | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec List.head? |
Std.TreeMap.getElem!_modify_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β] {f : β → β}, (t.modify k f)[k]! = (Option.map f t[k]?).get! |
Polynomial.le_trailingDegree_C | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} {a : R} [inst : Semiring R], 0 ≤ (Polynomial.C a).trailingDegree |
RootPairing.finrank_rootSpan_map_polarization_eq_finrank_corootSpan | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : CommRing R] [IsDomain R] [inst_5 : Module R M] [inst_6 : Module R N]
(P : RootPairing ι R M N) [P.IsAnisotropic],
Module.finrank R ↥(Submodule.map P.Polarization (P.rootSpan R)) = Module.finrank R ↥(P.corootSpan R) |
Nat.forM | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → m Unit |
IsPGroup.of_surjective | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G],
IsPGroup p G → ∀ {H : Type u_2} [inst_1 : Group H] (ϕ : G →* H), Function.Surjective ⇑ϕ → IsPGroup p H |
Std.TreeMap.forIn_eq_forIn_keys | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {δ : Type w} {m : Type w → Type w'}
[inst : Monad m] [LawfulMonad m] {f : α → δ → m (ForInStep δ)} {init : δ},
(forIn t init fun a d => f a.1 d) = forIn t.keys init f |
Asymptotics.isTheta_const_const_iff | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {E'' : Type u_9} {F'' : Type u_10} [inst : NormedAddCommGroup E''] [inst_1 : NormedAddCommGroup F'']
{l : Filter α} [l.NeBot] {c₁ : E''} {c₂ : F''}, ((fun x => c₁) =Θ[l] fun x => c₂) ↔ (c₁ = 0 ↔ c₂ = 0) |
Vector.mem_attach | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n) (x : { x // x ∈ xs }), x ∈ xs.attach |
Lean.Elab.Tactic.iterateExactly' | Mathlib.Tactic.Core | {m : Type → Type u} → [Monad m] → ℕ → m Unit → m Unit |
BoundedLatticeHom.dual._proof_2 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : BoundedOrder α] [inst_2 : Lattice β]
[inst_3 : BoundedOrder β],
Function.RightInverse (fun f => { toLatticeHom := LatticeHom.dual.symm f.toLatticeHom, map_top' := ⋯, map_bot' := ⋯ })
fun f => { toLatticeHom := LatticeHom.dual f.toLatticeHom, map_top' := ⋯, map_bot' := ⋯ } |
Std.DTreeMap.head?_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] [inst : Min α]
[inst_1 : LE α] [Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α]
[Std.LawfulEqCmp cmp], t.keys.head? = t.minKey? |
Set.encard_pos | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, 0 < s.encard ↔ s.Nonempty |
_private.Mathlib.Geometry.Convex.Cone.Basic.0.ConvexCone.Flat.mono.match_1_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_1} {G : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup G]
[inst_3 : SMul R G] {C₁ : ConvexCone R G} (motive : C₁.Flat → Prop) (x : C₁.Flat),
(∀ (x : G) (hxS : x ∈ C₁) (hx : x ≠ 0) (hnxS : -x ∈ C₁), motive ⋯) → motive x |
Lean.Grind.Linarith.eq_eq_subst | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} [inst : Lean.Grind.IntModule α] (ctx : Lean.Grind.Linarith.Context α) (x : Lean.Grind.Linarith.Var)
(p₁ p₂ p₃ : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.eq_eq_subst_cert x p₁ p₂ p₃ = true →
Lean.Grind.Linarith.Poly.denote' ctx p₁ = 0 →
Lean.Grind.Linarith.Poly.denote' ctx p₂ = 0 → Lean.Grind.Linarith.Poly.denote' ctx p₃ = 0 |
CategoryTheory.ShortComplex.exact_iff_isZero_leftHomology | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology], S.Exact ↔ CategoryTheory.Limits.IsZero S.leftHomology |
FormalMultilinearSeries.unshift_shift | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} {F : Type w} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E (E →L[𝕜] F)} {z : F}, (p.unshift z).shift = p |
CategoryTheory.WithInitial.Hom.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.WithInitial C),
CategoryTheory.WithInitial.star.Hom x = PUnit.{v + 1} |
OreLocalization.instMul | Mathlib.GroupTheory.OreLocalization.Basic | {R : Type u_1} → [inst : Monoid R] → {S : Submonoid R} → [inst_1 : OreLocalization.OreSet S] → Mul (OreLocalization S R) |
Batteries.RBSet.mergeWith.match_1 | Batteries.Data.RBMap.Basic | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((a₁ : α) → motive (some a₁)) → (Unit → motive none) → motive x |
Multiset.toList_eq_nil | Mathlib.Data.Multiset.Basic | ∀ {α : Type u_1} {s : Multiset α}, s.toList = [] ↔ s = 0 |
CategoryTheory.unmopFunctor._proof_1 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] (X : Cᴹᵒᵖ),
(fun {X Y} => Quiver.Hom.unmop) (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id X.unmop |
CategoryTheory.ShortComplex.gFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C), CategoryTheory.ShortComplex.gFunctor.obj S = CategoryTheory.Arrow.mk S.g |
TopCat.piFanIsLimit._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ {ι : Type u_2} (α : ι → TopCat) (S : CategoryTheory.Limits.Cone (CategoryTheory.Discrete.functor α)),
Continuous fun s i => (CategoryTheory.ConcreteCategory.hom (S.π.app { as := i })) s |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_15 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (lhs rhs : Std.Sat.AIG.Fanin), lhs.gate < upper ∧ rhs.gate < upper → lhs.gate < aig.decls.size |
_private.Mathlib.Topology.Maps.Basic.0.Topology.IsInducing.dense_iff._simp_1_1 | Mathlib.Topology.Maps.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) |
Bipointed.Hom.mk.noConfusion | Mathlib.CategoryTheory.Category.Bipointed | {X Y : Bipointed} →
{P : Sort u_1} →
{toFun : X.X → Y.X} →
{map_fst : toFun X.toProd.1 = Y.toProd.1} →
{map_snd : toFun X.toProd.2 = Y.toProd.2} →
{toFun' : X.X → Y.X} →
{map_fst' : toFun' X.toProd.1 = Y.toProd.1} →
{map_snd' : toFun' X.toProd.2 = Y.toProd.2} →
{ toFun := toFun, map_fst := map_fst, map_snd := map_snd } =
{ toFun := toFun', map_fst := map_fst', map_snd := map_snd' } →
(toFun ≍ toFun' → P) → P |
CommAlgCat.instMonoidalCategory._proof_20 | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] (X Y : CommAlgCat R),
CategoryTheory.CategoryStruct.comp
(CommAlgCat.isoMk (Algebra.TensorProduct.assoc R R R ↑X ↑(CommAlgCat.of R R) ↑Y)).hom
(CommAlgCat.ofHom
(Algebra.TensorProduct.map (AlgHom.id R ↑X)
(CommAlgCat.Hom.hom (CommAlgCat.isoMk (Algebra.TensorProduct.lid R ↑Y)).hom))) =
CommAlgCat.ofHom
(Algebra.TensorProduct.map (CommAlgCat.Hom.hom (CommAlgCat.isoMk (Algebra.TensorProduct.rid R R ↑X)).hom)
(AlgHom.id R ↑Y)) |
cfcₙHomSuperset_apply | 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] {a : A} (ha : p a)
{s : Set R} (hs : quasispectrum R a ⊆ s) (a_1 : ContinuousMapZero (↑s) R),
(cfcₙHomSuperset ha hs) a_1 =
(cfcₙHom ha) (a_1.comp { toFun := Subtype.map id hs, continuous_toFun := ⋯, map_zero' := ⋯ }) |
conjneg_one | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R], conjneg 1 = 1 |
CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.isIso_hom | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} {E : L.LeftExtension F}
(h : E.IsPointwiseLeftKanExtension) [L.Full] [L.Faithful], CategoryTheory.IsIso E.hom |
CategoryTheory.Functor.CoconeTypes.IsColimitCore.fac_apply | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimitCore) (c' : F.CoconeTypes) (j : J) (x : F.obj j), hc.desc c' (c.ι j x) = c'.ι j x |
VAddCommClass.op_left | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_5} [inst : VAdd M α] [inst_1 : VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α]
[inst_3 : VAdd N α] [VAddCommClass M N α], VAddCommClass Mᵃᵒᵖ N α |
Std.TreeSet.mk._flat_ctor | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : autoParam (α → α → Ordering) Std.TreeSet._auto_1} → Std.TreeMap α Unit cmp → Std.TreeSet α cmp |
CategoryTheory.Functor.PreOneHypercoverDenseData._sizeOf_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
{inst : CategoryTheory.Category.{v₀, u₀} C₀} →
{inst_1 : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C₀ C} → {S : C} → [SizeOf C₀] → [SizeOf C] → F.PreOneHypercoverDenseData S → ℕ |
USize.decEq | Init.Prelude | (a b : USize) → Decidable (a = b) |
ContDiffMapSupportedIn.topologicalSpace._proof_4 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (i : ℕ), IsBoundedSMul ℝ (ContinuousMultilinearMap ℝ (fun i => E) F) |
MonoidHom.cancel_right | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : MulOne M] [inst_1 : MulOne N] [inst_2 : MulOne P]
{g₁ g₂ : N →* P} {f : M →* N}, Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) |
Subfield.relfinrank_eq_of_inf_eq | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {A B C : Subfield E}, A ⊓ C = B ⊓ C → A.relfinrank C = B.relfinrank C |
AlgCat.adj._proof_7 | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (R : Type u_1) [inst : CommRing R] {X : Type u_1} {Y Y' : AlgCat R} (f : (AlgCat.free R).obj X ⟶ Y) (g : Y ⟶ Y'),
{ toFun := fun f => (FreeAlgebra.lift R).symm (AlgCat.Hom.hom f),
invFun := fun f => AlgCat.ofHom ((FreeAlgebra.lift R) f), left_inv := ⋯, right_inv := ⋯ }
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
({ toFun := fun f => (FreeAlgebra.lift R).symm (AlgCat.Hom.hom f),
invFun := fun f => AlgCat.ofHom ((FreeAlgebra.lift R) f), left_inv := ⋯, right_inv := ⋯ }
f)
((CategoryTheory.forget (AlgCat R)).map g) |
_private.Mathlib.Order.Interval.Set.Fin.0.Fin.preimage_rev_Ioc._simp_1_3 | Mathlib.Order.Interval.Set.Fin | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) |
Std.Iterators.Types.Flatten.it₂ | Init.Data.Iterators.Combinators.Monadic.FlatMap | {α α₂ β : Type w} → {m : Type w → Type u_1} → Std.Iterators.Types.Flatten α α₂ β m → Option (Std.IterM m β) |
Std.Internal.List.isEmpty_replaceEntry | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {k : α} {v : β k},
(Std.Internal.List.replaceEntry k v l).isEmpty = l.isEmpty |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocContext.closeAll | Lean.DocString.Extension | Lean.VersoModuleDocs.DocContext✝ → Except String Lean.VersoModuleDocs.DocContext✝¹ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.