name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Computability.Primrec.Basic.0.Primrec.nat_div._simp_1_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
CategoryTheory.sum.inlCompAssociator_hom_app | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (X : C ⊕ D),
(CategoryTheory.sum.inlCompAssociator C D E).hom.app X =
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Sum.i... | null | true |
Lean.Compiler.LCNF.SpecState.specInfo | Lean.Compiler.LCNF.SpecInfo | Lean.Compiler.LCNF.SpecState → Lean.PHashMap Lean.Name Lean.Compiler.LCNF.SpecEntry | null | true |
Aesop.RuleBuilderInput._sizeOf_1 | Aesop.Builder.Basic | Aesop.RuleBuilderInput → ℕ | null | false |
Int8.le_of_lt | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, a < b → a ≤ b | null | true |
CategoryTheory.Endofunctor.algebraPreadditive_homGroup_nsmul_f | Mathlib.CategoryTheory.Preadditive.EndoFunctor | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C]
(F : CategoryTheory.Functor C C) [inst_2 : F.Additive] (A₁ A₂ : CategoryTheory.Endofunctor.Algebra F) (n : ℕ)
(α : A₁ ⟶ A₂), (n • α).f = n • α.f | null | true |
IndexedPartition.piecewise_apply | Mathlib.Order.Setoid.Partition | ∀ {ι : Type u_1} {α : Type u_2} {s : ι → Set α} (hs : IndexedPartition s) {β : Type u_3} {f : ι → α → β} (x : α),
hs.piecewise f x = f (hs.index x) x | null | true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mlieBracketWithin_smul_left._abel_1_1 | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {H : Type u_3} [inst_1 : TopologicalSpace H] {E : Type u_1}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {x : M} {V W : (x : M) → Ta... | null | false |
fourier_coe_apply' | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ} {n : ℤ} {x : ℝ}, ↑(AddCircle.toCircle (n • ↑x)) = Complex.exp (2 * ↑Real.pi * Complex.I * ↑n * ↑x / ↑T) | null | true |
instIsDedekindFiniteMonoidOfIsRightCancelMulZero | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_3} [inst : MonoidWithZero M₀] [IsRightCancelMulZero M₀], IsDedekindFiniteMonoid M₀ | null | true |
_private.Mathlib.Data.Finset.Sum.0.Finset.disjSum_eq_empty._simp_1_1 | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | null | false |
OrderType.card_zero | Mathlib.Order.Types.Arithmetic | OrderType.card 0 = 0 | null | true |
bUnion_mem_nhdsSet | Mathlib.Topology.NhdsSet | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X} {t : X → Set X},
(∀ x ∈ s, t x ∈ nhds x) → ⋃ x ∈ s, t x ∈ nhdsSet s | null | true |
Filter.Germ.instSemiring._proof_11 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {l : Filter α} {R : Type u_1} [inst : Semiring R] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
Sym2.fromRelNdrec_mk | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} {motive : Sort u_4} {sym : Std.Symm r} {a b : α} (hz : r a b)
(f : (a b : α) → r a b → motive) (h : ∀ (a b : α) (h : r a b), f a b h = f b a ⋯),
Sym2.fromRelNdrec s(a, b) hz f h = f a b hz | null | true |
three'_nsmul | Mathlib.Algebra.Group.Monoid | ∀ {M : Type u_2} [inst : AddMonoid M] (a : M), 3 • a = a + a + a | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjId_hom_app_snd_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] (X_1 : C... | null | true |
Con.gi.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ (M : Type u_1) [inst : Mul M], Con.gi M = { choice := fun r x => conGen r, gc := ⋯, le_l_u := ⋯, choice_eq := ⋯ } | null | true |
Cardinal.beth_natCast_le_lift._simp_1 | Mathlib.SetTheory.Cardinal.Aleph | ∀ {c : Cardinal.{u}} {n : ℕ}, (Cardinal.beth ↑n ≤ Cardinal.lift.{v, u} c) = (Cardinal.beth ↑n ≤ c) | null | false |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.μ_bddAbove | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {R : Type u_1} [inst : CommRing R] (μ : RingSeminorm R),
μ 1 ≤ 1 →
∀ {s : ℕ → ℕ},
(∀ (n : ℕ), s n ≤ n) → ∀ (x : R) (ψ : ℕ → ℕ), BddAbove (Set.range fun n => μ (x ^ s (ψ n)) ^ (1 / ↑(ψ n))) | null | true |
CategoryTheory.Limits.weakPullbackIsWeakPullback | Mathlib.CategoryTheory.Limits.WeakLimits.WeakPullbacks | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y Z : C} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
[inst_1 : CategoryTheory.Limits.HasWeakPullback f g] →
CategoryTheory.Limits.IsWeakLimit
(CategoryTheory.Limits.PullbackCone.mk (CategoryTheory.Limits.weakPu... | The weak pullback cone built from the weak pullback projections is a weak pullback. | true |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.cos_angle_mul_norm_mul_norm._simp_1_1 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal._proof_3 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (Z : TopologicalSpace.Closeds ↥X) (U : ↑X.affineOpens),
∀ x ∈ ↑U,
x ∈ ↑Z ↔ x ∈ X.zeroLocus ↑(PrimeSpectrum.vanishingIdeal (⇑(AlgebraicGeometry.IsAffineOpen.fromSpec ⋯) ⁻¹' ↑Z)) | null | false |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.mkProdEqQ.makeRHS._sunfold | Mathlib.Data.Fin.Tuple.Reflection | {u : Lean.Level} →
{α : Q(Type u)} → Q(CommMonoid «$α») → (n : ℕ) → Q(Fin «$n» → «$α») → Q(NeZero «$n») → ℕ → Lean.MetaM Q(«$α») | null | false |
List.partition.loop.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (p : α → Bool) (a : α) (as bs cs : List α),
List.partition.loop p (a :: as) (bs, cs) =
match p a with
| true => List.partition.loop p as (a :: bs, cs)
| false => List.partition.loop p as (bs, a :: cs) | null | true |
Polynomial.hilbertPoly_mul_one_sub_succ | Mathlib.RingTheory.Polynomial.HilbertPoly | ∀ {F : Type u_1} [inst : Field F] [CharZero F] (p : Polynomial F) (d : ℕ),
(p * (1 - Polynomial.X)).hilbertPoly (d + 1) = p.hilbertPoly d | null | true |
Mathlib.Tactic.Bicategory.Mor₂OfExpr | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Lean.Expr → Mathlib.Tactic.Bicategory.BicategoryM Mathlib.Tactic.BicategoryLike.Mor₂ | Construct a `Mor₂` term from a Lean expression. | true |
Computation.Mem | Mathlib.Data.Seq.Computation | {α : Type u} → Computation α → α → Prop | Assertion that a `Computation` limits to a given value | true |
GroupLike.val_inj._simp_1 | Mathlib.RingTheory.Coalgebra.GroupLike | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] {a b : GroupLike R A}, (↑a = ↑b) = (a = b) | null | false |
Lean.Meta.mkSizeOfFns | Lean.Meta.SizeOf | Lean.Name → Lean.MetaM (Array Lean.Name × Lean.NameMap Lean.Name) | Create `sizeOf` functions for all inductive datatypes in the mutual inductive declaration containing `typeName`
The resulting array contains the generated functions names. The `NameMap` maps recursor names into the generated function names.
There is a function for each element of the mutual inductive declaration, and f... | true |
skewAdjointLieSubalgebra | Mathlib.Algebra.Lie.SkewAdjoint | {R : Type u} →
{M : Type v} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → LinearMap.BilinForm R M → LieSubalgebra R (Module.End R M) | Given an `R`-module `M`, equipped with a bilinear form, the skew-adjoint endomorphisms form a
Lie subalgebra of the Lie algebra of endomorphisms. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.forM_eq_forM_toArray._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t : Std.DTreeMap.Internal.Impl α β}, t.toArray = t.toList.toArray | null | false |
forall_gt_imp_ne_iff_le | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ (c : α), a < c → c ≠ b) ↔ b ≤ a | null | true |
ContinuousLinearMapWOT._sizeOf_inst | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | {𝕜₁ : Type u_1} →
{𝕜₂ : Type u_2} →
{inst : Semiring 𝕜₁} →
{inst_1 : Semiring 𝕜₂} →
(σ : 𝕜₁ →+* 𝕜₂) →
(E : Type u_3) →
(F : Type u_4) →
{inst_2 : AddCommGroup E} →
{inst_3 : TopologicalSpace E} →
{inst_4 : Module 𝕜₁ E} →
... | null | false |
Quot.liftFinsupp | Mathlib.Data.Finsupp.Quotient | {α : Type u_1} →
{β : Type u_2} → {r : α → α → Prop} → [inst : Zero β] → (f : α →₀ β) → (∀ (a b : α), r a b → f a = f b) → Quot r →₀ β | Lift a function `α →₀ β` to `Quot r →₀ β`. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.instDecidableEqLiteral.decEq._proof_1 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | ∀ (a : ℕ) (a_1 : BitVec a), { n := a, value := a_1 } = { n := a, value := a_1 } | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.List.getValue?_filter_containsKey._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {x : Option α} {α_1 : Type u_2} {f : α → α_1}, (Option.map f x = none) = (x = none) | null | false |
Lean.Meta.Grind.AC.MonadGetStruct.noConfusion | Lean.Meta.Tactic.Grind.AC.Util | {P : Sort u} →
{m : Type → Type} →
{t : Lean.Meta.Grind.AC.MonadGetStruct m} →
{m' : Type → Type} →
{t' : Lean.Meta.Grind.AC.MonadGetStruct m'} →
m = m' → t ≍ t' → Lean.Meta.Grind.AC.MonadGetStruct.noConfusionType P t t' | null | false |
BitVec.reduceGetMsb | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | Simplification procedure for `getMsb` (most significant bit) on `BitVec`. | true |
MulOpposite.isCancelMulZero_iff | Mathlib.Algebra.GroupWithZero.Opposite | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α], IsCancelMulZero αᵐᵒᵖ ↔ IsCancelMulZero α | null | true |
Submodule.mem_sSup | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{s : Set (Submodule R M)} {m : M}, m ∈ sSup s ↔ ∀ (N : Submodule R M), (∀ p ∈ s, p ≤ N) → m ∈ N | null | true |
CategoryTheory.MorphismProperty.multiplicativeClosure.below.casesOn | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
{motive : ⦃X Y : C⦄ → (x : X ⟶ Y) → W.multiplicativeClosure x → Prop}
{motive_1 :
{X Y : C} →
{x : X ⟶ Y} →
(t : W.multiplicativeClosure x) → CategoryTheory.MorphismProperty.multiplicativeClosure.below... | null | false |
Aesop.UnsafeQueueEntry.instToString.match_1 | Aesop.Tree.UnsafeQueue | (motive : Aesop.UnsafeQueueEntry → Sort u_1) →
(x : Aesop.UnsafeQueueEntry) →
((r : Aesop.IndexMatchResult Aesop.UnsafeRule) → motive (Aesop.UnsafeQueueEntry.unsafeRule r)) →
((r : Aesop.PostponedSafeRule) → motive (Aesop.UnsafeQueueEntry.postponedSafeRule r)) → motive x | null | false |
Inclusion.ExprInclusion.mk | Mathlib.Tactic.Inclusion.Core.Types | Lean.Expr → Lean.Expr → Inclusion.ExprInclusion | null | true |
ContinuousMultilinearMap.smulRightL._proof_2 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_4) {ι : Type u_1} (E : ι → Type u_2) (G : Type u_3) [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(f : ContinuousMultilinearMap 𝕜 E... | null | false |
Lean.Order.PreservesSup.upperAdjoint_mono | Std.Internal.Order.PreservesSup | ∀ {α : Type u} [inst : Lean.Order.CompleteLattice α] (f : α → α) [Lean.Order.PreservesSup f] {b b' : α},
Lean.Order.PartialOrder.rel b b' →
Lean.Order.PartialOrder.rel (Lean.Order.PreservesSup.upperAdjoint f b) (Lean.Order.PreservesSup.upperAdjoint f b') | A right adjoint is monotone. | true |
modelWithCornersEuclideanQuadrant | Mathlib.Geometry.Manifold.Instances.Real | (n : ℕ) → ModelWithCorners ℝ (EuclideanSpace ℝ (Fin n)) (EuclideanQuadrant n) | Definition of the model with corners `(EuclideanSpace ℝ (Fin n), EuclideanQuadrant n)`, used as a
model for manifolds with corners | true |
ModularForm.trace | Mathlib.NumberTheory.ModularForms.NormTrace | {𝒢 : Subgroup (GL (Fin 2) ℝ)} →
(ℋ : Subgroup (GL (Fin 2) ℝ)) →
{F : Type u_1} →
[inst : FunLike F UpperHalfPlane ℂ] →
{k : ℤ} → F → [𝒢.IsFiniteRelIndex ℋ] → [ModularFormClass F 𝒢 k] → ModularForm ℋ k | The trace of a modular form, as a modular form. | true |
equivShrink_le_equivShrink._simp_1 | Mathlib.Order.Shrink | ∀ {α : Type u_1} [inst : Small.{u, u_1} α] [inst_1 : Preorder α] {x y : α},
((equivShrink α) x ≤ (equivShrink α) y) = (x ≤ y) | null | false |
OrderDual.instMulOneClass | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [MulOneClass α] → MulOneClass αᵒᵈ | null | true |
CompleteOrthogonalIdempotents.ringEquivOfIsMulCentral._proof_3 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {I : Type u_2} {e : I → R} [inst : Semiring R] (r : R) (i : I), ∃ y, e i * y * e i = e i * r * e i | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs.0.CategoryTheory.IsPushout.inr_isoIsPushout_inv._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
(CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) | null | false |
Mathlib.Tactic.Ring.Common.evalMul₁._sunfold | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute bt sα →
Mathlib.Tactic.Ring.Common.RingCompute Mathlib.Tactic.Ring.Common.btℕ Mathlib.Tactic.Ring.Common.sℕ →
{a b : Q(«$α»)} →
Mathli... | null | false |
CommMonCat.forget₂_map_ofHom | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : Type u} [inst : CommMonoid X] [inst_1 : CommMonoid Y] (f : X →* Y),
(CategoryTheory.forget₂ CommMonCat MonCat).map (CommMonCat.ofHom f) = MonCat.ofHom f | null | true |
_private.Mathlib.Analysis.Complex.OpenMapping.0.AnalyticOnNhd.eq_const_of_re_eq_const._proof_1_2 | Mathlib.Analysis.Complex.OpenMapping | ∀ {f : ℂ → ℂ} {U : Set ℂ} {c₀ : ℝ},
AnalyticOnNhd ℂ f U → (∀ x ∈ U, (f x).re = c₀) → IsOpen U → IsConnected U → ∀ z₀ ∈ U, (¬∃ c, ∀ x ∈ U, f x = c) → False | null | false |
Lean.Doc.Part.below_2 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{p : Type w} →
{motive_1 : Lean.Doc.Part i b p → Sort u_1} →
{motive_2 : Array (Lean.Doc.Part i b p) → Sort u_1} →
{motive_3 : List (Lean.Doc.Part i b p) → Sort u_1} →
List (Lean.Doc.Part i b p) → Sort (max ((max (max u v) w) + 1) u_1) | null | false |
MeasureTheory.setToFun_mono_left' | Mathlib.MeasureTheory.Integral.SetToL1.Function | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {G'' : Type u_6} [inst_2 : NormedAddCommGroup G''] [inst_3 : PartialOrder G'']
[IsOrderedAddMonoid G''] [inst_5 : NormedSpace ℝ G''] [OrderClosedTopology G''] {T T' : Set α ... | null | true |
PNat.instSuccAddOrder | Mathlib.Order.SuccPred.PNat | SuccAddOrder ℕ+ | null | true |
Lean.Elab.Command.StatefulLinter._sizeOf_1 | Lean.Elab.Command | {σ τ : Type} → [SizeOf σ] → [SizeOf τ] → Lean.Elab.Command.StatefulLinter σ τ → ℕ | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.weierstrassPExcept_eq_tsum._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
contMDiff_zero_iff | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | zero-smoothness is equivalent to continuity. | true |
UniformSpaceCat.instFunLike | Mathlib.Topology.Category.UniformSpace | (X : UniformSpaceCat) → (Y : UniformSpaceCat) → FunLike { f // UniformContinuous f } X.carrier Y.carrier | null | true |
Nat.log_le_clog._simp_1 | Mathlib.Data.Nat.Log | ∀ (b n : ℕ), (Nat.log b n ≤ Nat.clog b n) = True | null | false |
dvd_differentIdeal_iff | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {B : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[inst_4 : IsDedekindDomain A] [inst_5 : IsDedekindDomain B] [inst_6 : Module.IsTorsionFree A B]
[inst_7 : Module.Finite A B] [Algebra.IsSeparable (FractionRing A) (FractionRing B)] {P : Ideal B}
... | A prime divides the different ideal iff it is ramified. | true |
WType.toList.match_1 | Mathlib.Data.W.Constructions | (γ : Type u_1) →
(motive : WType (WType.Listβ γ) → Sort u_2) →
(x : WType (WType.Listβ γ)) →
((f : WType.Listβ γ WType.Listα.nil → WType (WType.Listβ γ)) → motive (WType.mk WType.Listα.nil f)) →
((hd : γ) →
(f : WType.Listβ γ (WType.Listα.cons hd) → WType (WType.Listβ γ)) →
... | null | false |
Aesop.ElabM.Context.casesOn | Aesop.ElabM | {motive : Aesop.ElabM.Context → Sort u} →
(t : Aesop.ElabM.Context) →
((parsePriorities : Bool) → (goal : Lean.MVarId) → motive { parsePriorities := parsePriorities, goal := goal }) →
motive t | null | false |
Lean.MessageData.withContext | Lean.Message | Lean.MessageDataContext → Lean.MessageData → Lean.MessageData | `withContext ctx d` specifies the pretty printing context `(env, mctx, lctx, opts)` for the nested expressions in `d`. | true |
CategoryTheory.Mon.hom_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Mon C) [inst_3 : CategoryTheory.IsCommMonObj M.X],
CategoryTheory.MonObj.one.hom = CategoryTheory.MonObj.one | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.mkOfLe.match_1.splitter | Mathlib.AlgebraicTopology.SimplexCategory.Basic | (motive : Fin (1 + 1) → Sort u_1) → (x : Fin (1 + 1)) → (Unit → motive 0) → (Unit → motive 1) → motive x | null | true |
Convexity.StdSimplex.casesOn | Mathlib.Geometry.Convex.ConvexSpace.Defs | {R : Type u} →
[inst : LE R] →
[inst_1 : AddCommMonoid R] →
[inst_2 : One R] →
{X : Type v} →
{motive : Convexity.StdSimplex R X → Sort u_1} →
(t : Convexity.StdSimplex R X) →
((weights : X →₀ R) →
(nonneg : 0 ≤ weights) →
(to... | null | false |
Std.DHashMap.Internal.Raw₀.getKey?_eq_some_iff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → ∀ {k k' : α}, m.getKey? k = some k' ↔ ∃ (h : m.contains k = true), m.getKey k h = k' | null | true |
HomologicalComplex.mapBifunctor.hom_ext_iff | Mathlib.Algebra.Homology.Bifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D] {I₁ : Type u_4}
{I₂ : Type u_5} {J : Type u_6} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
[inst_3 : CategoryTheory.Lim... | null | true |
LieRinehartRing.lie_smul_eq_mul' | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {A : Type u_1} {L : Type u_2} {inst : CommRing A} {inst_1 : LieRing L} {inst_2 : Module A L}
{inst_3 : LieRingModule L A} [self : LieRinehartRing A L] (a b : A) (x : L), ⁅a • x, b⁆ = a * ⁅x, b⁆ | null | true |
StieltjesFunction.measurable_measure | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {x : MeasurableSpace α} {f : α → StieltjesFunction ℝ},
(∀ (q : ℝ), Measurable fun a => ↑(f a) q) →
(∀ (a : α), Filter.Tendsto (↑(f a)) Filter.atBot (nhds 0)) →
(∀ (a : α), Filter.Tendsto (↑(f a)) Filter.atTop (nhds 1)) → Measurable fun a => (f a).measure | A measurable function `α → StieltjesFunction ℝ` with limits 0 at -∞ and 1 at +∞ gives a
measurable function `α → Measure ℝ` by taking `StieltjesFunction.measure` at each point. | true |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic.initFn.match_7._@.Batteries.Tactic.Trans.2247956323._hygCtx._hyg.2 | Batteries.Tactic.Trans | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(x : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((xs : Array Lean.Expr) → (fst : Array Lean.BinderInfo) → (targetTy : Lean.Expr) → motive (xs, fst, targetTy)) →
motive x | null | false |
_private.Mathlib.MeasureTheory.Group.Integral.0.MeasureTheory.integral_eq_zero_of_mul_right_eq_neg._simp_1_2 | Mathlib.MeasureTheory.Group.Integral | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (f : α → G), -∫ (a : α), f a ∂μ = ∫ (a : α), -f a ∂μ | null | false |
mem_leftCoset_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Monoid α] (s : Submonoid α) {a : α}, a • ↑s = ↑s → a ∈ s | null | true |
Real.geom_mean_le_arith_mean4_weighted | Mathlib.Analysis.MeanInequalities | ∀ {w₁ w₂ w₃ w₄ p₁ p₂ p₃ p₄ : ℝ},
0 ≤ w₁ →
0 ≤ w₂ →
0 ≤ w₃ →
0 ≤ w₄ →
0 ≤ p₁ →
0 ≤ p₂ →
0 ≤ p₃ →
0 ≤ p₄ →
w₁ + w₂ + w₃ + w₄ = 1 → p₁ ^ w₁ * p₂ ^ w₂ * p₃ ^ w₃ * p₄ ^ w₄ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃ + w₄ * p₄ | null | true |
addSubgroupOfIdempotent._proof_3 | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : Finite G] (S : Set G) (hS1 : S.Nonempty) (hS2 : S + S = S),
0 ∈ (addSubmonoidOfIdempotent S hS1 hS2).carrier | null | false |
groupCohomology.instEpiModuleCatH2π | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
CategoryTheory.Epi (groupCohomology.H2π A) | null | true |
CategoryTheory.StrictlyUnitaryPseudofunctorCore.map₂_whisker_right._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | Lean.Syntax | null | false |
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent.noConfusion | Lean.Meta.Tactic.Grind.AC.Types | {P : Sort u} →
{x : Lean.Grind.AC.Var} →
{c₁ : Lean.Meta.Grind.AC.EqCnstr} →
{x' : Lean.Grind.AC.Var} →
{c₁' : Lean.Meta.Grind.AC.EqCnstr} →
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x c₁ =
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x' c₁' →
... | null | false |
CategoryTheory.Limits.CoproductDisjoint.isPullback_of_isInitial | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_1} {X : ι → C}
[CategoryTheory.Limits.CoproductDisjoint X] {c : CategoryTheory.Limits.Cofan X}
(hc : CategoryTheory.Limits.IsColimit c) {Y : C} (hY : CategoryTheory.Limits.IsInitial Y) {i j : ι}
[CategoryTheory.Limits.HasPullback (c.inj i) (c.in... | null | true |
AlgEquiv.ofInjectiveField._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_3} [inst : CommSemiring R] {E : Type u_1} {F : Type u_2} [inst_1 : DivisionRing E] [inst_2 : Semiring F]
[Nontrivial F] [inst_4 : Algebra R E] [inst_5 : Algebra R F] (f : E →ₐ[R] F), Function.Injective ⇑f.toRingHom | null | false |
Lean.Meta.Sym.AlphaShareCommon.State.noConfusionType | Lean.Meta.Sym.AlphaShareCommon | Sort u → Lean.Meta.Sym.AlphaShareCommon.State → Lean.Meta.Sym.AlphaShareCommon.State → Sort u | null | false |
Sum.map_bijective | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ},
Function.Bijective (Sum.map f g) ↔ Function.Bijective f ∧ Function.Bijective g | null | true |
Set.chainHeight_eq_top_iff | Mathlib.Order.Height | ∀ {α : Type u_1} (s : Set α) (r : α → α → Prop), s.chainHeight r = ⊤ ↔ ∀ (n : ℕ), ∃ t ⊆ s, t.encard = ↑n ∧ IsChain r t | null | true |
SubAddAction.ofStabilizer.conjMap._proof_5 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_1} [inst : AddGroup G] {α : Type u_2} [inst_1 : AddAction G α] {g : G} {a b : α} (hg : b = g +ᵥ a)
(x : ↥(AddAction.stabilizer G a)) (x_1 : ↥(SubAddAction.ofStabilizer G a)),
⟨g +ᵥ ↑(x +ᵥ x_1), ⋯⟩ = (AddAction.stabilizerEquivStabilizer hg) x +ᵥ ⟨g +ᵥ ↑x_1, ⋯⟩ | null | false |
_private.Init.Data.UInt.Bitwise.0.UInt8.xor_eq_zero_iff._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt8}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Lean.Elab.CompletionInfo.option.inj | Lean.Elab.InfoTree.Types | ∀ {stx stx_1 : Lean.Syntax}, Lean.Elab.CompletionInfo.option stx = Lean.Elab.CompletionInfo.option stx_1 → stx = stx_1 | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.copy._proof_1 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) {K' : C} (eK : K' ≅ h.K),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp eK.hom h.i) S.g = 0 | null | false |
Lean.Expr.name? | Lean.Util.Recognizers | Lean.Expr → Option Lean.Name | Checks if an expression is a `Name` literal, and if so returns the name.
| true |
_private.Mathlib.RingTheory.WittVector.StructurePolynomial.0.wittStructureRat_vars._proof_1_5 | Mathlib.RingTheory.WittVector.StructurePolynomial | ∀ {idx : Type u_1} (n k : ℕ) (i : idx), ∀ j < k + 1, k ∈ Finset.range (n + 1) → (i, j).2 < n + 1 | null | false |
Measurable.coe_real_ereal | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u_1} {mα : MeasurableSpace α} {f : α → ℝ}, Measurable f → Measurable fun x => ↑(f x) | null | true |
NFA.evalFrom_append | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} (M : NFA α σ) (S : Set σ) (x y : List α),
M.evalFrom S (x ++ y) = M.evalFrom (M.evalFrom S x) y | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtractAndExtendTarget.mk.congr_simp | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {outWidth w : ℕ} (x x_1 : aig.RefVec w),
x = x_1 → ∀ (h : outWidth = w * w), { w := w, x := x, h := h } = { w := w, x := x_1, h := h } | null | true |
Monoid.Coprod.fst | Mathlib.GroupTheory.Coprod.Basic | {M : Type u_1} → {N : Type u_2} → [inst : Monoid M] → [inst_1 : Monoid N] → Monoid.Coprod M N →* M | The natural projection `M ∗ N →* M`. | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.ContDiffWithinAt.congr_of_eventuallyEq.match_1_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : 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] {s : Set E}
{f : E → F} {x : E} (motive : (n : WithTop ℕ∞) → ContDiffWithinAt 𝕜 n f s x → Prop) (n : WithTop ℕ∞... | null | false |
ProfiniteGrp.coe_comp | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y Z : ProfiniteGrp.{u_1}} (f : X ⟶ Y) (g : Y ⟶ Z),
⇑(ProfiniteGrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(ProfiniteGrp.Hom.hom g) ∘ ⇑(ProfiniteGrp.Hom.hom f) | null | true |
Option.toArray_pmap | Init.Data.Option.Attach | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {o : Option α} {f : (a : α) → p a → β} (h : ∀ (a : α), o = some a → p a),
(Option.pmap f o h).toArray = Array.map (fun x => f ↑x ⋯) o.attach.toArray | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.