name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
starRingOfComm | Mathlib.Algebra.Star.Basic | {R : Type u_1} → [inst : CommSemiring R] → StarRing R | Any commutative semiring admits the trivial \*-structure.
See note [reducible non-instances].
| true |
MulEquiv.hasEnoughRootsOfUnity | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ {n : ℕ} [NeZero n] {M : Type u_1} {N : Type u_2} [inst : CommMonoid M] [inst_1 : CommMonoid N]
[hm : HasEnoughRootsOfUnity M n] (e : ↥(rootsOfUnity n M) ≃* ↥(rootsOfUnity n N)), HasEnoughRootsOfUnity N n | null | true |
Std.Sat.AIG.RelabelNat.State.inv2 | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {decls : Array (Std.Sat.AIG.Decl α)} {idx : ℕ}
(self : Std.Sat.AIG.RelabelNat.State α decls idx), Std.Sat.AIG.RelabelNat.State.Inv2 decls idx self.map | Proof that we inserted all atoms until `idx`.
| true |
CategoryTheory.Discrete.monoidalFunctor_δ | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ {M : Type u} [inst : Monoid M] {N : Type u'} [inst_1 : Monoid N] (F : M →* N) (m₁ m₂ : CategoryTheory.Discrete M),
CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.Discrete.monoidalFunctor F) m₁ m₂ =
CategoryTheory.Discrete.eqToHom ⋯ | null | true |
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_id._simp_1_2 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_1} [inst : CategoryTheory.EnrichedCategory CategoryTheory.Cat C] {a b : CategoryTheory.CatEnriched C}
{f f' : a ⟶ b} (η : f ⟶ f'),
(CategoryTheory.CatEnriched.hComp η (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id b)) ≍ η) =
True | null | false |
PerfectClosure.instCommRing._proof_5 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (m : ℕ) (x : K) (n : ℕ)
(y : K) (s : ℕ) (z : K),
Quot.mk (PerfectClosure.R K p) (m, x) *
(Quot.mk (PerfectClosure.R K p) (n, y) + Quot.mk (PerfectClosure.R K p) (s, z)) =
Quot.mk (PerfectClosure.R K p) (m, x) *... | null | false |
_private.Init.Prelude.0.Nat.eq_or_lt_of_le.match_1_1 | Init.Prelude | ∀ (n m : ℕ) (motive : n = m ∨ n < m → Prop) (x : n = m ∨ n < m),
(∀ (h : n = m), motive ⋯) → (∀ (h : n < m), motive ⋯) → motive x | null | false |
CategoryTheory.preadditiveCoyoneda_obj | Mathlib.CategoryTheory.Preadditive.Yoneda.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (X : Cᵒᵖ),
CategoryTheory.preadditiveCoyoneda.obj X =
(CategoryTheory.preadditiveCoyonedaObj (Opposite.unop X)).comp
(CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End (Opposite.unop X))ᵐᵒᵖ) AddCommGrpCat) | null | true |
Lean.Elab.Term.Do.mkReturn | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Syntax → Lean.Elab.Term.Do.CodeBlock | null | true |
_private.Mathlib.Analysis.Asymptotics.LinearGrowth.0.LinearGrowth.EReal.eventually_atTop_exists_nat_between.match_1_3 | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {b : EReal} (motive : (a : EReal) → a < b → Prop) (a : EReal) (h : a < b),
(∀ (h : ⊤ < b), motive (some none) h) →
(∀ (h : ⊥ < b), motive none h) → (∀ (a : ℝ) (h : ↑a < b), motive (some (some a)) h) → motive a h | null | false |
CategoryTheory.Quotient.preadditive._proof_6 | Mathlib.CategoryTheory.Quotient.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (r : HomRel C)
[inst_2 : CategoryTheory.Congruence r]
(hr : ∀ ⦃X Y : C⦄ (f₁ f₂ g₁ g₂ : X ⟶ Y), r f₁ f₂ → r g₁ g₂ → r (f₁ + g₁) (f₂ + g₂)) (P Q : CategoryTheory.Quotient r)
(a b : P ⟶ Q), a - b = a + -b | null | false |
Lean.Meta.Match.Extension.Entry.name | Lean.Meta.Match.MatcherInfo | Lean.Meta.Match.Extension.Entry → Lean.Name | null | true |
CategoryTheory.Preadditive.instMonoNegHom | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q : C} {f : P ⟶ Q}
[CategoryTheory.Mono f], CategoryTheory.Mono (-f) | null | true |
_private.Lean.Environment.0.Lean.Environment.AddConstAsyncResult.allRealizationsPromise | Lean.Environment | Lean.Environment.AddConstAsyncResult → IO.Promise (Lean.NameMap Lean.AsyncConst✝) | null | true |
GradedTensorProduct.algebraMap_def | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | true |
Fin.fin_two_eq_of_eq_zero_iff | Init.Data.Fin.Lemmas | ∀ {a b : Fin 2}, (a = 0 ↔ b = 0) → a = b | null | true |
spectralNorm.nontriviallyNormedField | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | (K : Type u) →
[inst : NontriviallyNormedField K] →
(L : Type v) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
[Algebra.IsAlgebraic K L] → [hu : IsUltrametricDist K] → [CompleteSpace K] → NontriviallyNormedField L | `L` with the spectral norm is a `NontriviallyNormedField`. | true |
_private.Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas.0.iteratedDeriv_neg._simp_1_1 | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {f : 𝕜 → F}, iteratedDeriv n f = iteratedDerivWithin n f Set.univ | null | false |
CategoryTheory.Comonad.mk.noConfusion | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{P : Sort u} →
{toFunctor : CategoryTheory.Functor C C} →
{ε : toFunctor ⟶ CategoryTheory.Functor.id C} →
{δ : toFunctor ⟶ toFunctor.comp toFunctor} →
{coassoc :
autoParam
(∀ (X : C)... | null | false |
CategoryTheory.GrothendieckTopology.instWEqualsLocallyBijectiveTypeFun | Mathlib.CategoryTheory.Sites.LocallyBijective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C),
J.WEqualsLocallyBijective (Type (max u v)) | null | true |
_private.Init.Data.List.Impl.0.List.replaceTR.go.eq_def | Init.Data.List.Impl | ∀ {α : Type u_1} [inst : BEq α] (l : List α) (b c : α) (a : List α) (a_1 : Array α),
List.replaceTR.go✝ l b c a a_1 =
match a, a_1 with
| [], x => l
| a :: as, acc => bif b == a then acc.toListAppend (c :: as) else List.replaceTR.go✝ l b c as (acc.push a) | null | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.rec_2 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.C... | null | false |
AlgebraicGeometry.Scheme.Pullback.t'._proof_1 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(i j k : 𝒰.I₀),
CategoryTheory.Limits.HasPullback (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
(AlgebraicGeometry.Sc... | null | false |
MulEquiv.toMonoidHom._proof_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (h : M ≃* N) (x y : M),
h.toFun (x * y) = h.toFun x * h.toFun y | null | false |
OpenPartialHomeomorph.singletonChartedSpace_chartAt_eq | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} [inst : TopologicalSpace H] {α : Type u_5} [inst_1 : TopologicalSpace α] (e : OpenPartialHomeomorph α H)
(h : e.source = Set.univ) {x : α}, chartAt H x = e | null | true |
LieRinehartSubalgebra.coe_toLieSubalgebra | Mathlib.Algebra.LieRinehartAlgebra.Subalgebra | ∀ {A : Type u_1} {L : Type u_2} [inst : CommRing A] [inst_1 : LieRing L] [inst_2 : Module A L]
(L' : LieRinehartSubalgebra A L) [inst_3 : LieRingModule L A] [inst_4 : LieRinehartRing A L] (R : Type u_3)
[inst_5 : CommRing R] [inst_6 : Algebra R A] [inst_7 : LieAlgebra R L] [inst_8 : LieRinehartAlgebra R A L],
↑(L... | null | true |
PresheafOfModules.colimitPresheafOfModules._proof_8 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ)
(x x_1 : ↑(R.obj X)), x * x_1 = x * x_1 | null | false |
ModuleCat.hom_add | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R} (f g : M ⟶ N),
ModuleCat.Hom.hom (f + g) = ModuleCat.Hom.hom f + ModuleCat.Hom.hom g | null | true |
MonadControl.noConfusion | Init.Control.Basic | {P : Sort u_1} →
{m : Type u → Type v} →
{n : Type u → Type w} →
{t : MonadControl m n} →
{m' : Type u → Type v} →
{n' : Type u → Type w} →
{t' : MonadControl m' n'} → m = m' → n = n' → t ≍ t' → MonadControl.noConfusionType P t t' | null | false |
IsCompact.diff | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsCompact s → IsOpen t → IsCompact (s \ t) | The set difference of a compact set and an open set is a compact set. | true |
Set.image_insert_eq | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α} {s : Set α}, f '' insert a s = insert (f a) (f '' s) | null | true |
Complex.not_continuousAt_Gamma_neg_nat | Mathlib.Analysis.SpecialFunctions.Gamma.Deriv | ∀ (n : ℕ), ¬ContinuousAt Complex.Gamma (-↑n) | null | true |
Associates.mkMonoidHom_apply | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M), Associates.mkMonoidHom a = Associates.mk a | null | true |
CategoryTheory.Triangulated.TStructure.natTransTruncLEOfLE.congr_simp | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
alexandrovDiscrete_coinduced | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {β : Type u_5} {f : α → β}, AlexandrovDiscrete β | null | true |
DivisibleHull.instIsOrderedCancelAddMonoid | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedCancelAddMonoid M],
IsOrderedCancelAddMonoid (DivisibleHull M) | null | true |
Int.Internal.Linear.dvd_of_eq_cert.eq_1 | Init.Data.Int.Linear | ∀ (x : Int.Internal.Linear.Var) (p₁ : Int.Internal.Linear.Poly) (d₂ : ℤ) (p₂ : Int.Internal.Linear.Poly),
Int.Internal.Linear.dvd_of_eq_cert x p₁ d₂ p₂ =
(d₂.beq' (Int.Internal.Linear.abs (p₁.coeff_k x)) && p₂.beq' (Int.Internal.Linear.Poly.insert (-p₁.coeff_k x) x p₁)) | null | true |
Monoid.CoprodI.NeWord.inv_last | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : (i : ι) → Group (G i)] {i j : ι} (w : Monoid.CoprodI.NeWord G i j),
w.inv.last = w.head⁻¹ | null | true |
Lean.Elab.Command.AssertExists.isDecl | Lean.Elab.AssertExists | Lean.Elab.Command.AssertExists → Bool | The type of the assertion: `true` means declaration, `false` means import. | true |
Lean.PrettyPrinter.Delaborator.OmissionReason.string.noConfusion | Lean.PrettyPrinter.Delaborator.Basic | {P : Sort u} →
{s s' : String} →
Lean.PrettyPrinter.Delaborator.OmissionReason.string s = Lean.PrettyPrinter.Delaborator.OmissionReason.string s' →
(s = s' → P) → P | null | false |
Vector.get_ofFn | Batteries.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} (f : Fin n → α) (i : Fin n), (Vector.ofFn f).get i = f i | null | true |
Subgroup.QuotientDiff | Mathlib.GroupTheory.SchurZassenhaus | {G : Type u_1} → [inst : Group G] → (H : Subgroup G) → [IsMulCommutative ↥H] → [H.FiniteIndex] → Type u_1 | The quotient of the transversals of an abelian normal `N` by the `diff` relation. | true |
EIO.tryCatch | Init.System.IO | {ε α : Type} → EIO ε α → (ε → EIO ε α) → EIO ε α | null | true |
Interval.mem_pure | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ∈ Interval.pure a ↔ b = a | null | true |
PositiveLinearMap.instInnerProductSpaceComplexPreGNS | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | {A : Type u_1} →
[inst : NonUnitalRing A] →
[inst_1 : PartialOrder A] →
[inst_2 : Module ℂ A] →
[inst_3 : StarRing A] →
[inst_4 : StarOrderedRing A] →
[inst_5 : SelfAdjointDecompose A] →
[inst_6 : StarModule ℂ A] →
[inst_7 : IsScalarTower ℂ A A] → ... | null | true |
Algebra.IsPushout.cancelBaseChangeAux._proof_13 | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_4) (S : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (A : Type u_2)
[inst_3 : CommRing A] [inst_4 : Algebra R A] (M : Type u_1) [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : Module A M] [inst_8 : IsScalarTower R A M],
LinearMap.CompatibleSMul (Tensor... | null | false |
MeasurableEquiv.Set.prod._proof_3 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_2} {β : Type u_1} (s : Set α) (t : Set β) (a : ↑(s ×ˢ t)), (↑a).2 ∈ t | null | false |
hasSum_of_isGLB_of_nonpos | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α]
[inst_3 : TopologicalSpace α] [OrderTopology α] {f : ι → α} (i : α),
(∀ (i : ι), f i ≤ 0) → IsGLB (Set.range fun s => ∑ i ∈ s, f i) i → HasSum f i | null | true |
Std.Do.ExceptConds.imp.eq_def | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} (x y : Std.Do.ExceptConds ps),
(x →ₑ y) =
match ps, x, y with
| Std.Do.PostShape.pure, x, y => PUnit.unit
| Std.Do.PostShape.arg σ ps, x, y => x →ₑ y
| Std.Do.PostShape.except ε a, x, y => (fun e => spred(x.1 e → y.1 e), x.2 →ₑ y.2) | null | true |
Pi.list_sum_apply | Mathlib.Algebra.BigOperators.Pi | ∀ {α : Type u_7} {M : α → Type u_8} [inst : (a : α) → AddMonoid (M a)] (a : α) (l : List ((a : α) → M a)),
l.sum a = (List.map (fun f => f a) l).sum | null | true |
AlgebraicGeometry.«_aux_Mathlib_AlgebraicGeometry_OpenImmersion___delab_app_AlgebraicGeometry_term_''ᵁ__1» | Mathlib.AlgebraicGeometry.OpenImmersion | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
SimpleGraph.Walk.reverse_reverse | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.reverse.reverse = p | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.KInjective.0.CochainComplex.isKInjective_of_injective_aux._proof_1_5 | Mathlib.Algebra.Homology.HomotopyCategory.KInjective | ∀ (n : ℤ), n + 1 = n + 1 | null | false |
Real.binEntropy_one_sub | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ (p : ℝ), Real.binEntropy (1 - p) = Real.binEntropy p | `binEntropy` is symmetric about 1/2. | true |
CategoryTheory.Adjunction.derived._proof_2 | Mathlib.CategoryTheory.Functor.Derived.Adjunction | ∀ {C₁ : Type u_4} {C₂ : Type u_8} {D₁ : Type u_2} {D₂ : Type u_6} [inst : CategoryTheory.Category.{u_3, u_4} C₁]
[inst_1 : CategoryTheory.Category.{u_7, u_8} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} D₁]
[inst_3 : CategoryTheory.Category.{u_5, u_6} D₂] {G : CategoryTheory.Functor C₁ C₂} {F : CategoryTheory.F... | null | false |
_private.Mathlib.Analysis.Analytic.Order.0.AnalyticOnNhd.codiscrete_setOfPred_analyticOrderAt_eq_zero_or_top._simp_1_3 | Mathlib.Analysis.Analytic.Order | ∀ {α : Type u_1} {f : Filter α} {s : Set α}, Disjoint f (Filter.principal s) = (sᶜ ∈ f) | null | false |
MonoidAlgebra.mapAlgEquiv_apply | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_1) {A : Type u_4} {B : Type u_5} (M : Type u_7) [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Monoid M] (e : A ≃ₐ[R] B)
(a : MonoidAlgebra A M), (MonoidAlgebra.mapAlgEquiv R M e) a = (↑↑(MonoidAlgebra.mapAlgHom M ↑e).toRingH... | null | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGT?.go.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] (k : α) (best : Option (α × β)) (size : ℕ) (k' : α) (v' : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.getEntryGT?.go k best (Std.DTreeMap.Internal.Impl.inner size k' v' l r) =
match compare k k' with
| Ordering.lt => Std.DTr... | null | true |
EReal.recENNReal_coe_ennreal | Mathlib.Data.EReal.Operations | ∀ {motive : EReal → Sort u_1} (coe : (x : ENNReal) → motive ↑x) (neg_coe : (x : ENNReal) → 0 < x → motive (-↑x))
(x : ENNReal), EReal.recENNReal coe neg_coe ↑x = coe x | null | true |
_private.Lean.Compiler.IR.NormIds.0.Lean.IR.NormalizeIds.normFnBody.match_1 | Lean.Compiler.IR.NormIds | (motive : Array Lean.IR.Param × Lean.IR.FnBody → Sort u_1) →
(x : Array Lean.IR.Param × Lean.IR.FnBody) →
((ys : Array Lean.IR.Param) → (v : Lean.IR.FnBody) → motive (ys, v)) → motive x | null | false |
AddEquiv.symm.eq_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} [inst : Add M] [inst_1 : Add N] (h : M ≃+ N),
h.symm = { toEquiv := h.symm, map_add' := ⋯ } | null | true |
_private.Init.Data.List.TakeDrop.0.List.drop_left.match_1_1 | Init.Data.List.TakeDrop | ∀ {α : Type u_1} (motive : List α → List α → Prop) (x x_1 : List α),
(∀ (x : List α), motive [] x) → (∀ (head : α) (l₁ x : List α), motive (head :: l₁) x) → motive x x_1 | null | false |
LieDerivation.SMulBracketCommClass.casesOn | Mathlib.Algebra.Lie.Derivation.Basic | {S : Type u_4} →
{L : Type u_5} →
{α : Type u_6} →
[inst : SMul S α] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup α] →
[inst_3 : LieRingModule L α] →
{motive : LieDerivation.SMulBracketCommClass S L α → Sort u} →
(t : LieDerivation.SMulBracketCo... | null | false |
Partition.rel_rfl_iff | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {x : α} {u : Set α} {P : Partition u}, P.Rel x x ↔ x ∈ u | null | true |
CategoryTheory.PreOneHypercover.Hom.s₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
(self : E.Hom F) → {i j : E.I₀} → E.I₁ i j → F.I₁ (self.s₀ i) (self.s₀ j) | The map between indexing types of the coverings of the fibre products over `S`. | true |
Finset.powersetCard_mono | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} {s t : Finset α}, s ⊆ t → Finset.powersetCard n s ⊆ Finset.powersetCard n t | null | true |
groupHomology.comp_d₂₁_eq | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
CategoryTheory.CategoryStruct.comp (groupHomology.chainsIso₂ A).hom (groupHomology.d₂₁ A) =
CategoryTheory.CategoryStruct.comp ((groupHomology.inhomogeneousChains A).d 2 1) (groupHomology.chainsIso₁ A).hom | Let `C(G, A)` denote the complex of inhomogeneous chains of `A : Rep k G`. This lemma
says `d₂₁` gives a simpler expression for the 1st differential: that is, the following
square commutes:
```
C₂(G, A) --d 2 1--> C₁(G, A)
| |
| |
| |
v ... | true |
CategoryTheory.Precoverage.ZeroHypercover.Small.Index | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Precoverage C} → {S : C} → (E : J.ZeroHypercover S) → [E.Small] → Type w' | The `w'`-index type of a `w'`-small `0`-hypercover. | true |
_private.Mathlib.Analysis.Normed.Ring.Units.0.NormedRing.inverse_add_norm._simp_1_2 | Mathlib.Analysis.Normed.Ring.Units | ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -(a * b) = -a * b | null | false |
Int.mul.eq_2 | Init.Data.Int.Order | ∀ (m_2 n_2 : ℕ), (Int.ofNat m_2).mul (Int.negSucc n_2) = Int.negOfNat (m_2 * n_2.succ) | null | true |
Filter.Germ.map_const | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (l : Filter α) (a : β) (f : β → γ), Filter.Germ.map f ↑a = ↑(f a) | null | true |
CategoryTheory.Limits.pullbackConeOfLeftIso_π_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso f],
(CategoryTheory.Limits.pullbackConeOfLeftIso f g).π.app CategoryTheory.Limits.WalkingCospan.left =
CategoryTheory.CategoryStruct.comp g (CategoryTheory.inv f) | null | true |
Finsupp.mem_rangeSingleton_apply_iff | Mathlib.Data.Finsupp.Interval | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] {f : ι →₀ α} {i : ι} {a : α}, a ∈ f.rangeSingleton i ↔ a = f i | null | true |
Lean.Elab.Term.MVarErrorInfo.noConfusionType | Lean.Elab.Term.TermElabM | Sort u → Lean.Elab.Term.MVarErrorInfo → Lean.Elab.Term.MVarErrorInfo → Sort u | null | false |
WeierstrassCurve.Projective.eval_polynomial_of_Z_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P : Fin 3 → F},
P 2 ≠ 0 →
(MvPolynomial.eval P) W.polynomial / P 2 ^ 3 = Polynomial.evalEval (P 0 / P 2) (P 1 / P 2) W.toAffine.polynomial | null | true |
Matroid.contract_eq_contract_iff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {C₁ C₂ : Set α}, M.contract C₁ = M.contract C₂ ↔ C₁ ∩ M.E = C₂ ∩ M.E | null | true |
_private.Mathlib.MeasureTheory.Measure.SeparableMeasure.0.MeasureTheory.Lp.SecondCountableTopology._abel_5 | Mathlib.MeasureTheory.Measure.SeparableMeasure | ∀ {X : Type u_1} {E : Type u_2} [m : MeasurableSpace X] [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure X}
{p : ENNReal} ⦃f g : X → E⦄ (hf : MeasureTheory.MemLp f p μ) (hg : MeasureTheory.MemLp g p μ)
(bf bg : ↥(MeasureTheory.Lp E p μ)),
MeasureTheory.MemLp.toLp f hf + MeasureTheory.MemLp.toLp g hg - (bf... | null | false |
Stream'.WSeq.map | Mathlib.Data.WSeq.Basic | {α : Type u} → {β : Type v} → (α → β) → Stream'.WSeq α → Stream'.WSeq β | Map a function over a weak sequence | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.incCount | Lean.Meta.LetToHave | Lean.Meta.LetToHave.M✝ Unit | Increments the count of the number of `let`s transformed into `have`s. | true |
Lean.Meta.InductionSubgoal._sizeOf_1 | Lean.Meta.Tactic.Induction | Lean.Meta.InductionSubgoal → ℕ | null | false |
Finsupp.induction | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddZeroClass M] {motive : (ι →₀ M) → Prop} (f : ι →₀ M),
motive 0 →
(∀ (a : ι) (b : M) (f : ι →₀ M), a ∉ f.support → b ≠ 0 → motive f → motive ((fun₀ | a => b) + f)) → motive f | null | true |
TopCat.forget_preservesColimitsOfSize | Mathlib.Topology.Category.TopCat.Limits.Basic | CategoryTheory.Limits.PreservesColimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget TopCat) | null | true |
CategoryTheory.CommGrp.instFullGrpForget₂Grp | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C], (CategoryTheory.CommGrp.forget₂Grp C).Full | null | true |
SubMulAction.orbitRel_of_subMul | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : Group R] [inst_1 : MulAction R M] (p : SubMulAction R M),
MulAction.orbitRel R ↥p = Setoid.comap Subtype.val (MulAction.orbitRel R M) | null | true |
ZNum.addMonoidWithOne | Mathlib.Data.Num.ZNum | AddMonoidWithOne ZNum | null | true |
HasDerivWithinAt.comp_hasDerivAt_of_eq | Mathlib.Analysis.Calculus.Deriv.Comp | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {h : 𝕜 → 𝕜'} {h₂ : 𝕜' → 𝕜'} {h' h₂' y : 𝕜'} {t : Set 𝕜'},
HasDerivWithinAt h₂ h₂' t y →
HasDerivAt h h' x → (∀ᶠ (x' : 𝕜) in nhds x, h x' ∈ t) → y = h x → Ha... | null | true |
Int.le_add_of_neg_le_sub_left | Init.Data.Int.Order | ∀ {a b c : ℤ}, -a ≤ b - c → c ≤ a + b | null | true |
InnerProductSpace.ringOfCoalgebra._proof_17 | Mathlib.Analysis.InnerProductSpace.Coalgebra | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] [inst_4 : Coalgebra 𝕜 E] (n : ℕ), (n + 1).unaryCast = n.unaryCast + 1 | null | false |
PartialOrder.ext_lt | Mathlib.Order.Basic | ∀ {α : Type u_2} {A B : PartialOrder α}, (∀ (x y : α), x < y ↔ x < y) → A = B | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.TwoPowShiftTarget.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | Sort u →
{α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.TwoPowShiftTarget aig w →
{α' : Type} →
[inst' : Hashable α'] →
[inst'_1 :... | null | false |
CategoryTheory.Limits.lim_map | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C] {X Y : CategoryTheory.Functor J C} (α : X ⟶ Y),
CategoryTheory.Limits.lim.map α = CategoryTheory.Limits.limMap α | null | true |
Lean.Server.RpcEncodable.rec | Lean.Server.Rpc.Basic | {α : Type} →
{motive : Lean.Server.RpcEncodable α → Sort u} →
((rpcEncode : α → StateM Lean.Server.RpcObjectStore Lean.Json) →
(rpcDecode : Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) α) →
motive { rpcEncode := rpcEncode, rpcDecode := rpcDecode }) →
(t : Lean.Server.... | null | false |
BoxIntegral.Prepartition.distortion_of_const | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) [inst : Fintype ι] {c : NNReal},
π.boxes.Nonempty → (∀ J ∈ π, J.distortion = c) → π.distortion = c | null | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.uniformSpace_eq_inf_precomp_of_cover._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (s ⊆ f ⁻¹' t) = (f '' s ⊆ t) | null | false |
CategoryTheory.Functor.cartesianMonoidalCategory._proof_7 | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} J]
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : CategoryTheory.Functor J C),
{ app := fun x => CategoryTheory.SemiCartesianMonoidalCategory.snd (X.obj x) (Y.obj x), naturality... | null | false |
SemigroupAction.noConfusion | Mathlib.Algebra.Group.Action.Defs | {P : Sort u} →
{α : Type u_9} →
{β : Type u_10} →
{inst : Semigroup α} →
{t : SemigroupAction α β} →
{α' : Type u_9} →
{β' : Type u_10} →
{inst' : Semigroup α'} →
{t' : SemigroupAction α' β'} →
α = α' → β = β' → inst ≍ inst' → t ≍... | null | false |
sSup_range | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : SupSet α] {f : ι → α}, sSup (Set.range f) = iSup f | null | true |
CategoryTheory.Pi.η_def | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] (i : I),
CategoryTheory.Functor.OplaxMonoidal.η (CategoryTheory.Pi.eval C i) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit... | null | true |
IsPrimitiveRoot.IsCyclotomicExtension.ringOfIntegersOfPrimePow | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p k : ℕ} {K : Type u} [inst : Field K] [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[IsCyclotomicExtension {p ^ k} ℚ K], IsCyclotomicExtension {p ^ k} ℤ (NumberField.RingOfIntegers K) | The ring of integers of a `p ^ k`-th cyclotomic extension of `ℚ` is a cyclotomic extension. | true |
Std.HashSet.Raw.get!_erase | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : Inhabited α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k a : α}, (m.erase k).get! a = if (k == a) = true then default else m.get! a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.