name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.pow_log_le_self | Mathlib.Data.Nat.Log | ∀ (b : ℕ) {x : ℕ}, x ≠ 0 → b ^ Nat.log b x ≤ x | null | true |
DirectSum.IsInternal.isometryL2OfOrthogonalFamily._proof_3 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
TestFunction.bilinLeftCLM._proof_4 | Mathlib.Analysis.Distribution.TestFunction | ∀ {𝕜 : Type u_4} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {n : ℕ∞} {F₁ : Type u_5} {F₂ : Type u_3} {F₃ : Type u_2}
[inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁] [inst_5 : NormedSpace ℝ F₁]
[inst_6 ... | null | false |
CoalgHom.End._proof_2 | Mathlib.RingTheory.Coalgebra.Hom | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] (n : ℕ) (x : A →ₗc[R] A), x ^ (n + 1) = x ^ n * x | null | false |
CategoryTheory.Limits.CatCospanTransform.associator_inv_base_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | null | true |
_private.Mathlib.Analysis.Complex.Basic.0.Complex.continuous_normSq._simp_1_1 | Mathlib.Analysis.Complex.Basic | ∀ (z : ℂ), ‖z‖ ^ 2 = Complex.normSq z | null | false |
RBTree.RBNode.forIn.visit | Batteries.Recycling.RBTree.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} → {σ : Type u_1} → [Monad m] → (α → σ → m (ForInStep σ)) → RBTree.RBNode α → σ → m (ForInStep σ) | Inner loop of `forIn`. | true |
USize.ofInt | Init.Data.UInt.Basic | ℤ → USize | Converts an `Int` to a `USize` by taking the (non-negative remainder of the division by `2 ^ numBits`. | true |
Mathlib.Meta.NormNum.NormNums.erase | Mathlib.Tactic.NormNum.Core | {m : Type → Type} →
[Monad m] → [Lean.MonadError m] → Mathlib.Meta.NormNum.NormNums → Lean.Name → m Mathlib.Meta.NormNum.NormNums | Erase a name marked as a `norm_num` attribute.
Check that it does in fact have the `norm_num` attribute by making sure it names a `NormNumExt`
found somewhere in the state's tree, and is not erased.
| true |
AlgebraicGeometry.IsOpenImmersion.comp_lift._proof_2 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {Y Z : AlgebraicGeometry.Scheme} (g : Y ⟶ Z) {Y' : AlgebraicGeometry.Scheme} (g' : Y' ⟶ Y),
Set.range ⇑(CategoryTheory.CategoryStruct.comp g' g) ⊆ Set.range ⇑g | null | false |
_private.Mathlib.Tactic.NormNum.Prime.0.Mathlib.Meta.NormNum.evalMinFac._sparseCasesOn_1 | Mathlib.Tactic.NormNum.Prime | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.CategoryTheory.ObjectProperty.Small.0.CategoryTheory.ObjectProperty.instSmallMax.match_1.splitter | Mathlib.CategoryTheory.ObjectProperty.Small | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
{P Q : CategoryTheory.ObjectProperty C} →
(motive : Subtype P ⊕ Subtype Q → Sort u_2) →
(x : Subtype P ⊕ Subtype Q) →
((x : Subtype P) → motive (Sum.inl x)) → ((x : Subtype Q) → motive (Sum.inr x)) → motive x | null | true |
ENat.natCast_lt_natCast._simp_1 | Mathlib.Data.ENat.Basic | ∀ {n m : ℕ}, (↑n < ↑m) = (n < m) | null | false |
RingEquiv.map_eq_zero_iff | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(f : R ≃+* S) {x : R}, f x = 0 ↔ x = 0 | null | true |
MeasureTheory.AEStronglyMeasurable.fun_add | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f g : α → β} [inst_1 : Add β] [ContinuousAdd β],
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AEStronglyMeasurable g μ → MeasureTheory.AEStronglyMeasurable (fun i => f i + g i) μ | null | true |
CategoryTheory.PreOneHypercover.Hom.s₁' | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} → {F : CategoryTheory.PreOneHypercover S} → E.Hom F → E.I₁' → F.I₁' | The induced index map `E.I₁' → F.I₁'` from a refinement morphism `E ⟶ F`. | true |
CategoryTheory.Comma.opFunctor_map | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) {X Y : CategoryTheory.Comma L R} (f : X ⟶ Y),
(CategoryTheory.Comma.... | null | true |
Lean.Lsp.TextDocumentChangeRegistrationOptions.documentSelector? | Lean.Data.Lsp.TextSync | Lean.Lsp.TextDocumentChangeRegistrationOptions → Option Lean.Lsp.DocumentSelector | null | true |
InnerProductSpace.HarmonicOnNhd.comp_CLM | Mathlib.Analysis.InnerProductSpace.Harmonic.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] {G : Type u_3}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace ℝ G] {f : E → F} {s : Set E},
InnerProductSpace.HarmonicOn... | Compositions of continuous linear maps with harmonic functions are harmonic.
| true |
Bimod._sizeOf_1 | Mathlib.CategoryTheory.Monoidal.Bimod | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} → {A B : CategoryTheory.Mon C} → [SizeOf C] → Bimod A B → ℕ | null | false |
Lean.Parser.Term.configItem.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_8 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (x : Fin as.size), ↑x < as.size | null | false |
ContinuousLinearEquiv.restrictScalars_apply | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ (R : Type u_1) {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [inst_4 : Module S M] [inst_5 : TopologicalSpace M] [inst_6 : LinearMap.CompatibleSMul M M R S]
(f : M ≃L[S] M) (a : M), (ContinuousLinearEquiv.restrictScalars R f) a = f a | null | true |
ContDiffPointwiseHolderAt.mk | Mathlib.Analysis.Calculus.ContDiffHolder.Pointwise | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {k : ℕ} {α : ↑unitInterval} {f : E → F} {a : E},
ContDiffAt ℝ (↑k) f a →
((fun x => iteratedFDeriv ℝ k f x - iteratedFDeriv ℝ k f a) =O[nhds a] fun x => ‖x - a‖ ^ ↑... | null | true |
Homeomorph.quotientKerEquivRange | Mathlib.Topology.Maps.Strict.Basic | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → {f : X → Y} → Topology.IsStrictMap f → Quotient (Setoid.ker f) ≃ₜ ↑(Set.range f) | The homeomorphism `Quotient (Setoid.ker f) ≃ₜ Set.range f` given by a strict map `f`.
This is the homeomorphism obtained from the first isomorphism theorem. | true |
Vector.get_tail | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} (v : Vector α (n + 1)) (i : Fin n), v.tail.get i = v.get i.succ | null | true |
CategoryTheory.Subobject.pullback.congr_simp | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasPullbacks C]
(f f_1 : X ⟶ Y), f = f_1 → CategoryTheory.Subobject.pullback f = CategoryTheory.Subobject.pullback f_1 | null | true |
ProbabilityTheory._aux_Mathlib_Probability_Moments_Variance___unexpand_ProbabilityTheory_variance_1 | Mathlib.Probability.Moments.Variance | Lean.PrettyPrinter.Unexpander | null | false |
Con.comapQuotientEquivOfSurj_symm_mk' | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] (c : Con M) (f : N ≃* M) (x : N),
(c.comapQuotientEquivOfSurj ↑f ⋯).symm ⟦f x⟧ = ↑x | This version infers the surjectivity of the function from a MulEquiv function | true |
AlgebraicTopology.DoldKan.DegeneraciesVanish.comp | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {n : ℕ} {T : C} {f : X.obj (Opposite.op { len := n }) ⟶ T},
AlgebraicTopology.DoldKan.DegeneraciesVanish f →
∀ {U : C} (g : T ⟶ U), AlgebraicTopology.DoldKan.Degeneracie... | null | true |
AffineEquiv.coeFn_inj._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] {e e' : P₁ ≃ᵃ[k] P₂}, (⇑e = ⇑e') = (e = e') | null | false |
«_aux_Mathlib_Order_Notation___macroRules_term_ᶜ_1» | Mathlib.Order.Notation | Lean.Macro | null | false |
_private.Mathlib.Tactic.Nontriviality.Core.0.Mathlib.Tactic.Nontriviality.elabNontriviality.match_1 | Mathlib.Tactic.Nontriviality.Core | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((tgt' : Lean.Expr) → motive (some tgt')) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
Lean.Parser.Syntax.unicodeAtom.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | null | true |
StarSubalgebra.starRing._proof_2 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (s : StarSubalgebra R A) (r₁ r₂ : ↥s),
star (r₁ * r₂) = star r₂ * star r₁ | null | false |
Finset.zsmul | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [DecidableEq α] → [Zero α] → [Add α] → [Neg α] → SMul ℤ (Finset α) | Repeated pointwise addition/subtraction (not the same as pointwise repeated
addition/subtraction!) of a `Finset`. See note [pointwise nat action]. | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.ToDepElimPattern.main.unpack.go.match_1 | Lean.Elab.Match | (motive : Lean.Expr → Sort u_1) →
(packed : Lean.Expr) →
((n : Lean.Name) → (d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam n d b binderInfo)) →
((x : Lean.Expr) → motive x) → motive packed | null | false |
Aesop.GoalKind.noConfusion | Aesop.Stats.Basic | {P : Sort v✝} → {x y : Aesop.GoalKind} → x = y → Aesop.GoalKind.noConfusionType P x y | null | false |
_private.Mathlib.Algebra.Polynomial.Monic.0.Polynomial.not_isUnit_X_add_C._proof_1_1 | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u_1} [inst : Semiring R] (g : Polynomial R), 0 = 1 + g.natDegree → False | null | false |
Ordering.isLE_eq_false | Init.Data.Ord.Basic | ∀ {o : Ordering}, o.isLE = false ↔ o = Ordering.gt | null | true |
SSet.Truncated.FundamentalGroupoid.pt | Mathlib.AlgebraicTopology.SimplicialSet.FundamentalGroupoid.Basic | {X : SSet.Truncated 2} →
X.FundamentalGroupoid →
X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.FundamentalGroupoid._proof_1 }) | The underlying vertex. | true |
CategoryTheory.Limits.walkingParallelPairOpEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {X Y : CategoryTheory.Limits.WalkingParallelPair} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id CategoryTheory.Limits.WalkingParallelPair).map f)
(CategoryTheory.eqToIso ⋯).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToIso ⋯).hom
((CategoryTheory.Limits.w... | null | false |
ENNReal.top_mul_top | Mathlib.Basic.ENNReal.Operations | ⊤ * ⊤ = ⊤ | null | true |
Option.not_isNone | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (a : Option α), (!a.isNone) = a.isSome | null | true |
Finset.forall_mem_compls | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {s : Finset α} {p : α → Prop}, (∀ a ∈ s.compls, p a) ↔ ∀ a ∈ s, p aᶜ | null | true |
Std.Roc.pairwise_toList_lt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : LT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLE α] [Std.PRange.LawfulUpwardEnumerableLT α] [inst_7 : Std.Rxc.IsAlwaysFinite α],
List.Pairwise (fun a b ... | null | true |
DFinsupp.toFun_eq_coe | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] (f : Π₀ (i : ι), β i), f.toFun = ⇑f | null | true |
addMonoidAlgebraRingEquivDirectSum_apply | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | ∀ {ι : Type u_1} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring M]
[inst_3 : (m : M) → Decidable (m ≠ 0)], ⇑addMonoidAlgebraRingEquivDirectSum = AddMonoidAlgebra.toDirectSum | null | true |
MulHom.prodMap | Mathlib.Algebra.Group.Prod | {M : Type u_3} →
{N : Type u_4} →
{M' : Type u_6} →
{N' : Type u_7} →
[inst : Mul M] →
[inst_1 : Mul N] → [inst_2 : Mul M'] → [inst_3 : Mul N'] → (M →ₙ* M') → (N →ₙ* N') → M × N →ₙ* M' × N' | `Prod.map` as a `MonoidHom`. | true |
DoResultSBC.ctorElim | Init.Core | {α σ : Type u} →
{motive : DoResultSBC α σ → Sort u_1} →
(ctorIdx : ℕ) → (t : DoResultSBC α σ) → ctorIdx = t.ctorIdx → DoResultSBC.ctorElimType ctorIdx → motive t | null | false |
Std.DTreeMap.get?_union_of_not_mem_right | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α}, k ∉ t₂ → (t₁ ∪ t₂).get? k = t₁.get? k | null | true |
_private.Mathlib.LinearAlgebra.SymplecticGroup.0.SymplecticGroup.fromBlocks_mem_iff._simp_1_1 | Mathlib.LinearAlgebra.SymplecticGroup | ∀ {l : Type u_1} {R : Type u_2} [inst : DecidableEq l] [inst_1 : Fintype l] [inst_2 : CommRing R]
{A : Matrix (l ⊕ l) (l ⊕ l) R}, (A ∈ Matrix.symplecticGroup l R) = (A * Matrix.J l R * A.transpose = Matrix.J l R) | null | false |
Nat.Perfect | Mathlib.NumberTheory.Divisors | ℕ → Prop | `n : ℕ` is perfect if and only the sum of the proper divisors of `n` is `n` and `n`
is positive. | true |
SheafOfModules.Submodule | Mathlib.Algebra.Category.ModuleCat.Sheaf.Submodule | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} → SheafOfModules R → Type (max u₁ v) | A submodule of a sheaf of modules `M`: a submodule `N` of the underlying presheaf of modules
whose membership condition is local. | true |
Std.TreeMap.Raw.getKey?_inter_of_mem_right | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∈ t₂ → (t₁ ∩ t₂).getKey? k = t₁.getKey? k | null | true |
AddCommMonCat.limitAddCommMonoid._proof_10 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddCommMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddCommMonCat)).sections],
autoParam
(∀ (x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget AddCommMonCat)))... | null | false |
Std.TreeMap.Equiv.insertManyIfNewUnit_list | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {t₁ t₂ : Std.TreeMap α Unit cmp},
t₁.Equiv t₂ → ∀ (l : List α), (t₁.insertManyIfNewUnit l).Equiv (t₂.insertManyIfNewUnit l) | null | true |
Std.DHashMap.Raw.Equiv.diff_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ m₃ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₂.Equiv m₃ → (m₁ \ m₂).Equiv (m₁ \ m₃) | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.toUInt8_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a < b) = (a.toNat < b.toNat) | null | false |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.BodyMode.eof | Std.Http.Protocol.H1 | Std.Http.Protocol.H1.Machine.BodyMode✝ | null | true |
_private.Mathlib.Basic.Nonempty.0.nonempty_psum.match_1_5 | Mathlib.Basic.Nonempty | ∀ {α : Sort u_1} {β : Sort u_2} (motive : Nonempty α ∨ Nonempty β → Prop) (h : Nonempty α ∨ Nonempty β),
(∀ (a : α), motive ⋯) → (∀ (b : β), motive ⋯) → motive h | null | false |
IsAddQuotientCoveringMap.map_vadd | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {G : Type u_3}
[inst_2 : AddGroup G] [inst_3 : AddAction G E], IsAddQuotientCoveringMap f G → ∀ (g : G) {e : E}, f (g +ᵥ e) = f e | null | true |
List.Pi.cons_def | Mathlib.Data.List.Pi | ∀ {ι : Type u_1} [inst : DecidableEq ι] {α : ι → Sort u_2} {i : ι} {l : List ι} (a : α i) (f : (j : ι) → j ∈ l → α j),
List.Pi.cons i l a f = fun j hj => if h : j = i then ⋯ ▸ a else f j ⋯ | null | true |
CochainComplex.HomComplex.Cochain.leftUnshift_neg | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n' a : ℤ}
(γ : CochainComplex.HomComplex.Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n') (n : ℤ)
(hn : n + a = n'), (-γ).leftUnshift n hn = -γ.leftUnshift n hn | null | true |
Prod.instCommGroup | Mathlib.Algebra.Group.Prod | {G : Type u_1} → {H : Type u_2} → [CommGroup G] → [CommGroup H] → CommGroup (G × H) | null | true |
ZeroHom.instAddMonoid._proof_5 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} {N : Type u_2} [inst : Zero M] [inst_1 : AddMonoid N],
autoParam (∀ (n : ℕ) (x : ZeroHom M N), (n + 1) • x = n • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
Ideal.Fiber.algEquivAux₂._proof_4 | Mathlib.RingTheory.LocalRing.ResidueField.Fiber | ∀ {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], RingHomClass (S →ₐ[R] TensorProduct R p.ResidueField S) S (TensorProduct R p.ResidueField S) | null | false |
countableSupClosure_univ | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} [inst : Preorder α], countableSupClosure Set.univ = Set.univ | null | true |
Simps.ProjectionRule.erase | Mathlib.Tactic.Simps.Basic | Lean.Name → Lean.Syntax → Simps.ProjectionRule | A hiding rule `-fieldName` | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.revMatchAt?_eq_none_iff.match_1_2 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {endPos : s.Pos}
(motive : String.Slice.Pattern.Model.RevMatchesAt pat endPos → Prop)
(x : String.Slice.Pattern.Model.RevMatchesAt pat endPos),
(∀ (h' : ∃ startPos, String.Slice.Pattern.Model.IsLongestRevMatchAt pat sta... | null | false |
Polynomial.ofFinsupp_ofNat | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (n : ℕ) [inst_1 : n.AtLeastTwo], { toFinsupp := OfNat.ofNat n } = OfNat.ofNat n | null | true |
aeSeq.aeSeq_eq_fun_of_mem_aeSeqSet | Mathlib.MeasureTheory.Function.AEMeasurableSequence | ∀ {ι : Sort u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : ι → α → β}
{μ : MeasureTheory.Measure α} {p : α → (ι → β) → Prop} (hf : ∀ (i : ι), AEMeasurable (f i) μ) {x : α},
x ∈ aeSeqSet hf p → ∀ (i : ι), aeSeq hf p i x = f i x | null | true |
CategoryTheory.Abelian.FunctorCategory.functor_category_isIso_coimageImageComparison | Mathlib.CategoryTheory.Abelian.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type w} [inst_1 : CategoryTheory.Category.{z, w} D]
[inst_2 : CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D} (α : F ⟶ G),
CategoryTheory.IsIso (CategoryTheory.Abelian.coimageImageComparison α) | null | true |
OrderIso.subLeft | Mathlib.Algebra.Order.Group.OrderIso | {α : Type u} → [inst : AddGroup α] → [inst_1 : LE α] → [AddLeftMono α] → [AddRightMono α] → α → α ≃o αᵒᵈ | `x ↦ a - x` as an order-reversing equivalence. | true |
CategoryTheory.Subobject.Classifier.Ω₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Subobject.Classifier C → C | The domain of the truth morphism | true |
Polynomial.lt_rootMultiplicity_iff_isRoot_iterate_derivative | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : CommRing R] [NoZeroDivisors R] [CharZero R] {p : Polynomial R} {t : R} {n : ℕ},
p ≠ 0 → (n < Polynomial.rootMultiplicity t p ↔ ∀ m ≤ n, ((⇑Polynomial.derivative)^[m] p).IsRoot t) | null | true |
_private.Init.Data.Nat.Basic.0.Nat.sub_lt_sub_right.match_1_1 | Init.Data.Nat.Basic | ∀ (motive : (x x_1 x_2 : ℕ) → x_2 ≤ x → x < x_1 → Prop) (x x_1 x_2 : ℕ) (x_3 : x_2 ≤ x) (x_4 : x < x_1),
(∀ (x x_5 : ℕ) (hle : x_5 ≤ 0) (h : 0 < x), motive 0 x x_5 hle h) →
(∀ (x x_5 : ℕ) (x_6 : 0 ≤ x) (h : x < x_5), motive x x_5 0 x_6 h) →
(∀ (n n_1 n_2 : ℕ) (hle : n_2 + 1 ≤ n + 1) (h : n + 1 < n_1 + 1), m... | null | false |
Lean.Grind.instIsCharPISizeHPowNatOfNatNumBits | Init.GrindInstances.Ring.SInt | Lean.Grind.IsCharP ISize (2 ^ System.Platform.numBits) | null | true |
Aesop.ForwardInstantiationStats._sizeOf_1 | Aesop.Stats.Basic | Aesop.ForwardInstantiationStats → ℕ | null | false |
Lean.Order.instCompleteLatticePProd | Init.Internal.Order.Basic | {α : Sort u} →
{β : Sort v} → [Lean.Order.CompleteLattice α] → [Lean.Order.CompleteLattice β] → Lean.Order.CompleteLattice (α ×' β) | null | true |
PNat.add_coe._simp_1 | Mathlib.Data.PNat.Basic | ∀ (m n : ℕ+), ↑m + ↑n = ↑(m + n) | null | false |
Prod.seminormedCommRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedCommRing α] [inst_1 : SeminormedCommRing β] (a : α × β), 1 * a = a | null | false |
PerfectSpace.univ_preperfect | Mathlib.Topology.Perfect | ∀ {α : Type u_1} {inst : TopologicalSpace α} [self : PerfectSpace α], Preperfect Set.univ | null | true |
CategoryTheory.Profunctor.associatorComponents._proof_1 | Mathlib.CategoryTheory.Profunctor.Comp | ∀ {C D E F : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] [inst_1 : CategoryTheory.Category.{u_6, u_1} D]
[inst_2 : CategoryTheory.Category.{u_5, u_1} E] [inst_3 : CategoryTheory.Category.{u_3, u_1} F]
(P : CategoryTheory.Profunctor.{max u_2 u_1, u_4, u_6, u_1, u_1} C D)
(Q : CategoryTheory.Profunctor.... | null | false |
Lean.Elab.Do.ControlStack.noConfusionType | Lean.Elab.Do.Control | Sort u → Lean.Elab.Do.ControlStack → Lean.Elab.Do.ControlStack → Sort u | null | false |
Int.sqrt_eq | Mathlib.Data.Int.Sqrt | ∀ (n : ℤ), Int.sqrt (n * n) = ↑n.natAbs | null | true |
Array.findFinIdx?_empty | Init.Data.Array.Find | ∀ {α : Type u_1} {p : α → Bool}, Array.findFinIdx? p #[] = none | null | true |
CochainComplex.ConnectData.homologyIsoPos._proof_1 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L) (n : ℕ) [NeZero n] (m : ℤ),
m = ↑n →
∀ [HomologicalComplex.HasHomology L n],
(HomologicalComplex.restricti... | null | false |
Std.DHashMap.Internal.AssocList.casesOn | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{motive : Std.DHashMap.Internal.AssocList α β → Sort u_1} →
(t : Std.DHashMap.Internal.AssocList α β) →
motive Std.DHashMap.Internal.AssocList.nil →
((key : α) →
(value : β key) →
(tail : Std.DHashMap.Internal.AssocList α β) →... | null | false |
ModularGroup.exists_eq_T_zpow_of_c_eq_zero | Mathlib.NumberTheory.Modular | ∀ {g : Matrix.SpecialLinearGroup (Fin 2) ℤ}, ↑g 1 0 = 0 → ∃ n, ∀ (z : UpperHalfPlane), g • z = ModularGroup.T ^ n • z | null | true |
Function.Embedding.codRestrict_apply | Mathlib.Logic.Embedding.Set | ∀ {α : Sort u_1} {β : Type u_2} (p : Set β) (f : α ↪ β) (H : ∀ (a : α), f a ∈ p) (a : α),
(Function.Embedding.codRestrict p f H) a = ⟨f a, ⋯⟩ | null | true |
AddSubmonoid.neg_le | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (S T : AddSubmonoid G), -S ≤ T ↔ S ≤ -T | null | true |
Std.Http.Status.proxyAuthenticationRequired | Std.Http.Data.Status | Std.Http.Status | 407 Proxy Authentication Required
| true |
MvPowerSeries.trunc_one | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : DecidableEq σ] [inst_1 : CommSemiring R] (n : σ →₀ ℕ),
n ≠ 0 → (MvPowerSeries.trunc R n) 1 = 1 | null | true |
Lean.Options.get? | Lean.Data.Options | {α : Type} → [Lean.KVMap.Value α] → Lean.Options → Lean.Name → Option α | null | true |
List.Lex.decidableRel._proof_3 | Mathlib.Data.List.Lex | ∀ {α : Type u_1} (r : α → α → Prop) (l₁ : List α), List.Lex r l₁ [] → False | null | false |
KaehlerDifferential.mvPolynomialBasis_repr_D | Mathlib.RingTheory.Kaehler.Polynomial | ∀ (R : Type u) [inst : CommRing R] (σ : Type u_1) (x : MvPolynomial σ R),
(KaehlerDifferential.mvPolynomialBasis R σ).repr ((KaehlerDifferential.D R (MvPolynomial σ R)) x) =
(MvPolynomial.mkDerivation R fun x => fun₀ | x => 1) x | null | true |
FreeAddGroup.reduceCyclically.eq_1 | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u} [inst : DecidableEq α] (l : List (α × Bool)),
FreeAddGroup.reduceCyclically l =
List.bidirectionalRec [] (fun x => [x]) (fun a L b rC => if b.1 = a.1 ∧ (!b.2) = a.2 then rC else a :: L ++ [b]) l | null | true |
_private.Mathlib.Algebra.Module.Submodule.Pointwise.0.Submodule.smul_inductionOn_pointwise._simp_1_1 | 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] {S : Type u_4}
[inst_3 : Monoid S] [inst_4 : DistribMulAction S M] (N : Submodule R M) [inst_5 : SMulCommClass S R M] (r : S),
r • N = {r} • N | null | false |
_private.Mathlib.Condensed.Light.Sequence.0.LightCondensed.internallyProjective_free_natUnionInfty._proof_1_10 | Mathlib.Condensed.Light.Sequence | T2Space (OnePoint ℕ) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.