name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.minKey_alter_eq_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
AlgEquiv.uniqueProd._proof_5 | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (x : R), ((algebraMap R (B × A)) x).2 = ((algebraMap R (B × A)) x).2 | null | false |
MeasurableEmbedding.equivImage._proof_2 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β} (s : Set α),
MeasurableEmbedding f → Measurable fun x => ⟨(f ∘ fun a => ↑(id a)) x, ⋯⟩ | null | false |
BoxIntegral.unitPartition.box | Mathlib.Analysis.BoxIntegral.UnitPartition | {ι : Type u_1} → (n : ℕ) → [NeZero n] → (ι → ℤ) → BoxIntegral.Box ι | A `BoxIntegral`, indexed by a positive integer `n` and `ν : ι → ℤ`, with corners `ν i / n`
and of side length `1 / n`. | true |
Irrational.intCast_div | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ}, Irrational x → ∀ {m : ℤ}, m ≠ 0 → Irrational (↑m / x) | null | true |
FirstOrder.Language.LHom.sumInr | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} → {L' : FirstOrder.Language} → L' →ᴸ L.sum L' | The inclusion of the right factor into the sum of two languages. | true |
AddMonoidHom.toMultiplicativeRight_symm_apply_apply | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {α : Type u_3} {β : Type u_4} [inst : MulOneClass α] [inst_1 : AddZeroClass β] (f : α →* Multiplicative β)
(a : Additive α), (AddMonoidHom.toMultiplicativeRight.symm f) a = Multiplicative.toAdd (f (Additive.toMul a)) | null | true |
List.SortedLT.getElem_lt_getElem_iff | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : LinearOrder α],
l.SortedLT → ∀ {i j : ℕ} {hi : i < l.length} {hj : j < l.length}, l[i] < l[j] ↔ i < j | null | true |
HurwitzZeta.completedCosZeta_eq | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : UnitAddCircle) (s : ℂ),
HurwitzZeta.completedCosZeta a s = HurwitzZeta.completedCosZeta₀ a s - 1 / s - (if a = 0 then 1 else 0) / (1 - s) | null | true |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors.0.«_aux_Mathlib_RingTheory_UniqueFactorizationDomain_NormalizedFactors___macroRules__private_Mathlib_RingTheory_UniqueFactorizationDomain_NormalizedFactors_0_term_~ᵤ__1» | Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | Lean.Macro | null | false |
ContinuousLinearMap.homeomorphOfUnit._proof_4 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_2} [inst : Semiring R₁] {M₁ : Type u_1} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] (T : (M₁ →L[R₁] M₁)ˣ), Continuous ⇑↑T⁻¹ | null | false |
CStarAlgebra.sub._inherited_default | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
(zero : A) →
(add : A → A → A) →
(∀ (a b c : A), a + b + c = a + (b + c)) →
(∀ (a : A), 0 + a = a) →
(∀ (a : A), a + 0 = a) →
(nsmul : ℕ → A → A) →
(∀ (x : A), 0 • x = 0) → (∀ (n : ℕ) (x : A), (n + 1) • x = n • x + x) → (A → A) → A → A → A | null | false |
Lean.Elab.Tactic.State._sizeOf_1 | Lean.Elab.Term.TermElabM | Lean.Elab.Tactic.State → ℕ | null | false |
LieSubalgebra.lieRing._proof_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ (R : Type u_2) (L : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(L' : LieSubalgebra R L) (x y z : ↥L'), ⟨⁅↑(x + y), ↑z⁆, ⋯⟩ = ⟨⁅↑x, ↑z⁆, ⋯⟩ + ⟨⁅↑y, ↑z⁆, ⋯⟩ | null | false |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.LetValue.toMono.match_5 | Lean.Compiler.LCNF.ToMono | (motive : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
((monoDecl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) → motive (some monoDecl)) →
((x : Option (Lean.Compiler.LCNF.Decl Lean.... | null | false |
UInt8.ofBitVec_shiftRight | Init.Data.UInt.Bitwise | ∀ (a : BitVec 8), ∀ b < 8, { toBitVec := a >>> b } = { toBitVec := a } >>> UInt8.ofNat b | null | true |
MeasureTheory.AECover.integrable_of_integral_tendsto_of_nonneg_ae | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι} [l.NeBot]
[l.IsCountablyGenerated] {φ : ι → Set α},
MeasureTheory.AECover μ l φ →
∀ {f : α → ℝ} (I : ℝ),
(∀ (i : ι), MeasureTheory.IntegrableOn f (φ i) μ) →
(∀ᵐ (x : α) ∂μ, 0 ≤ f x) →
... | null | true |
Lean.Meta.Grind.AC.State.steps._default | Lean.Meta.Tactic.Grind.AC.Types | ℕ | null | false |
HomologicalComplex.HomologySequence.mapComposableArrows₅._proof_1 | Mathlib.Algebra.Homology.HomologySequenceLemmas | 0 ≤ 1 | null | false |
Multiset.instHasSubset | Mathlib.Data.Multiset.Defs | {α : Type u_1} → HasSubset (Multiset α) | null | true |
MvPFunctor._sizeOf_1 | Mathlib.Data.PFunctor.Multivariate.Basic | {n : ℕ} → MvPFunctor.{u} n → ℕ | null | false |
ENNReal.top_mul' | Mathlib.Basic.ENNReal.Operations | ∀ {a : ENNReal}, ⊤ * a = if a = 0 then 0 else ⊤ | null | true |
NonUnitalAlgHom.mem_equalizer._simp_1 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] (φ ψ : A →ₙₐ[R] B) (x : A),
(x ∈ φ.equalizer ψ) = (φ x = ψ x) | null | false |
Lean.MetavarContext.LevelMVarToParam.State._sizeOf_1 | Lean.MetavarContext | Lean.MetavarContext.LevelMVarToParam.State → ℕ | null | false |
Unitization.inr_le_inr_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] {a b : A},
↑a ≤ ↑b ↔ a ≤ b | null | true |
_private.Mathlib.Data.Int.Basic.0.Int.dvd_natCast._simp_1_2 | Mathlib.Data.Int.Basic | ∀ {a b : ℤ}, (-a ∣ b) = (a ∣ b) | null | false |
Lists'.mem_of_subset'._unary | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : Lists α} (_x : (l₁ : Lists' α true) ×' (l₂ : Lists' α true) ×' (_ : l₁ ⊆ l₂) ×' a ∈ l₁.toList),
a ∈ _x.2.1 | null | false |
WithTop.LinearOrderedAddCommGroup.sub_eq_top_iff | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {G : Type u_1} [inst : AddCommGroup G] {x y : WithTop G}, x - y = ⊤ ↔ x = ⊤ ∨ y = ⊤ | null | true |
CategoryTheory.Preadditive.RightFreyd.Candidate.π | Mathlib.CategoryTheory.Preadditive.FreydCategory.RightFreyd | {V : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
[inst_1 : CategoryTheory.Preadditive V] →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts V] →
{u v : CategoryTheory.Arrow V} → (f : u ⟶ v) → v ⟶ CategoryTheory.Preadditive.RightFreyd.Candidate.cokernel f | For `f : u ⟶ v` a morphism in `Arrow V`, this is the morphism `v ⟶ cokernel f` from `v` to
the "candidate cokernel" of `f`, whose image in `RightFreyd V` will be the projection to
the cokernel of the image of `f`. | true |
Lean.Lsp.DocumentChange.create | Lean.Data.Lsp.Basic | Lean.Lsp.CreateFile → Lean.Lsp.DocumentChange | null | true |
String.Slice.toInt! | Init.Data.String.Slice | String.Slice → ℤ | Interprets a string as the decimal representation of an integer, returning it. Panics if the string
does not contain a decimal integer.
A string can be interpreted as a decimal integer if it only consists of at least one decimal digit
and optionally `-` in front. Leading `+` characters are not allowed.
Use `Slice.isI... | true |
RatFunc.toFractionRing_smul | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : CommRing K] {R : Type u_1} [inst_1 : SMul R (FractionRing (Polynomial K))] (c : R)
(p : RatFunc K), (c • p).toFractionRing = c • p.toFractionRing | null | true |
Module.End.hasEigenvalue_neg_iff | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R}, (-f).HasEigenvalue μ ↔ f.HasEigenvalue (-μ) | null | true |
not_covBy_of_denselyOrdered | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LT α] {a b : α} [DenselyOrdered α], ¬a ⋖ b | In a dense order, nothing covers anything. | true |
CategoryTheory.Adjunction.homEquiv_apply._to_dual_1 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : G ⊣ F) (X : C) (Y : D) (f : Y ⟶ F.obj X),
(adj.homEquiv' X Y) f = CategoryTheory.CategoryStruct.comp (G.map f) (adj.counit.... | null | false |
Algebra.Presentation.instCore_1._aux_1 | Mathlib.RingTheory.Extension.Presentation.Core | {R : Type u_1} →
{S : Type u_2} →
{ι : Type u_3} →
{σ : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → {P : Algebra.Presentation R S ι σ} → P.Core → S → S | null | false |
Aesop.Frontend.Parser.builder_nameConstructors | Aesop.Frontend.RuleExpr | Lean.ParserDescr | null | true |
Nat.prod_primeFactors_invOn_squarefree | Mathlib.Data.Nat.Squarefree | Set.InvOn (fun n => n.factorization.support) (fun s => ∏ p ∈ s, p) {s | ∀ p ∈ s, Nat.Prime p} {n | Squarefree n} | null | true |
Std.Http.Body.mk._flat_ctor | Std.Http.Data.Body.Basic | {α : Type} →
(α → Std.Async.Async (Option Std.Http.Chunk)) →
(α → Std.Async.Async Unit) →
(α → Std.Async.Async Bool) →
(α → Std.Async.Selector (Option Std.Http.Chunk)) →
(α → Std.Async.Async (Option (Option Std.Http.Chunk))) →
(α → Std.Async.Async (Option Std.Http.Body.Length))... | null | false |
ONote.fastGrowing_succ | Mathlib.SetTheory.Ordinal.Notation | ∀ (o : ONote) {a : ONote}, o.fundamentalSequence = Sum.inl (some a) → o.fastGrowing = fun i => a.fastGrowing^[i] i | null | true |
AddSubsemigroup.mk_le_mk._simp_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M] {s t : Set M} (h_add : ∀ {a b : M}, a ∈ s → b ∈ s → a + b ∈ s)
(h_add' : ∀ {a b : M}, a ∈ t → b ∈ t → a + b ∈ t),
({ carrier := s, add_mem' := h_add } ≤ { carrier := t, add_mem' := h_add' }) = (s ⊆ t) | null | false |
NumberField.mixedEmbedding.fundamentalCone.prod_deriv_expMap_single | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.realSpace K),
∏ w,
NumberField.mixedEmbedding.fundamentalCone.deriv_expMap_single w
((NumberField.mixedEmbedding.fundamentalCone.completeBasis K).equivFun.symm x w) =
Real.exp (x NumberField.Units.dirichletUni... | null | true |
CategoryTheory.Limits.WidePushoutShape.equivalenceOfEquiv.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} (J' : Type w') (h : J ≃ J'),
CategoryTheory.Limits.WidePushoutShape.equivalenceOfEquiv J' h =
{
functor :=
CategoryTheory.Limits.WidePushoutShape.wideSpan none (fun j => some (h j)) fun j =>
CategoryTheory.Limits.WidePushoutShape.Hom.init (h j),
inverse :=
Cate... | null | true |
_private.Std.Data.Iterators.Lemmas.Equivalence.Basic.0.Std.quotMk_eq_quotOfQuot_comp | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {α : Sort u_1} {R S : α → α → Prop} (h : ∀ (a b : α), R a b → S a b), Quot.mk S = Std.quotOfQuot✝ h ∘ Quot.mk R | null | true |
Sigma.instIsCentralVAdd | Mathlib.Algebra.Group.Action.Sigma | ∀ {ι : Type u_1} {M : Type u_2} {α : ι → Type u_4} [inst : (i : ι) → VAdd M (α i)] [inst_1 : (i : ι) → VAdd Mᵃᵒᵖ (α i)]
[∀ (i : ι), IsCentralVAdd M (α i)], IsCentralVAdd M ((i : ι) × α i) | null | true |
_private.Mathlib.Data.Set.Image.0.Set.range_eq_singleton_iff._simp_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
le_mul_right | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {α : Type u} [inst : Mul α] [inst_1 : Preorder α] [CanonicallyOrderedMul α] {a b c : α}, a ≤ b → a ≤ b * c | **Alias** of `le_mul_of_le_left`. | true |
AddAction.IsBlock.vadd_eq_vadd_or_disjoint | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} {X : Type u_2} [inst : VAdd G X] {B : Set X},
AddAction.IsBlock G B → ∀ (g₁ g₂ : G), g₁ +ᵥ B = g₂ +ᵥ B ∨ Disjoint (g₁ +ᵥ B) (g₂ +ᵥ B) | **Alias** of the forward direction of `AddAction.isBlock_iff_vadd_eq_vadd_or_disjoint`. | true |
Ring.DimensionLEOne.casesOn | Mathlib.RingTheory.DedekindDomain.Basic | {R : Type u_1} →
[inst : CommRing R] →
{motive : Ring.DimensionLEOne R → Sort u} →
(t : Ring.DimensionLEOne R) →
((maximalOfPrime : ∀ {p : Ideal R}, p ≠ ⊥ → p.IsPrime → p.IsMaximal) → motive ⋯) → motive t | null | false |
_private.Init.Data.UInt.Lemmas.0.UInt16.ofNat_eq_iff_mod_eq_toNat._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a = b) = (a.toNat = b.toNat) | null | false |
IntermediateField.coe_div._simp_1 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L)
(x y : ↥S), ↑x / ↑y = ↑(x / y) | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.String.0.String.Slice.startsWith_slice_iff.match_1_8 | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat s : String.Slice} (motive : (∃ x, pat.copy.toList ++ x.toList = s.copy.toList) → Prop)
(x : ∃ x, pat.copy.toList ++ x.toList = s.copy.toList),
(∀ (t : String) (ht : pat.copy.toList ++ t.toList = s.copy.toList), motive ⋯) → motive x | null | false |
CategoryTheory.ShortComplex.HomologyMapData.add_right | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ φ' : S₁ ⟶ S₂} {h₁ : S₁.HomologyData} {h₂ : S₂.HomologyData}
(γ : CategoryTheory.ShortComplex.HomologyMapData φ h₁ h₂) (γ' : CategoryTheory.ShortComplex.HomologyMapData φ'... | null | true |
Multiset.nodup_iff_count_le_one | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Multiset α}, s.Nodup ↔ ∀ (a : α), Multiset.count a s ≤ 1 | null | true |
AddMonoidAlgebra.basis.eq_1 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ (R : Type u_7) (k : Type u_8) [inst : Semiring k],
AddMonoidAlgebra.basis R k = { repr := AddMonoidAlgebra.coeffLinearEquiv k } | null | true |
CStarMatrix.instRing._proof_3 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Ring A],
autoParam (∀ (n_1 : ℕ) (a : CStarMatrix n n A), ↑n_1.succ • a = ↑n_1 • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
starL'_apply | Mathlib.Topology.Algebra.Module.Star | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : AddCommMonoid A]
[inst_3 : StarAddMonoid A] [inst_4 : Module R A] [inst_5 : StarModule R A] [inst_6 : TopologicalSpace A]
[inst_7 : ContinuousStar A] [inst_8 : TrivialStar R] (x : A), (starL' R) x = star x | null | true |
_private.Mathlib.Algebra.Module.NatInt.0.Module.addCommMonoidToAddCommGroup._simp_4 | Mathlib.Algebra.Module.NatInt | ∀ {α : Type u_5} {M : Type u_9} {N : Type u_10} [inst : SMul M N] [inst_1 : SMul N α] [inst_2 : SMul M α]
[IsScalarTower M N α] (x : M) (y : N) (z : α), x • y • z = (x • y) • z | null | false |
AddCon.congr_symm._proof_2 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_2} {N : Type u_1} [inst : Add M] [inst_1 : Add N] {c : AddCon M} {d : AddCon N} (e : M ≃+ N),
c = AddCon.comap ⇑e ⋯ d → ∀ (x₁ x₂ : M), d (e x₁) (e x₂) ↔ (AddCon.comap ⇑e.symm ⋯ c) (e x₁) (e x₂) | null | false |
Finset.card_univ_diff | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (s : Finset α),
(Finset.univ \ s).card = Fintype.card α - s.card | **Alias** of `Finset.card_univ_sdiff`. | true |
MulOpposite.instNormedAddCommGroup | Mathlib.Analysis.Normed.Group.Constructions | {E : Type u_3} → [NormedAddCommGroup E] → NormedAddCommGroup Eᵐᵒᵖ | null | true |
Aesop.PersistentHashSet.filter | Aesop.Util.Basic | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → (α → Bool) → Lean.PHashSet α → Lean.PHashSet α | null | true |
_private.Mathlib.Algebra.BigOperators.Group.List.Basic.0.List.prod_set'._proof_1_1 | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_1} (L : List G) (n : ℕ), ¬n < L.length → L.length ≤ n | null | false |
AddCon | Mathlib.GroupTheory.Congruence.Defs | (M : Type u_1) → [Add M] → Type u_1 | A congruence relation on a type with an addition is an equivalence relation which
preserves addition. | true |
Lean.Meta.Try.Collector.OrdSet.mk | Lean.Meta.Tactic.Try.Collect | {α : Type} → [inst : Hashable α] → [inst_1 : BEq α] → Array α → Std.HashSet α → Lean.Meta.Try.Collector.OrdSet α | null | true |
Std.ExtDTreeMap.isSome_maxKey?_insertIfNew | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k}, (t.insertIfNew k v).maxKey?.isSome = true | null | true |
Batteries.Tactic.Alias.setDeprecatedTarget | Batteries.Tactic.Alias | Lean.Name → Array Lean.Elab.Attribute → Array Lean.Elab.Attribute × Bool | Updates the `deprecated` declaration to point to `target` if no target is provided. | true |
_private.Init.Data.Option.Lemmas.0.Option.ext.match_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (motive : (x x_1 : Option α) → (∀ (a : α), x = some a ↔ x_1 = some a) → Prop) (x x_1 : Option α)
(x_2 : ∀ (a : α), x = some a ↔ x_1 = some a),
(∀ (x : ∀ (a : α), none = some a ↔ none = some a), motive none none x) →
(∀ (val : α) (x : Option α) (H : ∀ (a : α), some val = some a ↔ x = some a), mo... | null | false |
ContinuousLinearMap.opNNNorm_comp_linearIsometryEquiv | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜₁ : Type u_2} {𝕜₂ : Type u_3} {𝕜₃ : Type u_4} {E : Type u_5} {F : Type u_6} {G : Type u_8}
[inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜₁] [inst_4 : NormedSpace 𝕜₁ E] [inst_5 : NontriviallyNormedField 𝕜₂]
[inst_6 : Norme... | Precomposition with a linear isometry preserves the operator norm. | true |
Std.DTreeMap.Internal.Impl.Const.maxKey?_modify | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : β → β},
(Std.DTreeMap.Internal.Impl.Const.modify k f t).maxKey? =
Option.map (fun km => if compare km k = Ordering.eq then k else km) t.maxKey? | null | true |
Profinite.NobelingProof.spanCone._proof_1 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} {C : Set (I → Bool)}, IsCompact C → CompactSpace ↑C | null | false |
_private.Mathlib.Topology.UniformSpace.Basic.0.nhdset_of_mem_uniformity.match_1_7 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u_1} (s : SetRel α α) (motive : (x : α × α) → x ∈ s → Prop) (x : α × α) (hp : x ∈ s),
(∀ (a b : α) (hp : (a, b) ∈ s), motive (a, b) hp) → motive x hp | null | false |
Fin.le_castPred_iff | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ Fin.last n), j ≤ i.castPred hi ↔ j.castSucc ≤ i | null | true |
addRothNumber_empty | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α], addRothNumber ∅ = 0 | null | true |
ComplexShape.Associative.ε₂_ε₁ | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₃ : Type u_3} {I₁₂ : Type u_4} {I₂₃ : Type u_5} {J : Type u_6}
{c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {c₃ : ComplexShape I₃} {c₁₂ : ComplexShape I₁₂} {c₂₃ : ComplexShape I₂₃}
{c : ComplexShape J} {inst : TotalComplexShape c₁ c₂ c₁₂} {inst_1 : TotalComplexShape c₁₂ c₃ c}
... | null | true |
BitVec.toInt_add | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w), (x + y).toInt = (x.toInt + y.toInt).bmod (2 ^ w) | null | true |
CategoryTheory.Oplax.StrongTrans.mkOfOplax'._proof_6 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (η : CategoryTheory.Oplax.OplaxTrans F G)
[inst_2 : ∀ (a b : B) (f : a ⟶ b), CategoryTheory.IsIso (η.naturality f)] {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheor... | null | false |
OneHomClass.bound_of_antilipschitz | Mathlib.Analysis.Normed.Group.Uniform | ∀ {𝓕 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : SeminormedGroup E] [inst_1 : SeminormedGroup F]
[inst_2 : FunLike 𝓕 E F] [OneHomClass 𝓕 E F] (f : 𝓕) {K : NNReal},
AntilipschitzWith K ⇑f → ∀ (x : E), ‖x‖ ≤ ↑K * ‖f x‖ | null | true |
Lean.Grind.CommRing.Mon.degree | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Mon → ℕ | null | true |
IsUnit.scaleRoots_dvd_iff | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} [inst : CommSemiring R] (p q : Polynomial R) {r : R},
IsUnit r → (p.scaleRoots r ∣ q.scaleRoots r ↔ p ∣ q) | **Alias** of `Polynomial.scaleRoots_dvd_iff`. | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardStringSearcher.matchesAt_iff_getElem._proof_1 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat : String} {s : String.Slice} {pos : s.Pos},
pos.offset.byteIdx + pat.toByteArray.size ≤ s.copy.toByteArray.size →
∀ j < pat.toByteArray.size, ¬pos.offset.byteIdx + j < s.copy.toByteArray.size → False | null | false |
Std.Time.DayPeriodSymbols.mk.injEq | Std.Time.Format.DateFormat | ∀ (am pm noon midnight am_1 pm_1 noon_1 midnight_1 : String),
({ am := am, pm := pm, noon := noon, midnight := midnight } =
{ am := am_1, pm := pm_1, noon := noon_1, midnight := midnight_1 }) =
(am = am_1 ∧ pm = pm_1 ∧ noon = noon_1 ∧ midnight = midnight_1) | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.oppositeRightAction_actionObj_op | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (d : D) (c : C),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.a... | null | true |
_private.Mathlib.Order.Ideal.0.Order.isIdeal_sUnion_of_directedOn.match_1_1 | Mathlib.Order.Ideal | ∀ {P : Type u_1} {C : Set (Set P)} (motive : C.Nonempty → Prop) (hNe : C.Nonempty),
(∀ (I : Set P) (hI : I ∈ C), motive ⋯) → motive hNe | null | false |
Int32.xor_left_inj._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32} (c : Int32), (a ^^^ c = b ^^^ c) = (a = b) | null | false |
OrderHom.instSemilatticeInf._proof_1 | Mathlib.Order.Hom.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : SemilatticeInf β] (a b : α →o β),
SemilatticeInf.inf a b ≤ a | null | false |
AlgebraicGeometry.Scheme.fromSpecResidueField.eq_1 | Mathlib.AlgebraicGeometry.ResidueField | ∀ (X : AlgebraicGeometry.Scheme) (x : ↥X),
X.fromSpecResidueField x =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map (X.residue x)) (X.fromSpecStalk x) | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₄_eq_some_iff_utf8EncodeChar_eq._proof_1_10 | Init.Data.String.Decode | ∀ {c : Char}, 65535 < c.toNat → ¬65536 ≤ c.toNat → False | null | false |
MvPowerSeries.exists_coeff_ne_zero_and_weightedOrder | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) {f : MvPowerSeries σ R},
↑(MvPowerSeries.weightedOrder w f).toNat = MvPowerSeries.weightedOrder w f →
∃ d, (MvPowerSeries.coeff d) f ≠ 0 ∧ ↑((Finsupp.weight w) d) = MvPowerSeries.weightedOrder w f | If the order of a formal power series `f` is finite,
then some coefficient of weight equal to the order of `f` is nonzero. | true |
Lean.Parser.Command.include.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
alternatingGroup.kleinFour_card_of_card_eq_four | Mathlib.GroupTheory.SpecificGroups.Alternating.KleinFour | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α],
Nat.card α = 4 → Nat.card ↥(alternatingGroup.kleinFour α) = 4 | null | true |
Filter.tendsto_mul_const_atBot_of_neg | Mathlib.Order.Filter.AtTopBot.Field | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {l : Filter β}
{f : β → α} {r : α}, r < 0 → (Filter.Tendsto (fun x => f x * r) l Filter.atBot ↔ Filter.Tendsto f l Filter.atTop) | If `r` is a negative constant, `fun x ↦ f x * r` tends to negative infinity along a filter `l`
if and only if `f` tends to infinity along `l`. | true |
SSet.prodStdSimplex.isoNerve._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex | ∀ (p q : ℕ) {X Y : SimplexCategoryᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj { len := p })
(SSet.stdSimplex.obj { len := q })).map
f)
(match Y with
| Opposite.op { len := d } =>
(SSet.prod... | null | false |
PresentedAddMonoid.instAddMonoid | Mathlib.Algebra.PresentedMonoid.Basic | {α : Type u_1} → {rels : FreeAddMonoid α → FreeAddMonoid α → Prop} → AddMonoid (PresentedAddMonoid rels) | null | true |
realPart_comp_subtype_selfAdjoint | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [inst_3 : StarModule ℂ A],
realPart ∘ₗ (selfAdjoint.submodule ℝ A).subtype = LinearMap.id | null | true |
Finset.HasMulAntidiagonal.mk.noConfusion | Mathlib.Algebra.Order.Antidiag.Prod | {A : Type u_1} →
{inst : Mul A} →
{P : Sort u} →
{mulAntidiagonal : A → Finset (A × A)} →
{mem_mulAntidiagonal : ∀ {n : A} {a : A × A}, a ∈ mulAntidiagonal n ↔ a.1 * a.2 = n} →
{mulAntidiagonal' : A → Finset (A × A)} →
{mem_mulAntidiagonal' : ∀ {n : A} {a : A × A}, a ∈ mulAntid... | null | false |
Equiv.Set.univPi._proof_3 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_2} {β : α → Type u_1} (s : (a : α) → Set (β a)) (f : ↑(Set.univ.pi s)) (a : α), ↑f a ∈ s a | null | false |
_private.Lean.Parser.Types.0.Lean.Parser.SyntaxStack.mk.noConfusion | Lean.Parser.Types | {P : Sort u} →
{raw : Array Lean.Syntax} →
{drop : ℕ} →
{raw' : Array Lean.Syntax} →
{drop' : ℕ} →
{ raw := raw, drop := drop } = { raw := raw', drop := drop' } → (raw = raw' → drop = drop' → P) → P | null | false |
_private.Mathlib.Algebra.Order.Ring.GeomSum.0.geom_sum_alternating_of_lt_neg_one._simp_1_3 | Mathlib.Algebra.Order.Ring.GeomSum | ∀ {n : ℕ}, Even (n + 1) = ¬Even n | null | false |
_private.Mathlib.Algebra.Group.Pointwise.Finset.Basic.0.Finset.isUnit_iff_singleton._simp_1_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u} [inst : Group α] (a : α), IsUnit a = True | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.