name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
finTrdeg_iff_trdeg | Mathlib.FieldTheory.FinTrdeg | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L],
FinTrdeg K L ↔ Algebra.trdeg K L < Cardinal.aleph0 | null | true |
Std.TreeMap.Raw.maxKey?_le | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {k : α},
t.WF → ((∀ (k' : α), t.maxKey? = some k' → (cmp k' k).isLE = true) ↔ ∀ k' ∈ t, (cmp k' k).isLE = true) | null | true |
FirstOrder.Language.BoundedFormula.IsUniversal.below | Mathlib.ModelTheory.Complexity | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : {n : ℕ} → (a : L.BoundedFormula α n) → a.IsUniversal → Prop} →
{n : ℕ} → {a : L.BoundedFormula α n} → a.IsUniversal → Prop | null | true |
PrimeSpectrum.localization_comap_isInducing | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} (S : Type v) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (M : Submonoid R)
[IsLocalization M S], Topology.IsInducing (PrimeSpectrum.comap (algebraMap R S)) | null | true |
Multiset.sections_cons | Mathlib.Data.Multiset.Sections | ∀ {α : Type u_1} (s : Multiset (Multiset α)) (m : Multiset α),
(m ::ₘ s).Sections = m.bind fun a => Multiset.map (Multiset.cons a) s.Sections | null | true |
Equiv.Perm.viaEmbeddingHom | Mathlib.GroupTheory.Perm.ViaEmbedding | {α : Type u_1} → {β : Type u_2} → (α ↪ β) → Equiv.Perm α →* Equiv.Perm β | `viaEmbedding` as a group homomorphism | true |
MeasureTheory.integrable_of_forall_fin_meas_le' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {ε : Type u_7} [inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε]
{μ : MeasureTheory.Measure α} (hm : m ≤ m0) [MeasureTheory.SigmaFinite (μ.trim hm)],
∀ C < ⊤,
∀ {f : α → ε},
MeasureTheory.AEStronglyMeasurable f μ →
(∀ (s : Set α), MeasurableSet s ... | null | true |
Function.const_zero | Mathlib.Algebra.Notation.Pi.Defs | ∀ {α : Type u_2} {M : Type u_7} [inst : Zero M], Function.const α 0 = 0 | null | true |
ENNReal.rpow_mul_natCast | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ (x : ENNReal) (y : ℝ) (n : ℕ), x ^ (y * ↑n) = (x ^ y) ^ n | null | true |
MeasureTheory.VectorMeasure.instZero._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_2} [inst : AddCommMonoid M] (x : Set α),
¬MeasurableSet x → 0 x = 0 x | null | false |
CondensedMod.LocallyConstant.functorIsoDiscreteAux₁ | Mathlib.Condensed.Discrete.Module | (R : Type (u + 1)) → [inst : Ring R] → (M : ModuleCat R) → M ≅ ↧(LocallyConstant ↑(↧PUnit.{u + 1}).toTop ↑M) | Auxiliary definition for `functorIsoDiscrete`. | true |
CategoryTheory.nerveAdjunction.isIso_counit | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | CategoryTheory.IsIso CategoryTheory.nerveAdjunction.counit | null | true |
Lean.AttributeExtensionState._sizeOf_inst | Lean.Attributes | SizeOf Lean.AttributeExtensionState | null | false |
Std.HashMap.Raw.modify.congr_simp | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : EquivBEq α] [inst_2 : Hashable α] (m m_1 : Std.HashMap.Raw α β),
m = m_1 → ∀ (a a_1 : α), a = a_1 → ∀ (f f_1 : β → β), f = f_1 → m.modify a f = m_1.modify a_1 f_1 | null | true |
CategoryTheory.Functor.prod'_μ_fst | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E]
... | null | true |
Substring.Raw.ValidFor.drop | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {s : Substring.Raw},
Substring.Raw.ValidFor l m r s → ∀ (n : ℕ), Substring.Raw.ValidFor (l ++ List.take n m) (List.drop n m) r (s.drop n) | null | true |
Std.Sat.AIG._sizeOf_inst | Std.Sat.AIG.Basic | (α : Type) → {inst : DecidableEq α} → {inst_1 : Hashable α} → [SizeOf α] → SizeOf (Std.Sat.AIG α) | null | false |
instWellFoundedLTShrink | Mathlib.Order.Shrink | ∀ {α : Type u_1} [inst : Small.{u, u_1} α] [inst_1 : Preorder α] [WellFoundedLT α], WellFoundedLT (Shrink.{u, u_1} α) | null | true |
Subfield.relfinrank | Mathlib.FieldTheory.Relrank | {E : Type v} → [inst : Field E] → Subfield E → Subfield E → ℕ | The `Nat` version of `Subfield.relrank`.
If `B / A ⊓ B` is an infinite extension, then it is zero. | true |
_private.Mathlib.Algebra.Group.Basic.0.neg_nsmul.match_1_1 | Mathlib.Algebra.Group.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
AddCon.addGroup._proof_5 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : AddGroup M] (c : AddCon M) (a : c.Quotient), -a + a = 0 | null | false |
slope_pos_iff_gt | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {𝕜 : Type u_3} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {f : 𝕜 → 𝕜} {x₀ b : 𝕜},
b < x₀ → (0 < slope f x₀ b ↔ f b < f x₀) | null | true |
_private.Lean.Server.References.0.Lean.Server.References.definitionsMatching.match_1 | Lean.Server.References | (motive : Option IO.CancelToken → Sort u_1) →
(cancelTk? : Option IO.CancelToken) →
((cancelTk : IO.CancelToken) → motive (some cancelTk)) → ((x : Option IO.CancelToken) → motive x) → motive cancelTk? | null | false |
Int16.toNatClampNeg_toInt64 | Init.Data.SInt.Lemmas | ∀ (x : Int16), x.toInt64.toNatClampNeg = x.toNatClampNeg | null | true |
Lean.Server.FileWorker.RpcSession.recOn | Lean.Server.FileWorker.Utils | {motive : Lean.Server.FileWorker.RpcSession → Sort u} →
(t : Lean.Server.FileWorker.RpcSession) →
((objects : Lean.Server.RpcObjectStore) →
(expireTime : ℕ) → motive { objects := objects, expireTime := expireTime }) →
motive t | null | false |
_private.Init.Data.Int.Gcd.0.Int.lcm_eq_one_iff._simp_1_3 | Init.Data.Int.Gcd | ∀ {a b : ℤ}, (a ∣ b) = (a.natAbs ∣ b.natAbs) | null | false |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_of_span_eq_top._simp_1_2 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (g : M)
(r : R), (r ∈ (R ∙ g).annihilator) = (r • g = 0) | null | false |
Euclidean.ball_subset_closedBall | Mathlib.Analysis.InnerProductSpace.EuclideanDist | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : TopologicalSpace E] [inst_2 : IsTopologicalAddGroup E]
[inst_3 : T2Space E] [inst_4 : Module ℝ E] [inst_5 : ContinuousSMul ℝ E] [inst_6 : FiniteDimensional ℝ E] {x : E}
{r : ℝ}, Euclidean.ball x r ⊆ Euclidean.closedBall x r | null | true |
unitsCentralizerEquiv._proof_11 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ (M : Type u_1) [inst : Monoid M] (x : Mˣ) (x_1 y : ↥(MulAction.stabilizer (ConjAct Mˣ) x)),
{ toFun := fun u => ⟨↑(ConjAct.ofConjAct ↑u), ⋯⟩, map_one' := ⋯, map_mul' := ⋯ }.toHomUnits (x_1 * y) =
{ toFun := fun u => ⟨↑(ConjAct.ofConjAct ↑u), ⋯⟩, map_one' := ⋯, map_mul' := ⋯ }.toHomUnits x_1 *
{ toFun := f... | null | false |
NonUnitalStarSubalgebra.coe_eq_zero | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : Star A] (S : NonUnitalStarSubalgebra R A) {x : ↥S}, ↑x = 0 ↔ x = 0 | null | true |
Rat.mul_assoc | Init.Data.Rat.Lemmas | ∀ (a b c : ℚ), a * b * c = a * (b * c) | null | true |
Int.Internal.Linear.Poly.ctorIdx | Init.Data.Int.Linear | Int.Internal.Linear.Poly → ℕ | null | false |
CategoryTheory.ProfCat.coe_of | Mathlib.CategoryTheory.Profunctor.Bicategory | ∀ (C : CategoryTheory.ProfCat), { obj := C.obj, str := C.str } = C | null | true |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.isEqnThmHypothesis.go._unsafe_rec | Lean.Meta.Tactic.Simp.Rewrite | Lean.Expr → Bool | null | false |
CategoryTheory.Functor.limitIsoOfIsRightKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Basic | {C : Type u_1} →
{H : Type u_3} →
{D : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] →
[inst_2 : CategoryTheory.Category.{v_5, u_5} D] →
(F' : CategoryTheory.Functor D H) →
{L : CategoryTheory.Functor C... | If `F' : D ⥤ H` is a right Kan extension of `F : C ⥤ H` along `L : C ⥤ D`, the limit over `F'`
is isomorphic to the limit over `F`. | true |
IsUltrametricDist.nnnorm_tsum_le | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_1} {ι : Type u_2} [inst : SeminormedAddCommGroup M] [IsUltrametricDist M] (f : ι → M),
‖∑' (i : ι), f i‖₊ ≤ ⨆ i, ‖f i‖₊ | null | true |
_private.Mathlib.NumberTheory.Height.NumberField.0.NumberField.finite_setOfPred_mulHeight₁_le._proof_1_4 | Mathlib.NumberTheory.Height.NumberField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B : ℝ) (x : K) (n : ℕ),
n ≠ 0 → ↑n ≤ Height.mulHeight₁ x → Height.mulHeight₁ x ≤ B → n - 1 < ⌊B⌋₊ | null | false |
IntermediateField.algebraicIndependent_adjoin_iff | Mathlib.RingTheory.AlgebraicIndependent.AlgebraicClosure | ∀ {ι : Type u_1} {F : Type u_2} {E : Type u_3} {S : Type u_5} {s : Set E} [inst : Field F] [inst_1 : Field E]
[inst_2 : Algebra F E] [inst_3 : CommRing S] [inst_4 : Algebra E S] {x : ι → S},
AlgebraicIndependent (↥(IntermediateField.adjoin F s)) x ↔ AlgebraicIndependent (↥(Algebra.adjoin F s)) x | null | true |
_private.Lean.Meta.Tactic.Assert.0.Lean.MVarId.assertAfter'.findMaxFVar._sparseCasesOn_4 | Lean.Meta.Tactic.Assert | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CauSeq.instMaxAbs.match_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] (f g : CauSeq α abs) (x : α)
(x_1 : ℕ) (motive : ((∀ k ≥ x_1, |↑f k - ↑f x_1| < x) ∧ ∀ k ≥ x_1, |↑g k - ↑g x_1| < x) → Prop)
(x_2 : (∀ k ≥ x_1, |↑f k - ↑f x_1| < x) ∧ ∀ k ≥ x_1, |↑g k - ↑g x_1| < x),
(∀ (H₁ : ∀ k ≥ x_1, |↑... | null | false |
MonoidHom.mem_mgraph._simp_2 | Mathlib.Algebra.Group.Graph | ∀ {G : Type u_1} {H : Type u_2} [inst : Monoid G] [inst_1 : Monoid H] {f : G →* H} {x : G × H},
(x ∈ f.mgraph) = (f x.1 = x.2) | null | false |
Nat.add_modEq_right_iff | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, a + b ≡ b [MOD n] ↔ n ∣ a | null | true |
CategoryTheory.DifferentialObject.mk.noConfusion | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
{inst : AddMonoidWithOne S} →
{C : Type u} →
{inst_1 : CategoryTheory.Category.{v, u} C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} →
{inst_3 : CategoryTheory.HasShift C S} →
{P : Sort u_2} →
{obj : C} →
{d : obj ⟶ (Cate... | null | false |
Valuation.mk.sizeOf_spec | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : LinearOrderedCommMonoidWithZero Γ₀] [inst_1 : Ring R] [inst_2 : SizeOf R]
[inst_3 : SizeOf Γ₀] (toMonoidWithZeroHom : R →*₀ Γ₀)
(map_add_le_max' :
∀ (x y : R),
(↑toMonoidWithZeroHom).toFun (x + y) ≤ max ((↑toMonoidWithZeroHom).toFun x) ((↑toMonoidWithZeroHom).toFun... | null | true |
AlgebraicGeometry.Scheme.AffineZariskiSite.toOpens | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | {X : AlgebraicGeometry.Scheme} → X.AffineZariskiSite → X.Opens | The inclusion from `X.AffineZariskiSite` to `X.Opens`. | true |
Representation.IntertwiningMap.centralAlgebraMulHom | Mathlib.RepresentationTheory.Intertwining | {A : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
[inst : CommSemiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid V] →
[inst_3 : Module A V] →
(ρ : Representation A G V) → ↥(Submonoid.center (MonoidAlgebra A G)) →* ρ.IntertwiningMap ρ | `centralAlgebraMul` as monoid homomorphism from the center of `A[G]` to intertwining map
from any representation of `G` to itself. | true |
CategoryTheory.Grp.forget₂Mon | Mathlib.CategoryTheory.Monoidal.Grp | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
CategoryTheory.Functor (CategoryTheory.Grp C) (CategoryTheory.Mon C) | The forgetful functor from group objects to monoid objects. | true |
Set.sub_subset_sub | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Sub α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ⊆ t₁ → s₂ ⊆ t₂ → s₁ - s₂ ⊆ t₁ - t₂ | null | true |
Order.Icc_pred_right | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a b : α),
Set.Icc b (Order.pred a) = Set.Ico b a | null | true |
Lean.Elab.Tactic.Location.ctorIdx | Lean.Elab.Tactic.Location | Lean.Elab.Tactic.Location → ℕ | null | false |
MvPolynomial.pUnitAlgEquiv | Mathlib.Algebra.MvPolynomial.Equiv | (R : Type u) → [inst : CommSemiring R] → MvPolynomial PUnit.{u_2 + 1} R ≃ₐ[R] Polynomial R | The algebra isomorphism between multivariable polynomials in a single variable and
polynomials over the ground ring. | true |
Std.ExtHashMap.getKey?_eq_some_getKeyD_of_contains | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a fallback : α}, m.contains a = true → m.getKey? a = some (m.getKeyD a fallback) | null | true |
CondensedSet.toTopCat | Mathlib.Condensed.TopCatAdjunction | CondensedSet → TopCat | The object part of the functor `CondensedSet ⥤ TopCat` | true |
_private.Mathlib.LinearAlgebra.Matrix.ToLin.0.isStablyFiniteRing_iff_injective_of_surjective.match_1_3 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {A : Type u_1} [inst : Semiring A] (n : ℕ) (f : Module.End A (Fin n → A))
(motive : (∃ h, f ∘ₗ h = LinearMap.id) → Prop) (x : ∃ h, f ∘ₗ h = LinearMap.id),
(∀ (g : (Fin n → A) →ₗ[A] Fin n → A) (eq : f ∘ₗ g = LinearMap.id), motive ⋯) → motive x | null | false |
Std.Sat.CNF.biEntails_def | Std.Sat.CNF.Entails | ∀ {α : Type u_1} {f1 f2 : Std.Sat.CNF α}, f1.BiEntails f2 ↔ f1.Entails f2 ∧ f2.Entails f1 | null | true |
Std.Time.Internal.Bounded.LE.truncate._proof_2 | Std.Time.Internal.Bounded | ∀ {n m : ℤ} (bounded : Std.Time.Internal.Bounded.LE n m),
n ≤ ↑bounded → ↑bounded ≤ m → 0 ≤ ↑bounded - n ∧ ↑bounded - n ≤ m - n | null | false |
CategoryTheory.NatIso.cancel_natIso_hom_right_assoc | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (α : F ≅ G) {W X X' : D} {Y : C} (f : W ⟶ X) (g : X ⟶ F.obj Y) (f' : W ⟶ X')
(g' : X' ⟶ F.obj Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Category... | null | true |
_private.Mathlib.Analysis.Normed.Operator.NormedSpace.0.LinearMap.antilipschitz_of_comap_nhds_le._simp_1_3 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {F : Type u_8} {G₀ : Type u_9} {G₀' : Type u_10} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
[inst_2 : FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (x : G₀) (n : ℤ), f x ^ n = f (x ^ n) | null | false |
Std.DHashMap.Raw.Const.get_filter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Bool} {k : α} {h' : k ∈ Std.DHashMap.Raw.filter f m}
(h : m.WF), Std.DHashMap.Raw.Const.get (Std.DHashMap.Raw.filter f m) k h' = Std.DHashMap.Raw.Const.... | null | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow_add_eq._simp_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ (w : ℕ), (0 < 2 ^ w) = True | null | false |
Std.DTreeMap.Raw.getD_alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k k' : α} {fallback : β k'} {f : Option (β k) → Option (β k)},
(t.alter k f).getD k' fallback =
if heq : cmp k k' = Ordering.eq then (Option.map (cast ... | null | true |
_private.Init.Data.Int.LemmasAux.0.Int.mul_le_mul_of_natAbs_le._proof_1_7 | Init.Data.Int.LemmasAux | ∀ {x : ℤ} {y : ℤ} {s t : ℕ}, 0 < x → ¬0 ≤ x → False | null | false |
CategoryTheory.monadicOfReflective._proof_1 | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] {R : CategoryTheory.Functor D C}
[inst_2 : CategoryTheory.Reflective R],
(CategoryTheory.Monad.comparison (CategoryTheory.reflectorAdjunction R)).Faithful | null | false |
Subsemigroup.mem_unitBall._simp_1 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ (𝕜 : Type u_2) [inst : NonUnitalSeminormedRing 𝕜] {x : 𝕜}, (x ∈ Subsemigroup.unitBall 𝕜) = (‖x‖ < 1) | null | false |
CoeOut.casesOn | Init.Coe | {α : Sort u} →
{β : Sort v} →
{motive : CoeOut α β → Sort u_1} → (t : CoeOut α β) → ((coe : α → β) → motive { coe := coe }) → motive t | null | false |
compactlyGeneratedSpace_of_isOpen_of_t2 | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {X : Type u} [inst : TopologicalSpace X] [T2Space X],
(∀ (s : Set X), (∀ (K : Set X), IsCompact K → IsOpen (Subtype.val ⁻¹' s)) → IsOpen s) → CompactlyGeneratedSpace X | Let `s ⊆ X`. Suppose that `X` is Hausdorff, and that to prove that `s` is open,
it suffices to show that for every compact set `K ⊆ X`, `s ∩ K` is open in `K`.
Then `X` is compactly generated. | true |
_private.Lean.Meta.Sym.Apply.0.Lean.Meta.Sym.mkResultPos._sparseCasesOn_4 | Lean.Meta.Sym.Apply | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
DirectSum.GNonUnitalNonAssocSemiring.noConfusionType | Mathlib.Algebra.DirectSum.Ring | Sort u →
{ι : Type u_1} →
{A : ι → Type u_2} →
[inst : Add ι] →
[inst_1 : (i : ι) → AddCommMonoid (A i)] →
DirectSum.GNonUnitalNonAssocSemiring A →
{ι' : Type u_1} →
{A' : ι' → Type u_2} →
[inst' : Add ι'] →
[inst'_1 : (i : ι') → ... | null | false |
_private.Init.Data.String.Extra.0.String.removeNumLeadingSpaces.consumeSpaces._mutual._proof_5 | Init.Data.String.Extra | ∀ (n : ℕ) {s : String} (it : s.Pos) (r : String) (h : ¬it.IsAtEnd),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun n it => PSigma.casesOn it fun it r => (it, 1)) fun _x =>
PSigma.casesOn _x fun it r => (it, 0))
Prod.instWellFoundedRelation).1
(PSum.inl ⟨n... | null | false |
UpperHalfPlane.ρ._proof_2 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | (1 + 1).AtLeastTwo | null | false |
Nat.count_one | Mathlib.Data.Nat.Count | ∀ (p : ℕ → Prop) [inst : DecidablePred p], Nat.count p 1 = if p 0 then 1 else 0 | null | true |
_private.Lean.Meta.CoeAttr.0.Lean.Meta.initFn._@.Lean.Meta.CoeAttr.477343235._hygCtx._hyg.2 | Lean.Meta.CoeAttr | IO (Lean.SimpleScopedEnvExtension (Lean.Name × Lean.Meta.CoeFnInfo) (Lean.NameMap Lean.Meta.CoeFnInfo)) | null | false |
AddAction.BlockMem.instNontrivial | Mathlib.GroupTheory.GroupAction.Blocks | ∀ (G : Type u_1) [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] [Nontrivial X] (a : X),
Nontrivial (AddAction.BlockMem G a) | null | true |
CategoryTheory.Limits.preservesBiproduct_of_epi_biproductComparison' | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] {J : Type u_1} [Finite J] {f : J → C}
[inst_6 : ... | If the (coproduct-like) biproduct comparison for `F` and `f` is an epimorphism, then `F`
preserves the biproduct of `F` and `f`. For the converse, see `mapBiproduct`. | true |
himp_compl | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), a ⇨ aᶜ = aᶜ | null | true |
_private.Lean.ResolveName.0.Lean.resolveLocalName.go | Lean.ResolveName | Lean.LocalDecl → Lean.MacroScopesView → Lean.Name → Lean.Name → Option Lean.LocalDecl | null | true |
IsCoprime.of_isCoprime_of_dvd_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime z y → x ∣ y → IsCoprime z x | null | true |
CategoryTheory.evaluationAdjunctionRight._proof_9 | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) {X : D}
{Y Y' : CategoryTheory.Functor C D} (f : (CategoryTheory.evaluationLeftAdjoint D c).obj X ⟶ Y) ... | null | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_oneMore_iff | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.parseFirstByte b = ByteArray.utf8DecodeChar?.FirstByte.oneMore ↔ b &&& 224 = 192 | null | true |
CategoryTheory.instNonemptyFreeGroupoid | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [Nonempty C], Nonempty (CategoryTheory.FreeGroupoid C) | null | true |
NormedAddGroup.ofSeparation | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_2} → [inst : SeminormedAddGroup E] → (∀ (x : E), ‖x‖ = 0 → x = 0) → NormedAddGroup E | Construct a `NormedAddGroup` from a `SeminormedAddGroup`
satisfying `∀ x, ‖x‖ = 0 → x = 0`. This avoids having to go back to the `(Pseudo)MetricSpace`
level when declaring a `NormedAddGroup` instance as a special case of a more general
`SeminormedAddGroup` instance. | true |
CategoryTheory.ShortComplex.RightHomologyData.ofAbelian_p | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C),
(CategoryTheory.ShortComplex.RightHomologyData.ofAbelian S).p = CategoryTheory.Limits.cokernel.π S.f | null | true |
Std.Time.OffsetX.hourMinuteColon.sizeOf_spec | Std.Time.Format.Modifier | sizeOf Std.Time.OffsetX.hourMinuteColon = 1 | null | true |
Vector.insertIdx_eraseIdx._proof_5 | Init.Data.Vector.InsertIdx | ∀ {n i j : ℕ}, i < n → j ≤ n - 1 → ¬i ≤ j → n + 1 - 1 = n - 1 + 1 | null | false |
Matrix.card_SL | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Card | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] [Nonempty n] {R : Type u_2} [inst_3 : CommRing R]
[Finite Rˣ], Nat.card (Matrix.SpecialLinearGroup n R) = Nat.card (GL n R) / Nat.card Rˣ | The cardinal of the special linear group over a commutative ring with finitely many
units. | true |
TensorProduct.gradedMul_one | Mathlib.LinearAlgebra.TensorProduct.Graded.External | ∀ {R : Type u_1} {ι : Type u_2} [inst : CommSemiring ι] [inst_1 : Module ι (Additive ℤˣ)] [inst_2 : DecidableEq ι]
(𝒜 : ι → Type u_3) (ℬ : ι → Type u_4) [inst_3 : CommRing R] [inst_4 : (i : ι) → AddCommGroup (𝒜 i)]
[inst_5 : (i : ι) → AddCommGroup (ℬ i)] [inst_6 : (i : ι) → Module R (𝒜 i)] [inst_7 : (i : ι) → Mo... | null | true |
CategoryTheory.Functor.relativelyRepresentable.lift_fst_assoc | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X Y : D} {f : X ⟶ Y} (hf : F.relativelyRepresentable f) {a : C} {g : F.obj a ⟶ Y}
{c : C} (i : F.obj c ⟶ X) (h : c ⟶ a)
(hi : CategoryTheory.CategoryStruct.comp... | null | true |
Submodule.instOrderTop | Mathlib.Algebra.Module.Submodule.Lattice | {R : Type u_1} →
{M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → OrderTop (Submodule R M) | null | true |
List.sum_le_length_nsmul | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddRightMono M] [AddLeftMono M] (l : List M) (n : M),
(∀ x ∈ l, x ≤ n) → l.sum ≤ l.length • n | null | true |
_private.Std.Http.Protocol.H1.Parser.0.Std.Http.Protocol.H1.parseChunkPartial.match_1 | Std.Http.Protocol.H1.Parser | (motive : ℕ × Array (Std.Http.Chunk.ExtensionName × Option Std.Http.Chunk.ExtensionValue) → Sort u_1) →
(x : ℕ × Array (Std.Http.Chunk.ExtensionName × Option Std.Http.Chunk.ExtensionValue)) →
((size : ℕ) →
(ext : Array (Std.Http.Chunk.ExtensionName × Option Std.Http.Chunk.ExtensionValue)) → motive (size, ... | null | false |
Std.DHashMap.Raw.Equiv.union_congr | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : α → Type v} {m₁ m₂ m₃ m₄ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₄.WF → m₁.Equiv m₃ → m₂.Equiv m₄ → (m₁ ∪ m₂).Equiv (m₃ ∪ m₄) | null | true |
List.take_succ_eq_append_getElem | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {i : ℕ} {l : List α} (h : i < l.length), List.take (i + 1) l = List.take i l ++ [l[i]] | null | true |
DFinsupp.filter_single_neg | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] {p : ι → Prop}
[inst_2 : DecidablePred p] (i : ι) (x : β i), ¬p i → (DFinsupp.filter p fun₀ | i => x) = 0 | null | true |
_private.Mathlib.NumberTheory.RamificationInertia.Unramified.0.IsUnramifiedAt.of_liesOver_of_ne_bot.match_1_1 | Mathlib.NumberTheory.RamificationInertia.Unramified | ∀ (R : Type u_1) {S : Type u_3} {T : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] (p : Ideal S) (P : Ideal T) [inst_5 : p.IsPrime] [inst_6 : P.IsPrime]
(this : P.LiesOver (Ideal.under R p)),
let p₀ := Ideal.under R p;
let this_1 := Local... | null | false |
ContinuousLinearMap.prodMapL._proof_25 | Mathlib.Analysis.Normed.Operator.Prod | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (M₁ : Type u_2) (M₃ : Type u_3) [inst_1 : SeminormedAddCommGroup M₁]
[inst_2 : NormedSpace 𝕜 M₁] [inst_3 : SeminormedAddCommGroup M₃] [inst_4 : NormedSpace 𝕜 M₃],
IsNormableSpace 𝕜 (M₁ × M₃ →L[𝕜] M₁) | null | false |
Aesop.ScopeName.noConfusionType | Aesop.Rule.Name | Sort v✝ → Aesop.ScopeName → Aesop.ScopeName → Sort v✝ | null | true |
CategoryTheory.Limits.binaryFanZeroLeftIsLimit._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C)
(s : CategoryTheory.Limits.BinaryFan 0 X),
CategoryTheory.CategoryStruct.comp s.snd (CategoryTheory.CategoryStruct.id X) = s.snd | null | false |
Lean.OptionDecl._sizeOf_inst | Lean.Data.Options | SizeOf Lean.OptionDecl | null | false |
BooleanAlgebra.mk | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} →
[toDistribLattice : DistribLattice α] →
[toCompl : Compl α] →
[toSDiff : SDiff α] →
[toHImp : HImp α] →
[toTop : Top α] →
[toBot : Bot α] →
(∀ (x : α), x ⊓ xᶜ ≤ ⊥) →
(∀ (x : α), ⊤ ≤ x ⊔ xᶜ) →
(∀ (a : α), a ≤ ⊤) →
... | null | true |
_private.Mathlib.Tactic.Widget.StringDiagram.0.Mathlib.Tactic.Widget.StringDiagram.mkKind.match_5 | Mathlib.Tactic.Widget.StringDiagram | (motive : Option Mathlib.Tactic.Bicategory.Context → Sort u_1) →
(ctx? : Option Mathlib.Tactic.Bicategory.Context) →
((val : Mathlib.Tactic.Bicategory.Context) → motive (some val)) → (Unit → motive none) → motive ctx? | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.