name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AddSubmonoid.pi_mem_of_single_mem_aux | Mathlib.Algebra.Group.Submonoid.Finite | ∀ {η : Type u_1} {f : η → Type u_2} [inst : (i : η) → AddZeroClass (f i)] {S : Type u_3}
[inst_1 : SetLike S ((i : η) → f i)] [AddSubmonoidClass S ((i : η) → f i)] [inst_3 : DecidableEq η] (I : Finset η)
{H : S} (x : (i : η) → f i), (∀ i ∉ I, x i = 0) → (∀ i ∈ I, Pi.single i (x i) ∈ H) → x ∈ H | true |
IsCyclotomicExtension.norm_zeta_sub_one_of_isPrimePow | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {n : ℕ} [inst : NeZero n] {K : Type u} (L : Type v) [inst_1 : Field K] [inst_2 : Field L] [inst_3 : Algebra K L],
IsPrimePow n →
∀ [inst_4 : IsCyclotomicExtension {n} K L],
Irreducible (Polynomial.cyclotomic n K) →
n ≠ 2 → (Algebra.norm K) (IsCyclotomicExtension.zeta n K L - 1) = ↑n.minFac | true |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction.0.UpperHalfPlane.denom_cocycle'._simp_1_4 | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
Std.ExtDTreeMap.Const.get?_modify_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp}
{k : α} {f : β → β},
Std.ExtDTreeMap.Const.get? (Std.ExtDTreeMap.Const.modify t k f) k = Option.map f (Std.ExtDTreeMap.Const.get? t k) | true |
CategoryTheory.Over.starPullbackIsoStar._proof_7 | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasBinaryProducts C]
[CategoryTheory.Limits.HasPullbacks C] {X Y : C} (f : X ⟶ Y) (Z : C),
CategoryTheory.Limits.HasPullback ((CategoryTheory.Over.star Y).obj Z).hom f | false |
OreLocalization.instFieldNonZeroDivisors._proof_7 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : Nontrivial R] [inst_2 : NoZeroDivisors R]
[inst_3 : OreLocalization.OreSet (nonZeroDivisors R)] (a : OreLocalization (nonZeroDivisors R) R), a ≠ 0 → a * a⁻¹ = 1 | false |
Lean.Server.Test.Runner.Client.HighlightedMsgEmbed.widget.sizeOf_spec | Lean.Server.Test.Runner | ∀ (wi : Lean.Server.Test.Runner.Client.WidgetInstance)
(alt : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.HighlightedMsgEmbed),
sizeOf (Lean.Server.Test.Runner.Client.HighlightedMsgEmbed.widget wi alt) = 1 + sizeOf wi + sizeOf alt | true |
EuclideanDomain.lcm_eq_zero_iff | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] [inst_1 : DecidableEq R] {x y : R},
EuclideanDomain.lcm x y = 0 ↔ x = 0 ∨ y = 0 | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.unfoldBothDefEq._sparseCasesOn_1 | Lean.Meta.ExprDefEq | {motive : Lean.LBool → Sort u} →
(t : Lean.LBool) → motive Lean.LBool.true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Std.DTreeMap.getKey?_union_of_not_mem_left | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∉ t₁ → (t₁ ∪ t₂).getKey? k = t₂.getKey? k | true |
CategoryTheory.Limits.ColimitPresentation.Total.Hom.comp_base | Mathlib.CategoryTheory.Presentable.ColimitPresentation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u_1} {I : J → Type u_2}
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] [inst_2 : (j : J) → CategoryTheory.Category.{u_3, u_2} (I j)]
{D : CategoryTheory.Functor J C} {P : (j : J) → CategoryTheory.Limits.ColimitPresentation (I j) (D.obj j)}
{k l m : CategoryTheory.Limits.ColimitPresentation.Total P} (f : k.Hom l) (g : l.Hom m),
(f.comp g).base = CategoryTheory.CategoryStruct.comp f.base g.base | true |
Polynomial.isRoot_cyclotomic_iff | Mathlib.RingTheory.Polynomial.Cyclotomic.Roots | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [IsDomain R] [NeZero ↑n] {μ : R},
(Polynomial.cyclotomic n R).IsRoot μ ↔ IsPrimitiveRoot μ n | true |
_private.Init.Data.Range.Polymorphic.PRange.0.Std.instDecidableEqRoo.decEq._proof_3 | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u_1} (a a_1 b b_1 : α), ¬a = b → ((a<...a_1) = b<...b_1) → False | false |
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.Environment.mk.injEq | Std.Internal.Async.System | ∀ (toHashMap toHashMap_1 : Std.HashMap String String),
({ toHashMap := toHashMap } = { toHashMap := toHashMap_1 }) = (toHashMap = toHashMap_1) | true |
Prod.instBornology | Mathlib.Topology.Bornology.Constructions | {α : Type u_1} → {β : Type u_2} → [Bornology α] → [Bornology β] → Bornology (α × β) | true |
CategoryTheory.Comonad.comparison_obj_A | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (h : L ⊣ R) (X : C),
((CategoryTheory.Comonad.comparison h).obj X).A = L.obj X | true |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Polynomial.Monic.geom_sum._simp_1_2 | Mathlib.RingTheory.Polynomial.Basic | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ}, (↑m < ↑n) = (m < n) | false |
CategoryTheory.isIso_left_of_isIso_biprod_map | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z)
[CategoryTheory.IsIso (CategoryTheory.Limits.biprod.map f g)], CategoryTheory.IsIso f | true |
Filter.eventually_forall_ge_atTop | Mathlib.Order.Filter.AtTopBot.Finite | ∀ {α : Type u_3} [inst : Preorder α] {p : α → Prop},
(∀ᶠ (x : α) in Filter.atTop, ∀ (y : α), x ≤ y → p y) ↔ ∀ᶠ (x : α) in Filter.atTop, p x | true |
Array.lt_toList | Init.Data.Array.Lex.Lemmas | ∀ {α : Type u_1} [inst : LT α] {xs ys : Array α}, xs.toList < ys.toList ↔ xs < ys | true |
CategoryTheory.MonoidalCategory.«_aux_Mathlib_CategoryTheory_Monoidal_Category___macroRules_CategoryTheory_MonoidalCategory_term_◁__1» | Mathlib.CategoryTheory.Monoidal.Category | Lean.Macro | false |
subsetSupSet | Mathlib.Order.CompleteLatticeIntervals | {α : Type u_2} → (s : Set α) → [Preorder α] → [SupSet α] → [Inhabited ↑s] → SupSet ↑s | true |
_private.Mathlib.GroupTheory.SpecificGroups.Quaternion.0.QuaternionGroup.mul.eq_2 | Mathlib.GroupTheory.SpecificGroups.Quaternion | ∀ {n : ℕ} (a a_1 : ZMod (2 * n)),
QuaternionGroup.mul✝ (QuaternionGroup.a a) (QuaternionGroup.xa a_1) = QuaternionGroup.xa (a_1 - a) | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.algebra₀._proof_3 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ (R : Type u_2) [inst : CommRing R] {A : Type u_1} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra A B] (D : Algebra.Smooth.DescentAux✝ A B) (r : R)
(x : ↥(Algebra.Smooth.DescentAux.subalgebra✝ R D)),
(Algebra.Smooth.DescentAux.algebra₀._aux_1✝ R D) r * x = x * (Algebra.Smooth.DescentAux.algebra₀._aux_1✝¹ R D) r | false |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.shortComplexMap._proof_10 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ (n₀ n₁ n₂ : ℤ), ¬0 ≤ 1 → False | false |
ProbabilityTheory.integral_id_stdGaussian | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [BorelSpace E], ∫ (x : E), x ∂ProbabilityTheory.stdGaussian E = 0 | true |
_private.Init.Data.Array.Monadic.0.List.forIn'_eq_foldlM.match_1.eq_2 | Init.Data.Array.Monadic | ∀ {β : Type u_1} (motive : ForInStep β → Sort u_2) (b : β) (h_1 : (b : β) → motive (ForInStep.yield b))
(h_2 : (b : β) → motive (ForInStep.done b)),
(match ForInStep.done b with
| ForInStep.yield b => h_1 b
| ForInStep.done b => h_2 b) =
h_2 b | true |
Subgroup.centerToMulOpposite_apply_coe | Mathlib.GroupTheory.Subgroup.Center | ∀ (G : Type u_1) [inst : Group G] (r : ↥(Subsemigroup.center G)),
↑((Subgroup.centerToMulOpposite G) r) = MulOpposite.op ↑r | true |
Lean.instInhabitedLocalInstance | Lean.MetavarContext | Inhabited Lean.LocalInstance | true |
AddGroupFilterBasis.mk._flat_ctor | Mathlib.Topology.Algebra.FilterBasis | {A : Type u} →
[inst : AddGroup A] →
(sets : Set (Set A)) →
sets.Nonempty →
(∀ {x y : Set A}, x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y) →
(∀ {U : Set A}, U ∈ sets → 0 ∈ U) →
(∀ {U : Set A}, U ∈ sets → ∃ V ∈ sets, V + V ⊆ U) →
(∀ {U : Set A}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => -x) ⁻¹' U) →
(∀ (x₀ : A) {U : Set A}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x => x₀ + x + -x₀) ⁻¹' U) →
AddGroupFilterBasis A | false |
MeasureTheory.Measure.setLIntegral_condKernel_univ_right | Mathlib.Probability.Kernel.Disintegration.Integral | ∀ {β : Type u_1} {Ω : Type u_2} {mβ : MeasurableSpace β} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [inst_3 : MeasureTheory.IsFiniteMeasure ρ]
{f : β × Ω → ENNReal},
Measurable f →
∀ {s : Set β},
MeasurableSet s →
∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω) in s ×ˢ Set.univ, f x ∂ρ | true |
Ideal.instIsTwoSidedComap | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
{K : Ideal S} [inst_3 : RingHomClass F R S] [K.IsTwoSided], (Ideal.comap f K).IsTwoSided | true |
CategoryTheory.Subgroupoid.inclusion_trans | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {R S T : CategoryTheory.Subgroupoid C} (k : R ≤ S) (h : S ≤ T),
CategoryTheory.Subgroupoid.inclusion ⋯ =
(CategoryTheory.Subgroupoid.inclusion k).comp (CategoryTheory.Subgroupoid.inclusion h) | true |
Affine.Simplex.mongePoint.eq_1 | Mathlib.Geometry.Euclidean.MongePoint | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n),
s.mongePoint = (↑(n + 1) / ↑(n - 1)) • (Finset.centroid ℝ Finset.univ s.points -ᵥ s.circumcenter) +ᵥ s.circumcenter | true |
Heyting.Regular.instBooleanAlgebra._proof_10 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (a : Heyting.Regular α), ⊤ ≤ a ⊔ aᶜ | false |
MonoidHom.smulOneHom.eq_1 | Mathlib.Algebra.Group.Action.Hom | ∀ {M : Type u_4} {N : Type u_5} [inst : Monoid M] [inst_1 : MulOneClass N] [inst_2 : MulAction M N]
[inst_3 : IsScalarTower M N N], MonoidHom.smulOneHom = { toFun := fun x => x • 1, map_one' := ⋯, map_mul' := ⋯ } | true |
ProofWidgets.Html.noConfusionType | ProofWidgets.Data.Html | Sort u → ProofWidgets.Html → ProofWidgets.Html → Sort u | false |
Std.ExtTreeMap.ext_getKey?_unit | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {t₁ t₂ : Std.ExtTreeMap α Unit cmp},
(∀ (k : α), t₁.getKey? k = t₂.getKey? k) → t₁ = t₂ | true |
MeasureTheory.FiniteMeasure.tendsto_iff_forall_testAgainstNN_tendsto | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{γ : Type u_3} {F : Filter γ} {μs : γ → MeasureTheory.FiniteMeasure Ω} {μ : MeasureTheory.FiniteMeasure Ω},
Filter.Tendsto μs F (nhds μ) ↔
∀ (f : BoundedContinuousFunction Ω NNReal),
Filter.Tendsto (fun i => (μs i).testAgainstNN f) F (nhds (μ.testAgainstNN f)) | true |
Lean.LocalContext.lastDeclM | Mathlib.Lean.LocalContext | {m : Type u → Type v} → [AlternativeMonad m] → {β : Type u} → Lean.LocalContext → (Lean.LocalDecl → m β) → m β | true |
Monovary.inv_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : CommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α]
[inst_3 : PartialOrder β] {f : ι → α} {g : ι → β}, Monovary f g → Antivary f⁻¹ g | true |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.IsCyclotomicExtension.instSubsingleton._simp_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {S : Subalgebra R A},
(S = ⊤) = ∀ (x : A), x ∈ S | false |
CategoryTheory.ComposableArrows.scMap_τ₂ | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S₁ S₂ : CategoryTheory.ComposableArrows C n} (φ : S₁ ⟶ S₂) (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i : ℕ)
(hi : autoParam (i + 2 ≤ n) CategoryTheory.ComposableArrows.scMap._auto_1),
(CategoryTheory.ComposableArrows.scMap φ h₁ h₂ i hi).τ₂ = φ.app ⟨i + 1, ⋯⟩ | true |
associatedPrimes.nonempty | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[IsNoetherianRing R] [Nontrivial M], (associatedPrimes R M).Nonempty | true |
_private.Mathlib.Algebra.Group.Semiconj.Basic.0.SemiconjBy.inv_symm_left_iff._simp_1_1 | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a = b * c⁻¹) = (a * c = b) | false |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_5 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : (PreQuasiregular A)ˣ),
{ val := 1 + ↑(PreQuasiregular.equiv.symm ↑x), inv := 1 + ↑(PreQuasiregular.equiv.symm ↑x⁻¹), val_inv := ⋯,
inv_val := ⋯ } ∈
Unitization.unitsFstOne R A | false |
Module.Free.instIsTorsionFree | Mathlib.LinearAlgebra.FreeModule.Basic | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Free R M],
Module.IsTorsionFree R M | true |
Mathlib.CountHeartbeats.«_aux_Mathlib_Util_CountHeartbeats___elabRules_Mathlib_CountHeartbeats_command#count_heartbeatsApproximatelyIn___1» | Mathlib.Util.CountHeartbeats | Lean.Elab.Command.CommandElab | false |
Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.withBVLogicalCache | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | Lean.Expr →
(Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.LemmaM (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical)) →
Lean.Elab.Tactic.BVDecide.Frontend.LemmaM (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical) | true |
ModuleCat.isColimitCokernelCofork._proof_1 | Mathlib.Algebra.Category.ModuleCat.Kernels | ∀ {R : Type u_2} [inst : Ring R] {M N P : ModuleCat R} (f : M ⟶ N) (g : N ⟶ P),
Function.Exact ⇑(ModuleCat.Hom.hom f) ⇑(ModuleCat.Hom.hom g) → (ModuleCat.Hom.hom g).ker = (ModuleCat.Hom.hom f).range | false |
Lean.Grind.Semiring.add_zero | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Semiring α] (a : α), a + 0 = a | true |
Finset.Nonempty.of_add_right | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Add α] {s t : Finset α}, (s + t).Nonempty → t.Nonempty | true |
GradedAlgHom.coe_fn_injective | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_6} {B : Type u_7} {ι : Type u_10} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ℬ],
Function.Injective DFunLike.coe | true |
OreLocalization.nsmul_eq_nsmul | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddCommMonoid X] [inst_3 : Module R X] (n : ℕ) (x : OreLocalization S X), n • x = n • x | true |
instModUSize | Init.Data.UInt.Basic | Mod USize | true |
Topology.RelCWComplex.Finite.rec | Mathlib.Topology.CWComplex.Classical.Finite | {X : Type u_1} →
[inst : TopologicalSpace X] →
{C D : Set X} →
[inst_1 : Topology.RelCWComplex C D] →
{motive : Topology.RelCWComplex.Finite C → Sort u} →
([toFiniteDimensional : Topology.RelCWComplex.FiniteDimensional C] →
[toFiniteType : Topology.RelCWComplex.FiniteType C] → motive ⋯) →
(t : Topology.RelCWComplex.Finite C) → motive t | false |
TopCat.coneOfConeForget_pt | Mathlib.Topology.Category.TopCat.Limits.Basic | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J TopCat}
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.forget TopCat))),
(TopCat.coneOfConeForget c).pt = TopCat.of (TopCat.conePtOfConeForget c) | true |
Vector.toArray_injective | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {v w : Vector α n}, v.toArray = w.toArray → v = w | true |
Complex.UnitDisc.instInvolutiveStar | Mathlib.Analysis.Complex.UnitDisc.Basic | InvolutiveStar Complex.UnitDisc | true |
Option.get.hcongr_3 | Mathlib.Data.Sum.Basic | ∀ (α α' : Type u),
α = α' →
∀ (o : Option α) (o' : Option α'),
o ≍ o' → ∀ (a : o.isSome = true) (a' : o'.isSome = true), a ≍ a' → o.get a ≍ o'.get a' | true |
_private.Lean.Elab.Deriving.BEq.0.Lean.Elab.Deriving.BEq.mkBEqEnumFun | Lean.Elab.Deriving.BEq | Lean.Elab.Deriving.Context → Lean.Name → Lean.Elab.TermElabM Lean.Syntax | true |
Tactic.ComputeAsymptotics.Majorized.add | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Majorized | ∀ {f g b : ℝ → ℝ} {exp f_exp g_exp : ℝ},
Tactic.ComputeAsymptotics.Majorized f b f_exp →
Tactic.ComputeAsymptotics.Majorized g b g_exp →
f_exp ≤ exp → g_exp ≤ exp → Tactic.ComputeAsymptotics.Majorized (f + g) b exp | true |
ZNum.neg_of_int | Mathlib.Data.Num.ZNum | ∀ (n : ℤ), ↑(-n) = -↑n | true |
SNum.recOn | Mathlib.Data.Num.Bitwise | {motive : SNum → Sort u} →
(t : SNum) → ((a : Bool) → motive (SNum.zero a)) → ((a : NzsNum) → motive (SNum.nz a)) → motive t | false |
ConvexBody.instAdd | Mathlib.Analysis.Convex.Body | {V : Type u_1} →
[inst : TopologicalSpace V] →
[inst_1 : AddCommGroup V] → [inst_2 : Module ℝ V] → [ContinuousAdd V] → Add (ConvexBody V) | true |
TensorProduct.LieModule.mapIncl | Mathlib.Algebra.Lie.TensorProduct | {R : Type u} →
[inst : CommRing R] →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L M] →
[inst_7 : AddCommGroup N] →
[inst_8 : Module R N] →
[inst_9 : LieRingModule L N] →
[inst_10 : LieModule R L N] →
(M' : LieSubmodule R L M) →
(N' : LieSubmodule R L N) → TensorProduct R ↥M' ↥N' →ₗ⁅R,L⁆ TensorProduct R M N | true |
ScottContinuous.prodMk | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
{f : α → β} {g : α → γ}, ScottContinuous f → ScottContinuous g → ScottContinuous fun x => (f x, g x) | true |
Real.sin_antiperiodic | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Function.Antiperiodic Real.sin Real.pi | true |
CategoryTheory.GradedObject.mapBifunctorMap._proof_4 | Mathlib.CategoryTheory.GradedObject.Bifunctor | ∀ {C₁ : Type u_8} {C₂ : Type u_2} {C₃ : Type u_6} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_9} {J : Type u_1} {K : Type u_4}
(p : I × J → K)
[inst_3 :
∀ (X : CategoryTheory.GradedObject I C₁) (Y : CategoryTheory.GradedObject J C₂),
(((CategoryTheory.GradedObject.mapBifunctor F I J).obj X).obj Y).HasMap p]
(X : CategoryTheory.GradedObject I C₁) {X_1 Y Z : CategoryTheory.GradedObject J C₂} (f : X_1 ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.GradedObject.mapBifunctorMapMap F p (CategoryTheory.CategoryStruct.id X)
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.mapBifunctorMapMap F p (CategoryTheory.CategoryStruct.id X) f)
(CategoryTheory.GradedObject.mapBifunctorMapMap F p (CategoryTheory.CategoryStruct.id X) g) | false |
List.Cursor.ext | Std.Do.Triple.SpecLemmas | ∀ {α : Type u} {l : List α} {x y : l.Cursor}, x.prefix = y.prefix → x.suffix = y.suffix → x = y | true |
SimplexCategoryGenRel.IsAdmissible.getElemAsFin | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | {m : ℕ} → {L : List ℕ} → SimplexCategoryGenRel.IsAdmissible m L → (k : ℕ) → k < L.length → Fin (m + k + 1) | true |
List.orM | Mathlib.Data.List.Defs | {m : Type → Type v} → [Monad m] → List (m Bool) → m Bool | true |
EST.Out.error.injEq | Init.System.ST | ∀ {ε σ α : Type} (a : ε) (a_1 : Void σ) (a_2 : ε) (a_3 : Void σ),
(EST.Out.error a a_1 = EST.Out.error a_2 a_3) = (a = a_2 ∧ a_1 = a_3) | true |
ONote.scale | Mathlib.SetTheory.Ordinal.Notation | ONote → ONote → ONote | true |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedHomogeneousComponent_finsupp._simp_1_3 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
Batteries.DList.recOn | Batteries.Data.DList.Basic | {α : Type u} →
{motive : Batteries.DList α → Sort u_1} →
(t : Batteries.DList α) →
((apply : List α → List α) →
(invariant : ∀ (l : List α), apply l = apply [] ++ l) → motive { apply := apply, invariant := invariant }) →
motive t | false |
MeasureTheory.all_ae_ofReal_f_le_bound | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{F : ℕ → α → β} {f : α → β} {bound : α → ℝ},
(∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a) →
(∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun n => F n a) Filter.atTop (nhds (f a))) →
∀ᵐ (a : α) ∂μ, ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a) | true |
Lean.Compiler.LCNF.CompilerM.run | Lean.Compiler.LCNF.CompilerM | {α : Type} →
Lean.Compiler.LCNF.CompilerM α →
optParam Lean.Compiler.LCNF.CompilerM.State { } →
optParam Lean.Compiler.LCNF.Phase Lean.Compiler.LCNF.Phase.base → Lean.CoreM α | true |
QuadraticMap.toBilin._proof_4 | Mathlib.LinearAlgebra.QuadraticForm.Basis | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N], SMulCommClass R R (M →ₗ[R] N) | false |
Sylow.commutator_eq_bot_or_commutator_eq_self | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] {p : ℕ} [Fact (Nat.Prime p)] [Finite G] (P : Sylow p G) [IsCyclic ↥↑P] [(↑P).Normal]
{K : Subgroup G}, K.IsComplement' ↑P → ⁅K, ↑P⁆ = ⊥ ∨ ⁅K, ↑P⁆ = ↑P | true |
tendsto_inv_nhdsWithin_Iic_inv | Mathlib.Topology.Algebra.Group.Basic | ∀ {H : Type x} [inst : TopologicalSpace H] [inst_1 : CommGroup H] [inst_2 : PartialOrder H] [IsOrderedMonoid H]
[ContinuousInv H] {a : H}, Filter.Tendsto Inv.inv (nhdsWithin a⁻¹ (Set.Iic a⁻¹)) (nhdsWithin a (Set.Ici a)) | true |
Std.Roc.HasRcoIntersection.ctorIdx | Init.Data.Range.Polymorphic.PRange | {α : Type w} → Std.Roc.HasRcoIntersection α → ℕ | false |
ContinuousMultilinearMap.norm_compContinuous_linearIsometryEquiv | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {E₁ : ι → Type wE₁} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : (i : ι) → SeminormedAddCommGroup (E₁ i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (E₁ i)]
[inst_5 : SeminormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : Fintype ι]
(g : ContinuousMultilinearMap 𝕜 E₁ G) (f : (i : ι) → E i ≃ₗᵢ[𝕜] E₁ i),
‖g.compContinuousLinearMap fun i => ↑(f i).toContinuousLinearEquiv‖ = ‖g‖ | true |
nnnorm_sub_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] (a b : E), ‖a - b‖₊ ≤ ‖a‖₊ + ‖b‖₊ | true |
MeasurableSpace.measurableSet_iUnion | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_7} (self : MeasurableSpace α) (f : ℕ → Set α),
(∀ (i : ℕ), MeasurableSpace.MeasurableSet' self (f i)) → MeasurableSpace.MeasurableSet' self (⋃ i, f i) | true |
Equiv.Perm.perm_symm_mapsTo_iff_mapsTo._simp_1 | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u} {f : Equiv.Perm α} {s : Set α} [Finite ↑s], Set.MapsTo (⇑(Equiv.symm f)) s s = Set.MapsTo (⇑f) s s | false |
instInfiniteFreeRing | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u_1), Infinite (FreeRing α) | true |
NonUnitalRingHom.srangeRestrict | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
{F : Type u_1} →
[inst_1 : FunLike F R S] →
[inst_2 : NonUnitalNonAssocSemiring S] →
[inst_3 : NonUnitalRingHomClass F R S] → (f : F) → R →ₙ+* ↥(NonUnitalRingHom.srange f) | true |
Mathlib.Tactic.ToDual.unfoldBoundaries | Mathlib.Tactic.Translate.ToDual | Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaryExt | true |
MeasureTheory.Measure.measure_eq_zero_of_subset_diff_everywherePosSubset | Mathlib.MeasureTheory.Measure.EverywherePos | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s k : Set α},
IsCompact k → k ⊆ s \ μ.everywherePosSubset s → μ k = 0 | true |
WithConv.addEquiv_symm_apply_ofConv | Mathlib.Algebra.WithConv | ∀ (A : Type u_2) [inst : AddMonoid A] (ofConv : A), ((WithConv.addEquiv A).symm ofConv).ofConv = ofConv | true |
NumberField.RingOfIntegers.mk_one | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K], ⟨1, ⋯⟩ = 1 | true |
MeasureTheory.Measure.tendsto_IicSnd_atBot | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) [MeasureTheory.IsFiniteMeasure ρ]
{s : Set α}, MeasurableSet s → Filter.Tendsto (fun r => (ρ.IicSnd ↑r) s) Filter.atBot (nhds 0) | true |
_private.Init.Data.Nat.SOM.0.Nat.SOM.Poly.add.go.match_1.eq_3 | Init.Data.Nat.SOM | ∀ (motive : Nat.SOM.Poly → Nat.SOM.Poly → Sort u_1) (k₁ : ℕ) (m₁ : Nat.SOM.Mon) (p₁ : List (ℕ × Nat.SOM.Mon)) (k₂ : ℕ)
(m₂ : Nat.SOM.Mon) (p₂ : List (ℕ × Nat.SOM.Mon)) (h_1 : (p₁ : Nat.SOM.Poly) → motive p₁ [])
(h_2 : (p₂ : Nat.SOM.Poly) → motive [] p₂)
(h_3 :
(k₁ : ℕ) →
(m₁ : Nat.SOM.Mon) →
(p₁ : List (ℕ × Nat.SOM.Mon)) →
(k₂ : ℕ) → (m₂ : Nat.SOM.Mon) → (p₂ : List (ℕ × Nat.SOM.Mon)) → motive ((k₁, m₁) :: p₁) ((k₂, m₂) :: p₂)),
(match (k₁, m₁) :: p₁, (k₂, m₂) :: p₂ with
| p₁, [] => h_1 p₁
| [], p₂ => h_2 p₂
| (k₁, m₁) :: p₁, (k₂, m₂) :: p₂ => h_3 k₁ m₁ p₁ k₂ m₂ p₂) =
h_3 k₁ m₁ p₁ k₂ m₂ p₂ | true |
List.prev_eq_getElem_idxOf_pred_of_ne_head | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α} (ha : a ∈ l),
a ≠ l.head ⋯ → l.prev a ha = l[List.idxOf a l - 1] | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_inter_of_contains_right._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
minSmoothness_add | Mathlib.Analysis.Calculus.FDeriv.Symmetric | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n m : WithTop ℕ∞}, minSmoothness 𝕜 (n + m) = minSmoothness 𝕜 n + m | true |
CategoryTheory.Functor.Monoidal.whiskeringLeft._proof_2 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (E : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} E]
[inst_3 : CategoryTheory.MonoidalCategory E] (F : CategoryTheory.Functor C D) {X Y : CategoryTheory.Functor D E}
(f : X ⟶ Y) (X' : CategoryTheory.Functor D E),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (((CategoryTheory.Functor.whiskeringLeft C D E).obj F).map f)
(((CategoryTheory.Functor.whiskeringLeft C D E).obj F).obj X'))
(CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCategoryStruct.tensorObj (((CategoryTheory.Functor.whiskeringLeft C D E).obj F).obj Y)
(((CategoryTheory.Functor.whiskeringLeft C D E).obj F).obj X'))).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCategoryStruct.tensorObj (((CategoryTheory.Functor.whiskeringLeft C D E).obj F).obj X)
(((CategoryTheory.Functor.whiskeringLeft C D E).obj F).obj X'))).hom
(((CategoryTheory.Functor.whiskeringLeft C D E).obj F).map
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f X')) | false |
NonUnitalRingHom.cancel_right._simp_1 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : NonUnitalNonAssocSemiring α]
[inst_1 : NonUnitalNonAssocSemiring β] [inst_2 : NonUnitalNonAssocSemiring γ] {g₁ g₂ : β →ₙ+* γ} {f : α →ₙ+* β},
Function.Surjective ⇑f → (g₁.comp f = g₂.comp f) = (g₁ = g₂) | false |
AddSubgroup.leftTransversals.diff._proof_2 | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} (S T : H.LeftTransversal) (q : G ⧸ H),
-↑(⋯.leftQuotientEquiv q) + ↑(⋯.leftQuotientEquiv q) ∈ H | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.