name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
exists_ne_mem_inter_of_not_pairwise_disjoint | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {ι : Type u_4} {f : ι → Set α},
¬Pairwise (Function.onFun Disjoint f) → ∃ i j, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j | null | true |
apply_wcovBy_apply_iff._simp_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {a b : α} {E : Type u_3}
[inst_2 : EquivLike E α β] [OrderIsoClass E α β] (e : E), (e a ⩿ e b) = (a ⩿ b) | null | false |
Std.DTreeMap.Equiv.getEntryGT_eq.match_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₁ : Std.DTreeMap α β cmp} {k : α} (x : α)
(motive : x ∈ t₁ ∧ cmp x k = Ordering.gt → Prop) (x_1 : x ∈ t₁ ∧ cmp x k = Ordering.gt),
(∀ (h₁ : x ∈ t₁) (h₂ : cmp x k = Ordering.gt), motive ⋯) → motive x_1 | null | false |
LSeries.term_sum_apply | Mathlib.NumberTheory.LSeries.Linearity | ∀ {ι : Type u_1} (f : ι → ℕ → ℂ) (S : Finset ι) (s : ℂ) (n : ℕ),
LSeries.term (∑ i ∈ S, f i) s n = ∑ i ∈ S, LSeries.term (f i) s n | null | true |
CommGroupWithZero.toGroupWithZero | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} → [self : CommGroupWithZero G₀] → GroupWithZero G₀ | null | true |
Lean.Grind.CommRing.Mon.sharesVar._unary | Lean.Meta.Sym.Arith.Poly | (_ : Lean.Grind.CommRing.Mon) ×' Lean.Grind.CommRing.Mon → Bool | `sharesVar m₁ m₂` returns `true` if `m₁` and `m₂` shares at least one variable. | false |
Aesop.NormalizationState.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.NormalizationState} → t = t' → Aesop.NormalizationState.noConfusionType P t t' | null | false |
Std.TreeMap.contains_emptyc | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {k : α}, ∅.contains k = false | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.SafePoly.0.Lean.Grind.CommRing.Poly.simpM?.go?.match_3 | Lean.Meta.Tactic.Grind.Arith.CommRing.SafePoly | (motive : Lean.Grind.CommRing.Poly → Sort u_1) →
(p₁ : Lean.Grind.CommRing.Poly) →
((k₁' : ℤ) →
(m₁ : Lean.Grind.CommRing.Mon) →
(p₁ : Lean.Grind.CommRing.Poly) → motive (Lean.Grind.CommRing.Poly.add k₁' m₁ p₁)) →
((k : ℤ) → motive (Lean.Grind.CommRing.Poly.num k)) → motive p₁ | null | false |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.insertMany._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {β : Type u_2} {ρ : Type u_3} [inst : ForIn Id ρ (α × β)]
(m : Std.DHashMap α fun x => β) (l : ρ), (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany ⟨m.inner, ⋯⟩ l)).WF | null | false |
CategoryTheory.CopyDiscardCategory.copy_tensor | Mathlib.CategoryTheory.CopyDiscardCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.CopyDiscardCategory C] (X Y : C),
CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.ComonObj.comul C... | Tensor products of copies equal copies of tensor products. | true |
Lean.Meta.Try.collect | Lean.Meta.Tactic.Try.Collect | Lean.MVarId → Lean.Try.Config → Lean.MetaM Lean.Meta.Try.Info | null | true |
MeasureTheory.SimpleFunc.noConfusionType | Mathlib.MeasureTheory.Function.SimpleFunc | Sort u_1 →
{α : Type u} →
[inst : MeasurableSpace α] →
{β : Type v} →
MeasureTheory.SimpleFunc α β →
{α' : Type u} → [inst' : MeasurableSpace α'] → {β' : Type v} → MeasureTheory.SimpleFunc α' β' → Sort u_1 | null | false |
Topology.WithLowerSet.toLowerSet_symm | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1}, Topology.WithLowerSet.toLowerSet.symm = Topology.WithLowerSet.ofLowerSet | null | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doHave._regBuiltin.Lean.Parser.Term.doHave.parenthesizer_11 | Lean.Parser.Do | IO Unit | null | false |
NonUnitalSubalgebra.iSupLift._proof_4 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {ι : Sort u_3} [Nonempty ι]
(K : ι → NonUnitalSubalgebra R A), Directed (fun x1 x2 => x1 ≤ x2) K → ↑(iSup K) ⊆ ⋃ i, ↑(K i) | null | false |
Std.ExtDTreeMap.eq_empty_iff_size_eq_zero | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
t = ∅ ↔ t.size = 0 | null | true |
curveIntegralFun_symm | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {a b : E} (ω : E → E →L[𝕜] F)
(γ : Path a b), curveIntegralFun ω γ.symm = fun x => (-curveIntegralFun ω γ) (1 - x) | null | true |
Nat.mul_ne_mul_left | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, a ≠ 0 → (b * a ≠ c * a ↔ b ≠ c) | null | true |
GradedRingHom.map_one | Mathlib.RingTheory.GradedAlgebra.RingHom | ∀ {ι : Type u_1} {A : Type u_2} {B : Type u_3} {σ : Type u_6} {τ : Type u_7} [inst : Semiring A] [inst_1 : Semiring B]
[inst_2 : SetLike σ A] [inst_3 : SetLike τ B] {𝒜 : ι → σ} {ℬ : ι → τ} (f : 𝒜 →+*ᵍ ℬ), f 1 = 1 | Graded ring homomorphisms map one to one. | true |
Multiset.ssubset_singleton_iff | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α} {a : α}, s ⊂ {a} ↔ s = 0 | null | true |
CategoryTheory.Bicategory.Adj.forget₁._proof_7 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : CategoryTheory.Bicategory.Adj B} {f g : a ⟶ b}
(η : f ⟶ g) (h : b ⟶ c),
(CategoryTheory.Bicategory.whiskerRight η h).τl =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl (CategoryTheory.CategoryStruct.comp f h).l).hom
(CategoryTheo... | null | false |
UpperSet.completeLattice | Mathlib.Order.UpperLower.CompleteLattice | {α : Type u_1} → [inst : LE α] → CompleteLattice (UpperSet α) | null | true |
QuotientGroup.dense_preimage_mk._simp_2 | Mathlib.Topology.Algebra.Group.Quotient | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [SeparatelyContinuousMul G] {N : Subgroup G}
{s : Set (G ⧸ N)}, Dense (QuotientGroup.mk ⁻¹' s) = Dense s | null | false |
NonarchAddGroupSeminorm.instZero._proof_3 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (x : E), 0 (-x) = 0 (-x) | null | false |
OpenPartialHomeomorph.extend_image_nhds_mem_nhds_of_boundaryless | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} [I.Boundaryless] {x : M},
x ∈ f.s... | null | true |
Std.Iter.toList_zip_of_finite_right | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ α₂ β₁ β₂ : Type u_1} [inst : Std.Iterator α₁ Id β₁] [inst_1 : Std.Iterator α₂ Id β₂] {it₁ : Std.Iter β₁}
{it₂ : Std.Iter β₂} [Std.Iterators.Productive α₁ Id] [Std.Iterators.Finite α₂ Id],
(it₁.zip it₂).toList = (Std.Iter.take it₂.toList.length it₁).toList.zip it₂.toList | null | true |
Set.BijOn.surjOn | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.BijOn f s t → Set.SurjOn f s t | null | true |
MeasureTheory.Measure.FiniteAtFilter | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} → {_m0 : MeasurableSpace α} → MeasureTheory.Measure α → Filter α → Prop | A measure is called finite at filter `f` if it is finite at some set `s ∈ f`.
Equivalently, it is eventually finite at `s` in `f.small_sets`. | true |
_private.Mathlib.GroupTheory.OrderOfElement.0.mem_zpowers_zpow_iff._simp_1_4 | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (∃ c, b = a * c) = (a ∣ b) | null | false |
Lean.Meta.Grind.EMatchTheoremKind.leftRight.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | sizeOf Lean.Meta.Grind.EMatchTheoremKind.leftRight = 1 | null | true |
FiniteDimensional.basisSingleton._proof_5 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u_1} [inst : DivisionRing K], StrongRankCondition K | null | false |
Lean.Parser.nameLitFn | Lean.Parser.Basic | Lean.Parser.ParserFn | null | true |
QuaternionAlgebra.instRing._proof_3 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : CommRing R] (x : QuaternionAlgebra R c₁ c₂ c₃), x * 1 = x | null | false |
ConditionallyCompletePartialOrderInf.isGLB_csInf_of_directed | Mathlib.Order.ConditionallyCompletePartialOrder.Defs | ∀ {α : Type u_3} [self : ConditionallyCompletePartialOrderInf α] (s : Set α),
DirectedOn (fun x1 x2 => x1 ≥ x2) s → s.Nonempty → BddBelow s → IsGLB s (sInf s) | For each nonempty, directed set `s` which is bounded below, `sInf s` is
the greatest lower bound of `s`. | true |
MulAction.is_one_pretransitive_iff | Mathlib.GroupTheory.GroupAction.MultipleTransitivity | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α],
MulAction.IsMultiplyPretransitive G α 1 ↔ MulAction.IsPretransitive G α | An action is `1`-pretransitive iff it is pretransitive. | true |
CategoryTheory.Endofunctor.Algebra.Hom.mk.inj | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {F : CategoryTheory.Functor C C}
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} {f : A₀.a ⟶ A₁.a}
{h :
autoParam (CategoryTheory.CategoryStruct.comp (F.map f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str f)
CategoryTheory.Endofunctor.Algebra.H... | null | true |
ContinuousMap.inv_apply | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Inv β]
[inst_3 : ContinuousInv β] (f : C(α, β)) (x : α), f⁻¹ x = (f x)⁻¹ | null | true |
CategoryTheory.Limits.PushoutCocone.ofCocone | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor CategoryTheory.Limits.WalkingSpan C} →
CategoryTheory.Limits.Cocone F →
CategoryTheory.Limits.PushoutCocone (F.map CategoryTheory.Limits.WalkingSpan.Hom.fst)
(F.map CategoryTheory.Limits.WalkingSpan.Hom.... | Given `F : WalkingSpan ⥤ C`, which is really the same as `span (F.map fst) (F.map snd)`,
and a cocone on `F`, we get a pushout cocone on `F.map fst` and `F.map snd`. | true |
_private.Init.Data.List.Nat.TakeDrop.0.List.take_set_of_le._proof_1_1 | Init.Data.List.Nat.TakeDrop | ∀ {i j : ℕ}, j ≤ i → ∀ i_1 < j, i = i_1 → False | null | false |
LaurentSeries.coe_range_dense | Mathlib.RingTheory.LaurentSeries | ∀ {K : Type u_2} [inst : Field K], DenseRange ⇑(algebraMap (RatFunc K) (LaurentSeries K)) | null | true |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.isCyclotomicExtension_iff_eq_adjoin._simp_1_9 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Lists.Subset.decidable.match_1 | Mathlib.SetTheory.Lists | {α : Type u_1} →
(motive : Lists' α true → Lists' α true → Sort u_2) →
(x x_1 : Lists' α true) →
((x : Lists' α true) → motive Lists'.nil x) →
((b : Bool) → (a : Lists' α b) → (l₁ l₂ : Lists' α true) → motive (a.cons' l₁) l₂) → motive x x_1 | null | false |
WeierstrassCurve.Projective.addY_of_X_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P Q : Fin 3 → F},
W.Equation P →
W.Equation Q → P 2 ≠ 0 → Q 2 ≠ 0 → P 0 * Q 2 = Q 0 * P 2 → W.addY P Q = WeierstrassCurve.Projective.addU P Q | null | true |
MeasureTheory.hittingBtwn.eq_1 | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Preorder ι] [inst_1 : InfSet ι] (u : ι → Ω → β) (s : Set β)
(n m : ι) (x : Ω),
MeasureTheory.hittingBtwn u s n m x = if ∃ j ∈ Set.Icc n m, u j x ∈ s then sInf (Set.Icc n m ∩ {i | u i x ∈ s}) else m | null | true |
CategoryTheory.Functor.Faithful.mapMon | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {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]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] [F.Faithful], F.mapMon.Faithful | null | true |
Unique.rec | Mathlib.Logic.Unique | {α : Sort u} →
{motive : Unique α → Sort u_1} →
((toInhabited : Inhabited α) →
(uniq : ∀ (a : α), a = default) → motive { toInhabited := toInhabited, uniq := uniq }) →
(t : Unique α) → motive t | null | false |
Finset.inv_subset_inv | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Inv α] {s t : Finset α}, s ⊆ t → s⁻¹ ⊆ t⁻¹ | null | true |
Algebra.Extension.tensorCotangentInvFun._proof_5 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] {P : Algebra.Extension R S} {Q : Algebra.Extension R T}
[alg : Algebra P.Ring Q.Ring], IsScalarTower P.Ring Q.Ring ↥Q.ker | null | false |
List.get_length_sub_one._proof_1 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {l : List α}, l.length - 1 < l.length → l ≠ [] | null | false |
groupHomology.coinfNatTrans._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ (k : Type u_1) {G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal] (n : ℕ)
{X Y : Rep.{u_1, u_1, u_1} k G} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((groupHomology.functor k G n).map φ)
(groupHomology.map (QuotientGroup.mk' S) (Y.toCoinvariantsMkQ S) n) =
Ca... | null | false |
Nat.odd_mul_odd_div_two | Mathlib.Data.Nat.ModEq | ∀ {m n : ℕ}, m % 2 = 1 → n % 2 = 1 → m * n / 2 = m * (n / 2) + m / 2 | null | true |
OrderIso.sumLexIicIoi | Mathlib.Order.Hom.Lex | {α : Type u_1} → [inst : LinearOrder α] → (x : α) → ↑(Set.Iic x) ⊕ₗ ↑(Set.Ioi x) ≃o α | A linear order is isomorphic to the lexicographic sum of elements less or equal to `x` and
elements greater than `x`. | true |
Std.DHashMap.Internal.Raw₀.insertListₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[BEq α] → [Hashable α] → Std.DHashMap.Internal.Raw₀ α β → List ((a : α) × β a) → Std.DHashMap.Internal.Raw₀ α β | Internal implementation detail of the hash map | true |
fderiv_fun_smul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {𝕜' : Type u_5} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module ... | null | true |
Computability.encodingNatBool | Mathlib.Computability.Encoding | Computability.Encoding ℕ | A binary `Encoding` of `ℕ` in `Bool`. | true |
Std.Do.Spec.modifyGet_StateT | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {σ α : Type u} {f : σ → α × σ}
{Q : Std.Do.PostCond α (Std.Do.PostShape.arg σ ps)} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps],
⦃fun s =>
have t := f s;
Q.1 t.1 t.2⦄
MonadStateOf.modifyGet f ⦃Q⦄ | null | true |
PartOrdEmb.instConcreteCategoryOrderEmbeddingCarrier._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ {X Y : PartOrdEmb} (f : ↑X ↪o ↑Y), { hom' := f }.hom' = f | null | false |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_56 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x head : α) (tail : List α),
¬([(head :: tail).getLast ⋯] ++ [x]).dropLast.isEmpty = true → ([(head :: tail).getLast ⋯] ++ [x]).dropLast ≠ [] | null | false |
Lean.VersoModuleDocs.snippets | Lean.DocString.Extension | Lean.VersoModuleDocs → Lean.PersistentArray Lean.VersoModuleDocs.Snippet | null | true |
CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)} (hS : S.IsComplex) (k : ℕ)
(hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac._auto_1)
[inst_2 : (S.sc hS k... | null | true |
Std.Time.instHSubOffsetOffset_22 | Std.Time.Date.Basic | HSub Std.Time.Minute.Offset Std.Time.Day.Offset Std.Time.Minute.Offset | null | true |
instMulPosMonoWithZeroOfMulRightMono | Mathlib.Algebra.Order.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α] [MulRightMono α], MulPosMono (WithZero α) | null | true |
CFC.nnrpow_two | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : NonUnitalRing A] [inst_2 : TopologicalSpace A] [inst_3 : StarRing A]
[inst_4 : Module ℝ A] [inst_5 : SMulCommClass ℝ A A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : StarOrderedRing A]
[inst_8 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_9 : Nonneg... | null | true |
Std.ExtDHashMap.instInsertSigmaOfEquivBEqOfLawfulHashable.match_1 | Std.Data.ExtDHashMap.Basic | {α : Type u_1} →
{β : α → Type u_2} →
{x : BEq α} →
{x_1 : Hashable α} →
(motive : (a : α) × β a → Std.ExtDHashMap α β → Sort u_3) →
(x_2 : (a : α) × β a) →
(x_3 : Std.ExtDHashMap α β) →
((a : α) → (b : β a) → (s : Std.ExtDHashMap α β) → motive ⟨a, b⟩ s) → motive ... | null | false |
CategoryTheory.StructuredArrow.eta_hom_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : D} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T),
f.eta.hom.right = CategoryTheory.CategoryStruct.id f.right | null | true |
Real.cos_sub_nat_mul_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℕ), Real.cos (x - ↑n * Real.pi) = (-1) ^ n * Real.cos x | null | true |
_private.Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots.0.instFieldAdjoinPthRoots._aux_37 | Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots | (k : Type u_1) → [Field k] → ℤ → AdjoinPthRoots k → AdjoinPthRoots k | null | false |
CategoryTheory.Oplax.OplaxTrans.vcomp._proof_5 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.OplaxFunctor B C} (η : CategoryTheory.Oplax.OplaxTrans F G)
(θ : CategoryTheory.Oplax.OplaxTrans G H) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(C... | null | false |
ProofWidgets.CheckRequestResponse.done | ProofWidgets.Cancellable | ProofWidgets.LazyEncodable Lean.Json → ProofWidgets.CheckRequestResponse | null | true |
BinaryTree.node.sizeOf_spec | Mathlib.Data.Tree.Basic | ∀ {α : Type u} [inst : SizeOf α] (value : α) (left right : BinaryTree α),
sizeOf (BinaryTree.node value left right) = 1 + sizeOf value + sizeOf left + sizeOf right | null | true |
Set.card_image_of_inj_on | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {β : Type v} {s : Set α} [inst : Fintype ↑s] {f : α → β} [inst_1 : Fintype ↑(f '' s)],
(∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y) → Fintype.card ↑(f '' s) = Fintype.card ↑s | null | true |
HasStrictFDerivAt.snd | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {f₂ : E → F × G} {f₂' : E →L[... | null | true |
Vector.set_eraseIdx._proof_2 | Init.Data.Vector.Erase | ∀ {n i : ℕ} {w : i < n} {j : ℕ}, ¬i ≤ j → j < n | null | false |
Antitone.iSup_comp_tendsto_atBot | Mathlib.Order.Filter.AtTopBot.CompleteLattice | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : ConditionallyCompleteLattice γ]
[OrderTop γ] {l : Filter α} [l.NeBot] {f : β → γ},
Antitone f → ∀ {g : α → β}, Filter.Tendsto g l Filter.atBot → ⨆ a, f (g a) = ⨆ b, f b | If `f` is an antitone function taking values in a complete lattice
and `g` tends to `atBot` along a nontrivial filter,
then the indexed supremum of `f ∘ g` is equal to the indexed supremum of `f`. | true |
Rack.PreEnvelGroupRel'._sizeOf_inst | Mathlib.Algebra.Quandle | (R : Type u) → {inst : Rack R} → (a a_1 : Rack.PreEnvelGroup R) → [SizeOf R] → SizeOf (Rack.PreEnvelGroupRel' R a a_1) | null | false |
CategoryTheory.Mat.instAddCommGroupHom | Mathlib.CategoryTheory.Preadditive.Mat | (R : Type) → [inst : Ring R] → (X Y : CategoryTheory.Mat R) → AddCommGroup (X ⟶ Y) | null | true |
RingQuot.ringQuot_ext | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Semiring R] {T : Type uT} [inst_1 : NonAssocSemiring T] {r : R → R → Prop}
(f g : RingQuot r →+* T), f.comp (RingQuot.mkRingHom r) = g.comp (RingQuot.mkRingHom r) → f = g | null | true |
_private.Batteries.Tactic.Alias.0.Batteries.Tactic.Alias.AliasInfo.name.match_1 | Batteries.Tactic.Alias | (motive : Batteries.Tactic.Alias.AliasInfo → Sort u_1) →
(x : Batteries.Tactic.Alias.AliasInfo) →
((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasInfo.plain n)) →
((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasInfo.forward n)) →
((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasI... | null | false |
IsLocalization.height_comap | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {A : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[IsLocalization S A] (J : Ideal A), (Ideal.under R J).height = J.height | **Alias** of `IsLocalization.height_under`. | true |
Int.instIsCancelMulZero | Mathlib.Algebra.Ring.Int.Defs | IsCancelMulZero ℤ | null | true |
_private.Mathlib.CategoryTheory.PathCategory.MorphismProperty.0.CategoryTheory.MorphismProperty.instIsMultiplicativeStrictMapPathsPathsPathComposition.match_1 | Mathlib.CategoryTheory.PathCategory.MorphismProperty | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (W : CategoryTheory.MorphismProperty C) {X Y Z : C}
(f : X ⟶ Y) (motive : (x : Y ⟶ Z) → W.paths.strictMap (CategoryTheory.pathComposition C) x → Prop) (x : Y ⟶ Z)
(x_1 : W.paths.strictMap (CategoryTheory.pathComposition C) x),
(∀ (f : Y ⟶ Z) (hq : W.p... | null | false |
_private.Mathlib.Data.Set.Image.0.Set.image_singleton._proof_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_2} {β : Type u_1} {f : α → β} {a : α}, f '' {a} = {f a} | null | false |
AlgebraicGeometry.isIso_ΓSpec_adjunction_unit_app_basicOpen | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X : AlgebraicGeometry.Scheme} [CompactSpace ↥X] [QuasiSeparatedSpace ↥X] (f : ↑(X.presheaf.obj (Opposite.op ⊤))),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.app X.toSpecΓ (PrimeSpectrum.basicOpen f)) | If `U` is qcqs, then `Γ(X, D(f)) ≃ Γ(X, U)_f` for every `f : Γ(X, U)`.
This is known as the **Qcqs lemma** in [R. Vakil, *The rising sea*][RisingSea]. | true |
_private.Mathlib.NumberTheory.Padics.ProperSpace.0.PadicInt.totallyBounded_univ._simp_1_3 | Mathlib.NumberTheory.Padics.ProperSpace | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | null | false |
RingEquiv.toNonUnitalRingHom_trans | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} {S' : Type u_6} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring S'] (e₁ : R ≃+* S) (e₂ : S ≃+* S'),
(e₁.trans e₂).toNonUnitalRingHom = e₂.toNonUnitalRingHom.comp e₁.toNonUnitalRingHom | null | true |
AddSubgroup.single_mem_pi._simp_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → AddGroup (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → AddSubgroup (f i)} (i : η) (x : f i), (Pi.single i x ∈ AddSubgroup.pi I H) = (i ∈ I → x ∈ H i) | null | false |
_private.Mathlib.Combinatorics.Matroid.Dual.0.Matroid.IsBase.compl_inter_isBasis_of_inter_isBasis._simp_1_2 | Mathlib.Combinatorics.Matroid.Dual | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
HomologicalComplex.homologyι | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{ι : Type u_2} →
{c : ComplexShape ι} →
(K : HomologicalComplex C c) → (i : ι) → [inst_2 : K.HasHomology i] → K.homology i ⟶ K.opcycles i | The inclusion map of the homology of a homological complex into its opcycles. | true |
Lean.Parser.«_aux_Init_Simproc___macroRules_Lean_Parser_command__Simproc__[_]_(_):=__1» | Init.Simproc | Lean.Macro | null | false |
Nat.exists_subseq_of_forall_mem_union | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {s t : Set α} (e : ℕ → α),
(∀ (n : ℕ), e n ∈ s ∪ t) → ∃ g, (∀ (n : ℕ), e (g n) ∈ s) ∨ ∀ (n : ℕ), e (g n) ∈ t | null | true |
QuaternionAlgebra.instNeg | Mathlib.Algebra.Quaternion | {R : Type u_3} → {c₁ c₂ c₃ : R} → [Neg R] → Neg (QuaternionAlgebra R c₁ c₂ c₃) | null | true |
CompleteSublattice.subtype_apply | Mathlib.Order.CompleteSublattice | ∀ {α : Type u_1} [inst : CompleteLattice α] (L : Sublattice α) (a : ↥L), L.subtype a = ↑a | null | true |
CategoryTheory.FreeMonoidalCategory.Hom.l_inv | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} → (X : CategoryTheory.FreeMonoidalCategory C) → X.Hom (CategoryTheory.FreeMonoidalCategory.unit.tensor X) | null | true |
NonarchAddGroupSeminorm.add_bddBelow_range_add | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddCommGroup E] {p q : NonarchAddGroupSeminorm E} {x : E},
BddBelow (Set.range fun y => p y + q (x - y)) | null | true |
ProbabilityTheory.Kernel.ext_fun_iff | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β},
κ = η ↔ ∀ (a : α) (f : β → ENNReal), Measurable f → ∫⁻ (b : β), f b ∂κ a = ∫⁻ (b : β), f b ∂η a | null | true |
strictConvexOn_rpow | Mathlib.Analysis.Convex.SpecificFunctions.Basic | ∀ {p : ℝ}, 1 < p → StrictConvexOn ℝ (Set.Ici 0) fun x => x ^ p | For `p : ℝ` with `1 < p`, `fun x ↦ x ^ p` is strictly convex on $[0, +∞)$. | true |
BitVec.extractLsb'_eq_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {start : ℕ}, BitVec.extractLsb' start 0 x = 0#0 | null | true |
RightCancelMonoid | Mathlib.Algebra.Group.Defs | Type u → Type u | A monoid in which multiplication is right-cancellative. | true |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.normNumPositivity._proof_1 | Mathlib.Tactic.Positivity.Core | ∀ {u : Lean.Level} {α : Q(Type u)} (zα : Q(Zero «$α»)) (_a : Q(Semiring «$α»)),
«$zα» =Q instMulZeroClassOfSemiring.toZero | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.