name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.logMap_expMapBasis._simp_1_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
OnePoint.continuousMapMkDiscrete._proof_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_2} [inst_1 : TopologicalSpace Y] [inst_2 : DiscreteTopology X]
(f : X → Y) (y : Y),
Filter.Tendsto f Filter.cofinite (nhds y) →
Filter.Tendsto (⇑{ toFun := f, continuous_toFun := ⋯ }) (Filter.coclosedCompact X) (nhds y) | null | false |
Subsemiring.toIsStrictOrderedRing | Mathlib.Algebra.Ring.Subsemiring.Order | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (s : Subsemiring R),
IsStrictOrderedRing ↥s | A subsemiring of a strict ordered semiring is a strict ordered semiring. | true |
String.Pos.Raw.isValidForSlice_eq_false_iff._simp_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw},
(String.Pos.Raw.isValidForSlice s p = false) = ¬String.Pos.Raw.IsValidForSlice s p | null | false |
Std.TreeMap.getKeyD_maxKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → ∀ {fallback : α}, t.getKeyD t.maxKey! fallback = t.maxKey! | null | true |
CartanMatrix.Generators.F.sizeOf_spec | Mathlib.Algebra.Lie.SerreConstruction | ∀ {B : Type v} [inst : SizeOf B] (a : B), sizeOf (CartanMatrix.Generators.F a) = 1 + sizeOf a | null | true |
IterateAddAct.instMeasurableSpace.eq_1 | Mathlib.MeasureTheory.MeasurableSpace.Instances | ∀ {α : Type u_1} {f : α → α}, IterateAddAct.instMeasurableSpace = ⊤ | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Dihedral.0.DihedralGroup.center_eq_bot_of_odd_ne_one._proof_1_3 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ}, Odd n → n ≠ 1 → 1 < n | null | false |
CategoryTheory.InjectiveResolution.add_extMk | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.InjectiveResolution Y) {n : ℕ}
(f g : X ⟶ R.cocomplex.X n) (m : ℕ) (hm : n + 1 = m)
(hf : CategoryTheory.CategoryStruct.comp f (R.cocomplex.d n m) = 0)
(h... | null | true |
DiffeologicalSpace.CorePlotsOn.mk.inj | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1}
{isPlotOn : {n : ℕ} → {u : Set (EuclideanSpace ℝ (Fin n))} → IsOpen u → (EuclideanSpace ℝ (Fin n) → X) → Prop}
{isPlotOn_congr :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p q : EuclideanSpace ℝ (Fin n) → X},
Set.EqOn p q u → (isPlotOn hu p ↔ isPlotOn hu q)}
{isPlot... | null | true |
RBTree.RBNode.foldr.eq_2 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {σ : Sort u_2} (f : α → σ → σ) (x : σ) (c : RBTree.RBColor) (l : RBTree.RBNode α) (v : α)
(r : RBTree.RBNode α),
RBTree.RBNode.foldr f (RBTree.RBNode.node c l v r) x = RBTree.RBNode.foldr f l (f v (RBTree.RBNode.foldr f r x)) | null | true |
Std.Roo.HasRcoIntersection.ctorIdx | Init.Data.Range.Polymorphic.PRange | {α : Type w} → Std.Roo.HasRcoIntersection α → ℕ | null | false |
Batteries.Random.MersenneTwister.State.twist | Batteries.Data.Random.MersenneTwister | {cfg : Batteries.Random.MersenneTwister.Config} →
Batteries.Random.MersenneTwister.State cfg → Batteries.Random.MersenneTwister.State cfg | Apply the twisting transformation to the given state. | true |
NonUnitalStarAlgHom.realContinuousMapZeroOfNNReal._proof_8 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_2} [inst : TopologicalSpace X] [inst_1 : Zero X] {A : Type u_1} [inst_2 : NonUnitalRing A]
[inst_3 : StarRing A] [inst_4 : Module ℝ A] (φ : ContinuousMapZero X NNReal →⋆ₙₐ[NNReal] A)
(f : ContinuousMapZero X ℝ), φ (star f).toNNReal - φ (-star f).toNNReal = star (φ f.toNNReal - φ (-f).toNNReal) | null | false |
Eq.ndrec_symm.congr_simp | Init.Grind.Ring.CommSolver | ∀ {α : Sort u2} {a : α} {motive : α → Sort u1} (m m_1 : motive a),
m = m_1 → ∀ {b : α} (h : b = a), Eq.ndrec_symm m h = Eq.ndrec_symm m_1 h | null | true |
Fin.decodeProd_encodeProd | Batteries.Data.Fin.Coding | ∀ {m n : ℕ} (x : Fin m × Fin n), Fin.decodeProd (Fin.encodeProd x) = x | null | true |
Array.elem_push_self | Init.Data.Array.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {xs : Array α} {a : α}, Array.elem a (xs.push a) = true | null | true |
Nonneg.instIsCancelAdd | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [inst_2 : AddLeftMono α] [IsCancelAdd α],
IsCancelAdd (Nonneg α) | null | true |
Mathlib.Meta.Positivity.evalPowZeroNat | Mathlib.Tactic.Positivity.Basic | Mathlib.Meta.Positivity.PositivityExt | The `positivity` extension which identifies expressions of the form `a ^ (0 : ℕ)`.
This extension is run in addition to the general `a ^ b` extension (they are overlapping). | true |
LibraryNote.category_theory_universes | Mathlib.CategoryTheory.Category.Basic | Batteries.Util.LibraryNote | The typeclass `Category C` describes morphisms associated to objects of type `C : Type u`.
The universe levels of the objects and morphisms are independent, and will often need to be
specified explicitly, as `Category.{v} C`.
Typically any concrete example will either be a `SmallCategory`, where `v = u`,
which can be... | true |
Equiv.subtypePreimage._proof_7 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_2} {β : Sort u_1} (p : α → Prop) [inst : DecidablePred p] (x₀ : { a // p a } → β) (x : α → β)
(hx : x ∘ Subtype.val = x₀) (a : α),
↑((fun x => ⟨fun a => if h : p a then x₀ ⟨a, h⟩ else x ⟨a, h⟩, ⋯⟩) ((fun x a => ↑x ↑a) ⟨x, hx⟩)) a = ↑⟨x, hx⟩ a | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.RingId.0.Lean.Meta.Grind.Arith.CommRing.getCommSemiringId?.go? | Lean.Meta.Tactic.Grind.Arith.CommRing.RingId | Lean.Expr → Lean.Meta.Grind.GoalM (Option ℕ) | null | true |
Lean.Elab.HeaderProcessedSnapshot.noConfusionType | Lean.Elab.DefView | Sort u → Lean.Elab.HeaderProcessedSnapshot → Lean.Elab.HeaderProcessedSnapshot → Sort u | null | false |
Lean.instReprSMap | Lean.Data.SMap | {α : Type u_1} → {β : Type u_2} → {x : BEq α} → {x_1 : Hashable α} → [Repr α] → [Repr β] → Repr (Lean.SMap α β) | null | true |
_private.Init.Data.List.Nat.Count.0.List.countP_replace._proof_1_6 | Init.Data.List.Nat.Count | ∀ {α : Type u_1} [BEq α] {a : α} {b : α} {p : α → Bool} (x : α) (l : List α),
(¬((List.countP p l + if p b = true then 1 else 0) + if p x = true then 1 else 0) =
(List.countP p l + if p x = true then 1 else 0) + if p b = true then 1 else 0) →
False | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.δ_comp_δ._proof_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (i k : ℕ), k < i → i ≤ k → False | null | false |
Polynomial.evalEval_neg | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : Ring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.evalEval x y (-p) = -Polynomial.evalEval x y p | null | true |
summable_pnat_iff_summable_succ | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] {f : ℕ → M},
(Summable fun x => f ↑x) ↔ Summable fun x => f (x + 1) | null | true |
CentroidHom.commRing | Mathlib.Algebra.Ring.CentroidHom | {α : Type u_5} →
[inst : NonUnitalRing α] → (∀ (a b : α), (∀ (r : α), a * r * b = 0) → a = 0 ∨ b = 0) → CommRing (CentroidHom α) | A prime associative ring has commutative centroid. | true |
ProbabilityTheory.HasGaussianLaw.fst | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {F : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E]
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace ℝ F] [inst_6 : MeasurableSpace F] {Y : Ω → F},
... | null | true |
NNRat.castHom | Mathlib.Data.Rat.Cast.CharZero | (α : Type u_1) → [inst : DivisionSemiring α] → [CharZero α] → ℚ≥0 →+* α | Coercion `ℚ≥0 → α` as a `RingHom`. | true |
CategoryTheory.Abelian.Ext.precompOfLinear._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X : C} (R : Type u_1) [inst_3 : CommRing R] [inst_4 : CategoryTheory.Linear R C]
(Z : C) {b : ℕ}, SMulCommClass R R (CategoryTheory.Abelian.Ext X Z b) | null | false |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.addUnresolvedCompletionItem | Lean.Server.Completion.CompletionCollectors | Lean.Name →
Lean.Lsp.CompletionIdentifier →
Lean.Lsp.CompletionItemKind → Array Lean.Lsp.CompletionItemTag → Lean.Server.Completion.M✝ Unit | Adds a new completion item with the given `label`, `id`, `kind` and `score` to the state in `M`.
Computes the doc string from the environment if available.
| true |
CategoryTheory.MorphismProperty.instCompleteBooleanAlgebra._proof_15 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.CategoryStruct.{u_1, u_2} C] (x : ⦃X Y : C⦄ → (X ⟶ Y) → Prop), ⊤ ≤ x ⊔ xᶜ | null | false |
_private.Init.Data.String.OrderInstances.0.String.Pos.Raw.instTotalLe._simp_6 | Init.Data.String.OrderInstances | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
ordinaryHypergeometricSeries.congr_simp | Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric | ∀ {𝕂 : Type u_1} (𝔸 : Type u_2) [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸] [inst_3 : TopologicalSpace 𝔸]
[inst_4 : IsTopologicalRing 𝔸] (a a_1 : 𝕂),
a = a_1 →
∀ (b b_1 : 𝕂),
b = b_1 →
∀ (c c_1 : 𝕂),
c = c_1 → ∀ (n : ℕ), ordinaryHypergeometricSeries 𝔸 a b c n = ... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_minKeyD._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
NormedAddGroupHom.ker.lift._proof_2 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_3} {V₂ : Type u_1} {V₃ : Type u_2} [inst : SeminormedAddCommGroup V₁]
[inst_1 : SeminormedAddCommGroup V₂] [inst_2 : SeminormedAddCommGroup V₃] (f : NormedAddGroupHom V₁ V₂)
(g : NormedAddGroupHom V₂ V₃) (h : g.comp f = 0) (v w : V₁), ⟨f (v + w), ⋯⟩ = ⟨f v, ⋯⟩ + ⟨f w, ⋯⟩ | null | false |
AddSubgroup.instNormalCenter | Mathlib.GroupTheory.Subgroup.Center | ∀ {G : Type u_1} [inst : AddGroup G], (AddSubgroup.center G).Normal | null | true |
List.splitLengths.eq_def | Mathlib.Data.List.SplitLengths | ∀ {α : Type u_1} (x : List ℕ) (x_1 : List α),
x.splitLengths x_1 =
match x, x_1 with
| [], x => []
| n :: ns, x =>
match List.splitAt n x with
| (x0, x1) => x0 :: ns.splitLengths x1 | null | true |
AlgEquiv.ofRingEquiv.congr_simp | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] {f f_1 : A₁ ≃+* A₂} (e_f : f = f_1)
(hf : ∀ (x : R), f ((algebraMap R A₁) x) = (algebraMap R A₂) x), AlgEquiv.ofRingEquiv hf = AlgEquiv.ofRingEquiv ⋯ | null | true |
LieRing.recOn | Mathlib.Algebra.Lie.Basic | {L : Type v} →
{motive : LieRing L → Sort u} →
(t : LieRing L) →
([toAddCommGroup : AddCommGroup L] →
[toBracket : Bracket L L] →
(add_lie : ∀ (x y z : L), ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆) →
(lie_add : ∀ (x y z : L), ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆) →
(lie_self ... | null | false |
_private.Init.Data.String.Defs.0.String.Slice.Pos.byte._simp_1 | Init.Data.String.Defs | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
CategoryTheory.ShortComplex.SnakeInput.snd_δ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd S.L₁.g S.v₀₁.τ₃) S.δ =
CategoryTheory.CategoryStruct.comp S.φ₁ S.v₂₃.τ₁ | null | true |
OrderEmbedding.locallyFiniteOrder._proof_6 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder β] (f : α ↪o β)
(a b : α), Set.InjOn (⇑f.toEmbedding) (⇑f ⁻¹' ↑(Finset.Ico (f a) (f b))) | null | false |
PerfectionMap.id | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (R : Type u₁) [inst_1 : CommSemiring R] [inst_2 : CharP R p]
[inst_3 : PerfectRing R p], PerfectionMap p (RingHom.id R) | For a perfect ring, it itself is the perfection. | true |
Aesop.NormSeqResult.proved.noConfusion | Aesop.Search.Expansion.Norm | {P : Sort u} →
{script script' : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep))} →
Aesop.NormSeqResult.proved script = Aesop.NormSeqResult.proved script' → (script = script' → P) → P | null | false |
LightProfinite.equivDiagram | Mathlib.Topology.Category.LightProfinite.Basic | LightProfinite ≌ LightDiagram | The equivalence of categories `LightProfinite ≌ LightDiagram` | true |
Lean.Meta.Sym.Simp.Result.isContextDependent.match_1 | Lean.Meta.Sym.Simp.SimpM | (motive : Lean.Meta.Sym.Simp.Result → Sort u_1) →
(x : Lean.Meta.Sym.Simp.Result) →
((done cd : Bool) → motive (Lean.Meta.Sym.Simp.Result.rfl done cd)) →
((e' proof : Lean.Expr) → (done cd : Bool) → motive (Lean.Meta.Sym.Simp.Result.step e' proof done cd)) → motive x | null | false |
RelIso.trans._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_3} {β : Type u_1} {γ : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop} (f₁ : r ≃r s)
(f₂ : s ≃r t) {a b : α}, t (f₂ (f₁.toEquiv a)) (f₂ (f₁.toEquiv b)) ↔ r a b | null | false |
_private.Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski.0.AlgebraicGeometry.Scheme.AffineZariskiSite.coequifibered_iff_forall_isLocalizationAway.match_1_5 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} (x : X.AffineZariskiSiteᵒᵖ) (motive : (x_1 : X.AffineZariskiSiteᵒᵖ) → (x_1 ⟶ x) → Prop)
(x_1 : X.AffineZariskiSiteᵒᵖ) (x_2 : x_1 ⟶ x),
(∀ (V : X.AffineZariskiSite) (x : Opposite.op V ⟶ x), motive (Opposite.op V) x) → motive x_1 x_2 | null | false |
Derivation.noConfusion | Mathlib.RingTheory.Derivation.Basic | {P : Sort u} →
{R : Type u_1} →
{A : Type u_2} →
{M : Type u_3} →
{inst : CommSemiring R} →
{inst_1 : CommSemiring A} →
{inst_2 : AddCommMonoid M} →
{inst_3 : Algebra R A} →
{inst_4 : Module A M} →
{inst_5 : Module R M} →
... | null | false |
HomeomorphClass.coe_coe | Mathlib.Topology.Homeomorph.Defs | ∀ {F : Type u_4} {α : Type u_5} {β : Type u_6} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : EquivLike F α β] [h : HomeomorphClass F α β] (f : F), ⇑↑f = ⇑f | null | true |
CategoryTheory.Functor.PullbackObjObj.π_iso_of_iso_left_inv | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ f₁' : CategoryTheory.Arrow C₁}
{f₃ : CategoryTheory.Arrow C... | null | true |
Std.Roi.LawfulRcoIntersection.mk._flat_ctor | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type w} [inst : LT α] [inst_1 : LE α] [inst_2 : Std.Roi.HasRcoIntersection α],
(∀ {a : α} {r : Std.Roi α} {s : Std.Rco α}, a ∈ Std.Roi.HasRcoIntersection.intersection r s ↔ a ∈ r ∧ a ∈ s) →
Std.Roi.LawfulRcoIntersection α | null | false |
List.mapIdx.go.match_1 | Init.Data.List.MapIdx | {α : Type u_1} →
{β : Type u_2} →
(motive : List α → Array β → Sort u_3) →
(x : List α) →
(x_1 : Array β) →
((acc : Array β) → motive [] acc) →
((a : α) → (as : List α) → (acc : Array β) → motive (a :: as) acc) → motive x x_1 | null | false |
Int.lcm_dvd_lcm_mul_right_right | Init.Data.Int.Gcd | ∀ (a b c : ℤ), a.lcm b ∣ a.lcm (b * c) | null | true |
_private.Batteries.Data.Char.Basic.0.Char.any._proof_1 | Batteries.Data.Char.Basic | ∀ c < Char.max - Char.maxSurrogate, 57343 < c + 57343 + 1 ∧ c + 57343 + 1 < 1114112 | null | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.FirstByte.utf8ByteSize.match_1.eq_3 | Init.Data.String.Decode | ∀ (motive : ByteArray.utf8DecodeChar?.FirstByte → Sort u_1)
(h_1 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.invalid)
(h_2 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.done)
(h_3 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.oneMore)
(h_4 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.... | null | true |
lie_mem_left | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L)
(x y : L), x ∈ I → ⁅x, y⁆ ∈ I | null | true |
_private.Batteries.Logic.0.not_nonempty_pempty.match_1_1 | Batteries.Logic | ∀ (motive : Nonempty PEmpty.{u_1} → Prop) (x : Nonempty PEmpty.{u_1}), (∀ (h : PEmpty.{u_1}), motive ⋯) → motive x | null | false |
isGLB_singleton._simp_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsGLB {a} a = True | null | false |
CategoryTheory.ObjectProperty.ι_obj_lift_obj | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(P : CategoryTheory.ObjectProperty D) (F : CategoryTheory.Functor C D) (hF : ∀ (X : C), P (F.obj X)) (X : C),
P.ι.obj ((P.lift F hF).obj X) = F.obj X | null | true |
AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft_I₀ | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z),
(AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft 𝒰 f g).I₀ = 𝒰.I₀ | null | true |
Mathlib.Explode.Entry.casesOn | Mathlib.Tactic.Explode.Datatypes | {motive : Mathlib.Explode.Entry → Sort u} →
(t : Mathlib.Explode.Entry) →
((type : Lean.MessageData) →
(line : Option ℕ) →
(depth : ℕ) →
(status : Mathlib.Explode.Status) →
(thm : Lean.MessageData) →
(deps : List (Option ℕ)) →
(useAsDep... | null | false |
Algebra.Extension.h1Cotangentι_ext | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
(x y : P.H1Cotangent), ↑x = ↑y → x = y | null | true |
GenContFract.nextDen | Mathlib.Algebra.ContinuedFractions.Basic | {K : Type u_2} → [DivisionRing K] → K → K → K → K → K | Returns the next denominator `Bₙ = bₙ₋₁ * Bₙ₋₁ + aₙ₋₁ * Bₙ₋₂`, where `predB` is `Bₙ₋₁` and
`ppredB` is `Bₙ₋₂`, `a` is `aₙ₋₁`, and `b` is `bₙ₋₁`.
| true |
Nat.or_mod_two_eq_one | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b : ℕ}, (a ||| b) % 2 = 1 ↔ a % 2 = 1 ∨ b % 2 = 1 | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.SolverExtension.mk.injEq | Lean.Meta.Tactic.Grind.Types | ∀ {σ : Type} (id : ℕ) (mkInitial : IO σ) (internalize : Lean.Expr → Option Lean.Expr → Lean.Meta.Grind.GoalM Unit)
(newEq newDiseq : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit) (mbtc : Lean.Meta.Grind.GoalM Bool)
(action : Lean.Meta.Grind.Action) (check : Lean.Meta.Grind.GoalM Bool) (checkInv : Lean.Meta.Gr... | null | true |
Submodule.one_mem_div._simp_1 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
{I J : Submodule R A}, (1 ∈ I / J) = (J ≤ I) | null | false |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.descFactorial_self.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
eventually_nhdsWithin_iff | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α} {p : α → Prop},
(∀ᶠ (x : α) in nhdsWithin a s, p x) ↔ ∀ᶠ (x : α) in nhds a, x ∈ s → p x | null | true |
Polynomial.Chebyshev.T_derivative_mem_span_T | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ {R : Type u_1} [inst : CommRing R] (n : ℕ),
Polynomial.derivative (Polynomial.Chebyshev.T R ↑n) ∈
Submodule.span ℕ ((fun m => Polynomial.Chebyshev.T R ↑m) '' Set.Ico 0 n) | null | true |
Qq.Impl.UnquoteState.exprBackSubst | Qq.Macro | Qq.Impl.UnquoteState → Std.HashMap Lean.Expr Qq.Impl.ExprBackSubstResult | Maps free variables in the new context to expressions in the old context (of type Expr) | true |
_private.Mathlib.RingTheory.Finiteness.Cofinite.0.Submodule.FG.cofg_of_codisjoint._simp_1_1 | Mathlib.RingTheory.Finiteness.Cofinite | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂}, Function.Surjective ⇑f = (f.range = ⊤... | null | false |
Matrix.Fin.circulant_mul_comm | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} [inst : CommMagma α] [inst_1 : AddCommMonoid α] {n : ℕ} (v w : Fin n → α),
Matrix.circulant v * Matrix.circulant w = Matrix.circulant w * Matrix.circulant v | null | true |
CategoryTheory.Functor.ext_of_iso._to_dual_1 | Mathlib.CategoryTheory.EqToHom | ∀ {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} (e : F ≅ G) (hobj : ∀ (X : C), F.obj X = G.obj X),
autoParam (∀ (X : C), e.inv.app X = CategoryTheory.eqToHom ⋯) CategoryTheory.Functor.ext_of_iso._to_dual_1._au... | null | false |
Fin.predAbove._proof_2 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (p : Fin n) (i : Fin (n + 1)), p.castSucc < i → i ≠ 0 | null | false |
metricSpacePi._proof_1 | Mathlib.Topology.MetricSpace.Basic | ∀ {β : Type u_1} {X : β → Type u_2} [inst : (b : β) → MetricSpace (X b)], T0Space ((i : β) → X i) | null | false |
_private.Mathlib.LinearAlgebra.Dimension.Free.0.FiniteDimensional.nonempty_linearEquiv_iff_finrank_eq.match_1_1 | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u_3} {M : Type u_2} {M' : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (motive : Nonempty (M ≃ₗ[R] M') → Prop)
(x : Nonempty (M ≃ₗ[R] M')), (∀ (h : M ≃ₗ[R] M'), motive ⋯) → motive x | null | false |
Ordinal._aux_Mathlib_SetTheory_Ordinal_Veblen___macroRules_Ordinal_termε₀_1 | Mathlib.SetTheory.Ordinal.Veblen | Lean.Macro | null | false |
Valuation.HasExtension.comp | Mathlib.RingTheory.Valuation.Extension | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_5} {B : Type u_6} {ΓR : Type u_7} {ΓA : Type u_8} {ΓB : Type u_9}
[inst_1 : CommRing A] [inst_2 : Ring B] [inst_3 : LinearOrderedCommMonoidWithZero ΓR]
[inst_4 : LinearOrderedCommMonoidWithZero ΓA] [inst_5 : LinearOrderedCommMonoidWithZero ΓB] [inst_6 : Algebra R A]
... | null | true |
_private.Mathlib.Topology.IsLocalHomeomorph.0.IsLocalHomeomorphOn.discreteTopology_image_iff._simp_1_2 | Mathlib.Topology.IsLocalHomeomorph | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
MonoidAlgebra.nonUnitalNonAssocRing._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : Mul M] (a b c : MonoidAlgebra R M),
(a + b) * c = a * c + b * c | null | false |
CentroidHom.instAddCommGroup._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (x y : CentroidHom α), (x + y).toEnd = x.toEnd + y.toEnd | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.withInductiveLocalDecls.loop._unsafe_rec | Lean.Elab.MutualInductive | {α : Type} →
Array Lean.Elab.Command.PreElabHeaderResult →
(Array Lean.Expr → Array Lean.Expr → Lean.Elab.TermElabM α) →
Array Lean.Expr → ℕ → Array Lean.Expr → Lean.Elab.TermElabM α | null | false |
Option.pfilter_congr | Init.Data.Option.Lemmas | ∀ {α : Type u} {o o' : Option α} (ho : o = o') {f : (a : α) → o = some a → Bool} {g : (a : α) → o' = some a → Bool},
(∀ (a : α) (ha : o' = some a), f a ⋯ = g a ha) → o.pfilter f = o'.pfilter g | null | true |
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux_map | Mathlib.CategoryTheory.Sites.CoverLifting | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {G : CategoryTheory.Functor C D} {A : Type w}
[inst_2 : CategoryTheory.Category.{w', w} A] {J : CategoryTheory.GrothendieckTopology C}
{K : CategoryTheory.GrothendieckTopology D} [inst_3 :... | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.clear._regBuiltin.Lean.Parser.Term.clear.parenthesizer_13 | Lean.Parser.Term | IO Unit | null | false |
MeasureTheory.ofReal_lpNorm | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f : α → E},
MeasureTheory.MemLp f p μ → ENNReal.ofReal (MeasureTheory.lpNorm f p μ) = MeasureTheory.eLpNorm f p μ | null | true |
_private.Init.Data.Nat.Lemmas.0.Nat.le_pow._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {a : ℕ} {b : ℕ}, 0 < b → ¬b = b - 1 + 1 → False | null | false |
DirectSum.sigmaCurryEquiv._proof_2 | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type u_3} [inst : DecidableEq ι] {α : ι → Type u_2} {δ : (i : ι) → α i → Type u_1}
[inst_1 : (i : ι) → (j : α i) → AddCommMonoid (δ i j)],
Function.RightInverse DFinsupp.sigmaCurryEquiv.invFun DFinsupp.sigmaCurryEquiv.toFun | null | false |
Dilation.isClosedEmbedding | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : EMetricSpace α] [inst_1 : FunLike F α β] [CompleteSpace α]
[inst_3 : EMetricSpace β] [DilationClass F α β] (f : F), Topology.IsClosedEmbedding ⇑f | A dilation from a complete emetric space is a closed embedding | true |
DirectSum.instRingOfNat._proof_2 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddMonoid ι], (DirectSum.of A 0) 0 = 0 | null | false |
Finmap.lookup_union_right | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s₁ s₂ : Finmap β},
a ∉ s₁ → Finmap.lookup a (s₁ ∪ s₂) = Finmap.lookup a s₂ | null | true |
LE.rec | Init.Prelude | {α : Type u} → {motive : LE α → Sort u_1} → ((le : α → α → Prop) → motive { le := le }) → (t : LE α) → motive t | null | false |
MeasureTheory.innerRegularWRT_isCompact_isOpen | Mathlib.MeasureTheory.Measure.RegularityCompacts | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
[TopologicalSpace.IsCompletelyPseudoMetrizableSpace α] [OpensMeasurableSpace α] (P : MeasureTheory.Measure α)
[MeasureTheory.IsFiniteMeasure P], P.InnerRegularWRT IsCompact IsOpen | null | true |
MinTropical.instCommMonoidOfAddCommMonoid.eq_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : AddCommMonoid R],
MinTropical.instCommMonoidOfAddCommMonoid = { toMonoid := MinTropical.instMonoidOfAddMonoid, mul_comm := ⋯ } | null | true |
PontryaginDual.instFiniteOfDiscreteTopologyOfCompactSpace | Mathlib.Topology.Algebra.PontryaginDual | ∀ {A : Type u_1} [inst : Monoid A] [inst_1 : TopologicalSpace A] [DiscreteTopology A] [CompactSpace A],
Finite (PontryaginDual A) | null | true |
Lean.Environment.isPrivateOrAutoDecl | Batteries.Tactic.Lint.Basic | Lean.Environment → Lean.Name → Bool | Returns true if `decl` is a private or automatically generated declaration.
Also returns true if `decl` is an internal name or created during macro expansion.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.