name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
WithBot.insertBot | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → Finset α ↪o Finset (WithBot α) | Given a finset on `α`, lift it to being a finset on `WithBot α`
using `WithBot.some` and then insert `⊥`. | true |
Finset.preimage_subset | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} {f : α ↪ β} {s : Finset β} {t : Finset α}, s ⊆ Finset.map f t → s.preimage ⇑f ⋯ ⊆ t | null | true |
Aesop.GoalWithMVars.ctorIdx | Aesop.Script.GoalWithMVars | Aesop.GoalWithMVars → ℕ | null | false |
Algebra.semiringToRing._proof_1 | Mathlib.Algebra.Algebra.Basic | ∀ {A : Type u_1} (R : Type u_2) [inst : CommRing R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (z : ℕ),
(algebraMap R A) ↑↑z = ↑z | null | false |
BoundedContinuousFunction.natCast_apply | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : PseudoMetricSpace β] [inst_2 : NatCast β] (n : ℕ)
(x : α), ↑n x = ↑n | null | true |
AddUnits.leftOfAdd._proof_2 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (a b : M), a + b = ↑u → AddCommute a b → b + ↑(-u) + a = 0 | null | false |
CategoryTheory.Functor.IsStronglyCocartesian.map_isHomLift | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p : CategoryTheory.Functor 𝒳 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [inst_2 : p.IsStronglyCocartesian f φ]
{S' : 𝒮} {b' : 𝒳} {g : S ⟶ S'} {f' : R ⟶ S'} (hf' : f' = CategoryTheor... | null | true |
RingCat.limitRing._proof_45 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J RingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget RingCat)).sections],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
_private.Mathlib.Algebra.Order.Archimedean.Class.0.MulArchimedeanClass.orderHom_injective._simp_1_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a b : M},
(MulArchimedeanClass.mk a = MulArchimedeanClass.mk b) = ((∃ m, |b|ₘ ≤ |a|ₘ ^ m) ∧ ∃ n, |a|ₘ ≤ |b|ₘ ^ n) | null | false |
Sum.Lex.denselyOrdered_of_noMaxOrder | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [DenselyOrdered α] [DenselyOrdered β] [NoMaxOrder α],
DenselyOrdered (α ⊕ₗ β) | null | true |
Lean.Lsp.FileChangeType._sizeOf_inst | Lean.Data.Lsp.Workspace | SizeOf Lean.Lsp.FileChangeType | null | false |
Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty.elim | Mathlib.Tactic.NormNum.BigOperators | {u : Lean.Level} →
{α : Q(Type u)} →
{s : Q(Finset «$α»)} →
{motive : Mathlib.Meta.Finset.ProveEmptyOrConsResult s → Sort u} →
(t : Mathlib.Meta.Finset.ProveEmptyOrConsResult s) →
t.ctorIdx = 0 → ((pf : Q(«$s» = ∅)) → motive (Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty pf)) → motive t | null | false |
OrderAddMonoidHom.addCommute_inl_inr | Mathlib.Algebra.Order.Monoid.Lex | ∀ {α : Type u_1} {β : Type u_2} [inst : AddMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddMonoid β]
[inst_3 : Preorder β] (m : α) (n : β), AddCommute ((OrderAddMonoidHom.inl α β) m) ((OrderAddMonoidHom.inr α β) n) | null | true |
Subgroup.transferFocal.quotientKerMulEquivQuotientFocalSubroupOf._proof_1 | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] {p : ℕ} (P : Sylow p G), (↑P).focalSubgroupOf.Normal | null | false |
Std.DHashMap.Raw.getKey?_insert_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, (m.insert k v).getKey? k = some k | null | true |
_private.Mathlib.LinearAlgebra.ExteriorAlgebra.Basic.0.ExteriorAlgebra.map_injective.match_1_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u_3} [inst : CommRing R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f : M →ₗ[R] N} (motive : (∃ g, g ∘ₗ f = LinearMap.id) → Prop)
(hf : ∃ g, g ∘ₗ f = LinearMap.id), (∀ (w : N →ₗ[R] M) (hgf : w ∘ₗ f = LinearMap.id), motiv... | null | false |
sup_sdiff | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a ⊔ b) \ c = a \ c ⊔ b \ c | null | true |
_private.Lean.Meta.Coe.0.Lean.Meta.coerceSimple?.match_1 | Lean.Meta.Coe | (motive : Lean.LOption (Lean.Expr × List Lean.Name) → Sort u_1) →
(__do_lift : Lean.LOption (Lean.Expr × List Lean.Name)) →
((result : Lean.Expr) → (snd : List Lean.Name) → motive (Lean.LOption.some (result, snd))) →
(Unit → motive Lean.LOption.none) → (Unit → motive Lean.LOption.undef) → motive __do_lift | null | false |
AddActionSemiHomClass.mk | Mathlib.GroupTheory.GroupAction.Hom | ∀ {F : Type u_8} {M : outParam (Type u_9)} {N : outParam (Type u_10)} {φ : outParam (M → N)} {X : outParam (Type u_11)}
{Y : outParam (Type u_12)} [inst : VAdd M X] [inst_1 : VAdd N Y] [inst_2 : FunLike F X Y],
(∀ (f : F) (c : M) (x : X), f (c +ᵥ x) = φ c +ᵥ f x) → AddActionSemiHomClass F φ X Y | null | true |
Lean.Lsp.CompletionItemKind.enumMember | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionItemKind | null | true |
Filter.smul.instNeBot | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {f : Filter α} {g : Filter β} [f.NeBot] [g.NeBot], (f • g).NeBot | null | true |
Lean.Server.References.removeWorkerRefs | Lean.Server.References | Lean.Server.References → Lean.Name → Lean.Server.References | Erases all worker references in `self` for the worker managing `name`. | true |
_private.Mathlib.Geometry.Euclidean.Volume.Measure.0.MeasureTheory.Measure.euclideanHausdorffMeasure._proof_3 | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ (d : ℕ), Module.Finite ℝ (WithLp 2 (Fin d → ℝ)) | null | false |
Asymptotics.SuperpolynomialDecay.add | Mathlib.Analysis.Asymptotics.SuperpolynomialDecay | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {k f g : α → β} [inst : TopologicalSpace β] [inst_1 : CommSemiring β]
[ContinuousAdd β],
Asymptotics.SuperpolynomialDecay l k f →
Asymptotics.SuperpolynomialDecay l k g → Asymptotics.SuperpolynomialDecay l k (f + g) | null | true |
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.integral_isMulLeftInvariant_isMulRightInvariant_combo._simp_1_6 | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), (a ^ m) ^ n = a ^ (m * n) | null | false |
AddOpposite.instSubtractionMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubtractionMonoid α],
AddOpposite.instSubtractionMonoid =
{ toSubNegMonoid := AddOpposite.instSubNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯ } | null | true |
CategoryTheory.Functor.OplaxMonoidal.comp_δ | 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 |
_private.Lean.Parser.Term.0.Lean.Parser.Term.letMVar._regBuiltin.Lean.Parser.Term.letMVar_1 | Lean.Parser.Term | IO Unit | null | false |
Algebra.QuasiFinite.iff_finite_primesOver | Mathlib.RingTheory.QuasiFinite.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.FiniteType R S], Algebra.QuasiFinite R S ↔ ∀ (I : Ideal R), I.IsPrime → (I.primesOver S).Finite | null | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Basic.0.pow_succ_nonneg.match_1_1 | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
dist_vadd_left | Mathlib.Analysis.Normed.Group.AddTorsor | ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] (v : V) (x : P), dist (v +ᵥ x) x = ‖v‖ | null | true |
TopologicalSpace.CompactOpens.map | Mathlib.Topology.Sets.Compacts | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(f : α → β) → Continuous f → IsOpenMap f → TopologicalSpace.CompactOpens α → TopologicalSpace.CompactOpens β | The image of a compact open under a continuous open map. | true |
InfiniteGalois.isOpen_and_normal_iff_finite_and_isGalois | Mathlib.FieldTheory.Galois.Infinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] (L : IntermediateField k K)
[IsGalois k K], IsOpen L.fixingSubgroup.carrier ∧ L.fixingSubgroup.Normal ↔ FiniteDimensional k ↥L ∧ IsGalois k ↥L | null | true |
IsPrimitiveRoot.adjoinEquivRingOfIntegers_apply | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n) (a : ↥ℤ[ζ]),
hζ.adjoinEquivRingOfIntegers a = (IsIntegralClosure.lift ℤ (NumberField.RingOfIntegers K) K) a | null | true |
Std.Time.Formats.leanDateTimeWithIdentifierAndNanos | Std.Time.Format | Std.Time.GenericFormat Std.Time.Awareness.any | The leanDateTimeWithIdentifierAndNanos format, which follows the pattern `uuuu-MM-dd'T'HH:mm:ss.SSSSSSSSS'[z]'`
for representing date, time, and time zone. It uses the default value that can be parsed with the
notation of dates.
| true |
CategoryTheory.Abelian.SpectralObject.cyclesIso_inv_cyclesMap._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
Subgroup.quotientiInfSubgroupOfEmbedding._proof_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {ι : Type u_2} (f : ι → Subgroup α) (i : ι), iInf f ≤ f i | null | false |
EMetric.ball_disjoint | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε₁ ε₂ : ENNReal},
ε₁ + ε₂ ≤ edist x y → Disjoint (Metric.eball x ε₁) (Metric.eball y ε₂) | **Alias** of `Metric.eball_disjoint`. | true |
Std.DHashMap.Raw.size_alter_eq_sub_one | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
{k : α} {f : Option (β k) → Option (β k)},
m.WF → k ∈ m → (f (m.get? k)).isNone = true → (m.alter k f).size = m.size - 1 | null | true |
_private.Init.Data.Order.Lemmas.0.Std.instAssociativeMaxOfIsLinearOrderOfLawfulOrderMax._simp_1 | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : Max α] [inst_1 : LE α] [Std.LawfulOrderSup α] {a b c : α}, (a ⊔ b ≤ c) = (a ≤ c ∧ b ≤ c) | null | false |
Subtype.impEmbedding._proof_1 | Mathlib.Logic.Embedding.Basic | ∀ {α : Type u_1} (p q : α → Prop) (h : ∀ (x : α), p x → q x) (x y : { x // p x }),
(fun x => ⟨↑x, ⋯⟩) x = (fun x => ⟨↑x, ⋯⟩) y → x = y | null | false |
EquivLike.pairwise_comp_iff | Mathlib.Logic.Equiv.Pairwise | ∀ {X : Type u_1} {Y : Type u_2} {F : Sort u_3} [inst : EquivLike F Y X] (f : F) (p : X → X → Prop),
Pairwise (Function.onFun p ⇑f) ↔ Pairwise p | null | true |
LinearMap.BilinForm.baseChange_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ {R : Type uR} {A : Type uA} {M₂ : Type uM₂} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₂] [inst_3 : Algebra R A] [inst_4 : Module R M₂] [FaithfulSMul R A]
(B : LinearMap.BilinForm R M₂), (LinearMap.BilinForm.baseChange A B = 0) = (B = 0) | null | false |
le_mul_of_one_le_left' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : LE α] [MulRightMono α] {a b : α}, 1 ≤ b → a ≤ b * a | null | true |
ContinuousMapZero.toContinuousMapHom._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : IsTopologicalSemiring R], ↑0 = ↑0 | null | false |
_private.Mathlib.CategoryTheory.Sites.Hypercover.Zero.0.CategoryTheory.PreZeroHypercover.Hom.ext'_iff.match_1_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {S : C} {E : CategoryTheory.PreZeroHypercover S}
{F : CategoryTheory.PreZeroHypercover S} {f g : E.Hom F}
(motive :
(∃ (hs : f.s₀ = g.s₀),
∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)) →
... | null | false |
Ordinal.pred_le_self | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (o : Ordinal.{u_4}), o.pred ≤ o | null | true |
Std.LawfulEqOrd.compare_eq_iff_eq._simp_1 | Init.Data.Order.Ord | ∀ {α : Type u} [inst : Ord α] [Std.LawfulEqOrd α] {a b : α}, (compare a b = Ordering.eq) = (a = b) | null | false |
Squarefree.moebius_eq | Mathlib.RingTheory.UniqueFactorizationDomain.Moebius | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α},
Squarefree a → UniqueFactorizationMonoid.moebius a = (-1) ^ (UniqueFactorizationMonoid.factors a).card | null | true |
Semiquot.mem_pure._simp_1 | Mathlib.Data.Semiquot | ∀ {α : Type u_1} {a b : α}, (a ∈ pure b) = (a = b) | null | false |
Ordnode.Valid'.rotateL_lemma₁ | Mathlib.Data.Ordmap.Ordset | ∀ {a b c : ℕ}, 3 * a ≤ b + c → c ≤ 3 * b → a ≤ 3 * b | null | true |
Std.HashSet.Raw.WF.casesOn | Std.Data.HashSet.Raw | {α : Type u} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{m : Std.HashSet.Raw α} → {motive : m.WF → Sort u_1} → (t : m.WF) → ((out : m.inner.WF) → motive ⋯) → motive t | null | false |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor?._sparseCasesOn_5 | Lean.Meta.Tactic.Grind.PropagateInj | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
PNat.find_eq_one._simp_1 | Mathlib.Data.PNat.Find | ∀ {p : ℕ+ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), (PNat.find h = 1) = p 1 | null | false |
_private.Mathlib.Tactic.Simproc.ExistsAndEq.0.ExistsAndEq.withNestedExistsElim.match_1 | Mathlib.Tactic.Simproc.ExistsAndEq | (motive : List ExistsAndEq.VarQ → Sort u_1) →
(exs : List ExistsAndEq.VarQ) →
(Unit → motive []) →
((u : Lean.Level) → (β : Q(Sort u)) → (b : Q(«$β»)) → (tl : List ExistsAndEq.VarQ) → motive (⟨u, ⟨β, b⟩⟩ :: tl)) →
motive exs | null | false |
Polynomial.eval₂_homogenize_of_eq_one | Mathlib.Algebra.Polynomial.Homogenize | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] {p : Polynomial R} {n : ℕ},
p.natDegree ≤ n →
∀ (f : R →+* S) (g : Fin 2 → S), g 1 = 1 → MvPolynomial.eval₂ f g (p.homogenize n) = Polynomial.eval₂ f (g 0) p | null | true |
groupHomology.H0π_comp_map_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (x : ↑A),
(CategoryTheory.ConcreteCategory.hom (groupHomology.map f φ 0))
((CategoryTheory.ConcreteCategory.hom (groupHomology.H0π A)) x) =
(Categ... | null | true |
Configuration.HasPoints.lineCount_eq_pointCount | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} [inst : Membership P L] [Configuration.HasPoints P L] [inst_2 : Fintype P]
[inst_3 : Fintype L],
Fintype.card P = Fintype.card L →
∀ {p : P} {l : L}, p ∉ l → Configuration.lineCount L p = Configuration.pointCount P l | null | true |
Set.FiniteExhaustion._sizeOf_inst | Mathlib.Data.Set.FiniteExhaustion | {α : Type u_1} → (s : Set α) → [SizeOf α] → [(a : α) → SizeOf (s a)] → SizeOf s.FiniteExhaustion | null | false |
WeakPseudoEMetricSpace.mk.noConfusion | Mathlib.Topology.EMetricSpace.Defs | {α : Type u} →
{τ : TopologicalSpace α} →
{P : Sort u_1} →
{toEDist : EDist α} →
{edist_self : ∀ (x : α), edist x x = 0} →
{edist_comm : ∀ (x y : α), edist x y = edist y x} →
{edist_triangle : ∀ (x y z : α), edist x z ≤ edist x y + edist y z} →
{topology_le : (uni... | null | false |
MessageType.log.elim | Lean.Data.Lsp.Window | {motive : MessageType → Sort u} → (t : MessageType) → t.ctorIdx = 3 → motive MessageType.log → motive t | null | false |
Std.DHashMap.Internal.Raw₀.getKeyD_insertMany_emptyWithCapacity_list_of_contains_eq_false | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)} {k fallback : α},
(List.map Sigma.fst l).contains k = false →
(↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertMany l)).getKeyD k fallback = fallback | null | true |
_private.Mathlib.Algebra.Order.Group.Unbundled.Int.0.Int.ediv_eq_zero_of_lt_abs.match_1_1 | Mathlib.Algebra.Order.Group.Unbundled.Int | ∀ {a : ℤ} (motive : (b x : ℤ) → x = ↑b.natAbs → a < x → Prop) (b x : ℤ) (x_1 : x = ↑b.natAbs) (H2 : a < x),
(∀ (n : ℕ) (H2 : a < ↑(↑n).natAbs), motive (Int.ofNat n) ↑(↑n).natAbs ⋯ H2) →
(∀ (n : ℕ) (H2 : a < ↑(Int.negSucc n).natAbs), motive (Int.negSucc n) ↑(Int.negSucc n).natAbs ⋯ H2) →
motive b x x_1 H2 | null | false |
_private.Std.Data.TreeSet.Lemmas.0.Std.TreeSet.contains_toArray._simp_1_1 | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp}, t.toArray = t.toList.toArray | null | false |
IntermediateField.induction_on_adjoin | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] [FiniteDimensional F E]
(P : IntermediateField F E → Prop),
P ⊥ →
(∀ (K : IntermediateField F E) (x : E), P K → P (IntermediateField.restrictScalars F (↥K)⟮x⟯)) →
∀ (K : IntermediateField F E), P K | null | true |
Lean.Sym.UInt16.lt_eq_true | Init.Sym.Lemmas | ∀ (a b : UInt16), decide (a < b) = true → (a < b) = True | null | true |
AddSubmonoid.coe_multiset_sum | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_4} [inst : AddCommMonoid M] (S : AddSubmonoid M) (m : Multiset ↥S),
↑m.sum = (Multiset.map Subtype.val m).sum | null | true |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.Basic.0.irreducible_iff_prime_of_existsUnique_irreducible_factors.match_1_3 | Mathlib.RingTheory.UniqueFactorizationDomain.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (p : α) (fa fb : Multiset α)
(motive : (∃ b ∈ fa + fb, Associated p b) → Prop) (x : ∃ b ∈ fa + fb, Associated p b),
(∀ (q : α) (hqf : q ∈ fa + fb) (hq : Associated p q), motive ⋯) → motive x | null | false |
_private.Aesop.Frontend.Command.0.Aesop.Frontend.Parser._aux_Aesop_Frontend_Command___elabRules_Aesop_Frontend_Parser_addRules_1.match_1 | Aesop.Frontend.Command | (motive : Aesop.GlobalRuleSetMember × Array Aesop.RuleSetName → Sort u_1) →
(x : Aesop.GlobalRuleSetMember × Array Aesop.RuleSetName) →
((rule : Aesop.GlobalRuleSetMember) → (rsNames : Array Aesop.RuleSetName) → motive (rule, rsNames)) → motive x | null | false |
CategoryTheory.ObjectProperty.IsStrongGenerator.isDense_colimitsCardinalClosure_ι | Mathlib.CategoryTheory.Presentable.StrongGenerator | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular]
[CategoryTheory.Limits.HasColimitsOfSize.{w, w, v, u} C] [CategoryTheory.LocallySmall.{w, v, u} C]
{P : CategoryTheory.ObjectProperty C} [CategoryTheory.ObjectProperty.Small.{w, v, u} P],
P.IsStrongGenerator → ... | null | true |
Std.HashMap.Raw.getKey_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α} (h' : k ∈ m), m.getKey k h' = k | null | true |
AlgebraicGeometry.Scheme.basicOpen_restrict | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {V U : X.Opens} (i : V ⟶ U) (f : ↑(X.presheaf.obj (Opposite.op U))),
X.basicOpen (TopCat.Presheaf.restrict f i) ≤ X.basicOpen f | null | true |
DirectSum.toAddMonoid | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
[DecidableEq ι] →
{γ : Type u₁} → [inst_2 : AddCommMonoid γ] → ((i : ι) → β i →+ γ) → (DirectSum ι fun i => β i) →+ γ | `toAddMonoid φ` is the natural homomorphism from `⨁ i, β i` to `γ`
induced by a family `φ` of homomorphisms `β i → γ`. | true |
String.eq_append_of_dropPrefix?_prop_eq_some | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {P : Char → Prop} [inst : DecidablePred P] {s : String} {res : String.Slice},
s.dropPrefix? P = some res → ∃ c, s = String.singleton c ++ res.copy ∧ P c | null | true |
CategoryTheory.Limits.isTerminalEquivUnique._proof_8 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete PEmpty.{1}) C) (Y : C),
Function.LeftInverse (fun u => { lift := fun s => default, fac := ⋯, uniq := ⋯ }) fun t X =>
{
default :=
t.lift
{ pt := X,
π := { app :... | null | false |
Sigma.Lex.boundedOrder | Mathlib.Data.Sigma.Order | {ι : Type u_1} →
{α : ι → Type u_2} →
[inst : PartialOrder ι] →
[inst_1 : BoundedOrder ι] →
[inst_2 : (i : ι) → Preorder (α i)] → [OrderBot (α ⊥)] → [OrderTop (α ⊤)] → BoundedOrder (Σₗ (i : ι), α i) | The lexicographical linear order on a sigma type. | true |
CategoryTheory.Pretriangulated.instHasFiniteCoproducts | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
CategoryTheory.Limits.H... | null | true |
Representation.finsuppLEquivFreeAsModule._proof_4 | Mathlib.RepresentationTheory.Basic | ∀ (k : Type u_1) (G : Type u_2) [inst : CommSemiring k] [inst_1 : Monoid G] (α : Type u_3),
Function.LeftInverse (AddEquiv.refl (α →₀ MonoidAlgebra k G)).invFun (AddEquiv.refl (α →₀ MonoidAlgebra k G)).toFun | null | false |
Std.DTreeMap.Const.getKey?_insertMany_list_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
k ∈ List.map Prod.fst l → (Std.DTreeMap.Const.insertMany t l).getKey? k' = some k | null | true |
ProbabilityTheory.complexMGF_id_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (z : ℂ),
ProbabilityTheory.complexMGF id (ProbabilityTheory.gaussianReal μ v) z = Complex.exp (z * ↑μ + ↑↑v * z ^ 2 / 2) | The complex moment-generating function of a Gaussian distribution with mean `μ` and variance `v`
is given by `z ↦ exp (z * μ + v * z ^ 2 / 2)`. | true |
intervalIntegral.measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_le | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {ι : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a : ℝ} {c : E}
{l l' : Filter ℝ} {lt : Filter ι} {μ : MeasureTheory.Measure ℝ} {u v : ι → ℝ} [MeasureTheory.IsLocallyFiniteMeasure μ]
[CompleteSpace E] [intervalIntegral.FTCFilter a l l'],
StronglyMeasurableAtFil... | **Fundamental theorem of calculus-1**, local version for any measure.
Let filters `l` and `l'` be related by `[intervalIntegral.FTCFilter a l l']`; let `μ` be a locally
finite measure. If `f` has a finite limit `c` at `l' ⊓ ae μ`, then
`∫ x in u..v, f x ∂μ = μ (Ioc u v) • c + o(μ(Ioc u v))` as both `u` and `v` tend t... | true |
CategoryTheory.LocalizerMorphism.inv_functor | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂)
[inst_2 : Φ.functor.IsEquivalence] [inst_3 : Φ.IsInduced] [in... | null | true |
TopCat.Presheaf.EtaleSpace.homeomorph._proof_5 | Mathlib.Topology.Sheaves.EtaleSpace | ∀ {X : TopCat} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {CC : C → Type u_1} {FC : C → C → Type u_3}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[inst_3 : CategoryTheory.Limits.HasColimits C] {F : TopCat.Presheaf C X} (U : TopologicalSpace... | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.isValidRevSearchFrom_iff_isValidRevSearchFrom_beq._simp_1_3 | Init.Data.String.Lemmas.Pattern.Char | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice}
{l : List (String.Slice.Pattern.SearchStep s)} {startPos endPos : s.Pos},
startPos < endPos →
(∀ (pos : s.Pos), startPos < pos → pos ≤ endPos → ¬String.Slice.Pattern.Model.RevMatchesAt pat pos) →
String.Slice.Pa... | null | false |
Matroid.freeOn.eq_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (E : Set α), Matroid.freeOn E = (Matroid.loopyOn E)✶ | null | true |
Std.DTreeMap.Internal.Cell.ofOption | Std.Data.DTreeMap.Internal.Cell | {α : Type u} → {β : α → Type v} → [inst : Ord α] → (k : α) → Option (β k) → Std.DTreeMap.Internal.Cell α β (compare k) | Internal implementation detail of the tree map | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems.isErased | Lean.Elab.Tactic.Do.Attr | Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems → Lean.Elab.Tactic.Do.SpecAttr.SpecProof → Bool | null | true |
Order.Ideal.PrimePair.I_isPrime | Mathlib.Order.PrimeIdeal | ∀ {P : Type u_1} [inst : Preorder P] (IF : Order.Ideal.PrimePair P), IF.I.IsPrime | null | true |
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.exists_linearEquiv_eq_graph._simp_1_2 | Mathlib.LinearAlgebra.Prod | ∀ {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₂} {x : M₂}, (x ∈ f.range) = ∃ y, f y = x | null | false |
ENat.WithBot.add_le_add_one_left_iff | Mathlib.Data.ENat.Basic | ∀ {a b : WithBot ℕ∞}, 1 + a ≤ 1 + b ↔ a ≤ b | null | true |
RBTree.RBNode.isOrdered_iff' | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {L R : Option α} [Std.TransCmp cmp] {t : RBTree.RBNode α},
RBTree.RBNode.isOrdered cmp t L R = true ↔
(∀ a ∈ L, RBTree.RBNode.All (fun x => RBTree.RBNode.cmpLT cmp a x) t) ∧
(∀ a ∈ R, RBTree.RBNode.All (fun x => RBTree.RBNode.cmpLT cmp x a) t) ∧
(∀ a ∈ L, ∀ ... | null | true |
Ring.instAddCommMonoidDirectLimit._aux_1 | Mathlib.Algebra.Colimit.Ring | {ι : Type u_1} →
[inst : Preorder ι] →
(G : ι → Type u_2) →
[inst_1 : (i : ι) → CommRing (G i)] →
(f : (i j : ι) → i ≤ j → G i → G j) → Ring.DirectLimit G f → Ring.DirectLimit G f → Ring.DirectLimit G f | null | false |
PSigma.Lex.preorder._proof_4 | Mathlib.Data.PSigma.Order | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : Preorder ι] [inst_1 : (i : ι) → Preorder (α i)] (a b : Σₗ' (i : ι), α i),
a < b ↔ a ≤ b ∧ ¬b ≤ a | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
«command#long_names_» | Mathlib.Util.LongNames | Lean.ParserDescr | Lists all declarations with a long name, gathered according to the module they are defined in.
Use as `#long_names` or `#long_names 100` to specify the length.
| true |
OrderedFinpartition.eraseMiddle._proof_11 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (hc : Set.range (c.emb 0) ≠ {0}) (i j : Fin c.length),
i < j →
(fun m =>
if h : m = c.index 0 then
(c.emb m
(Fin.cast ⋯ ⟨Function.update c.partSize (c.index 0) (c.partSize (c.index 0) - 1) m - 1, ⋯⟩.succ)).pred
⋯
... | null | false |
Pi.mulZeroOneClass._proof_2 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroOneClass (α i)] (a : (i : ι) → α i), a * 1 = a | null | false |
IsStronglyTranscendental.iff_of_isLocalization | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] {M : Submonoid S},
M ≤ nonZeroDivisors S →
∀ [IsLocalization M T] [IsScalarTower R S T] {x : S},
IsStronglyTranscendental R ((... | null | true |
CommBialgCat.Hom | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} → [inst : CommRing R] → CommBialgCat R → CommBialgCat R → Type v | The type of morphisms in `CommBialgCat R`. | true |
Sub.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : Sub α} → {α' : Type u} → {t' : Sub α'} → α = α' → t ≍ t' → Sub.noConfusionType P t t' | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.