name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DHashMap.Raw.getKeyD_erase | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a fallback : α}, (m.erase k).getKeyD a fallback = if (k == a) = true then fallback else m.getKeyD a fallback | null | true |
Nat.ofDigits_div_pow_eq_ofDigits_drop | Mathlib.Data.Nat.Digits.Defs | ∀ {p : ℕ} (i : ℕ),
0 < p →
∀ (digits : List ℕ), (∀ l ∈ digits, l < p) → Nat.ofDigits p digits / p ^ i = Nat.ofDigits p (List.drop i digits) | Interpreting as a base `p` number and dividing by `p^i` is the same as dropping `i`.
| true |
instIsDirectedOrder | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] [Archimedean R], IsDirectedOrder R | null | true |
Submonoid.closure_eq_one_union | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] (s : Set M), ↑(Submonoid.closure s) = {1} ∪ ↑(Subsemigroup.closure s) | The `Submonoid.closure` of a set is the union of `{1}` and its `Subsemigroup.closure`. | true |
ZSpan.ceil | Mathlib.Algebra.Module.ZLattice.Basic | {E : Type u_1} →
{ι : Type u_2} →
{K : Type u_3} →
[inst : NormedField K] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace K E] →
(b : Module.Basis ι K E) →
[inst_3 : LinearOrder K] →
[IsStrictOrderedRing K] → [FloorRing K] → [Fintype ι] →... | The map that sends a vector of `E` to the element of the ℤ-lattice spanned by `b` obtained
by rounding up its coordinates on the basis `b`. | true |
Mathlib.Meta.FunProp.Mor.isCoeFun | Mathlib.Tactic.FunProp.Mor | Lean.Expr → Lean.MetaM Bool | Is `e` a coercion from some function space to functions? | true |
eq_zero_of_sameRay_neg_smul_right | Mathlib.LinearAlgebra.Ray | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {x : M} [IsDomain R] [Module.IsTorsionFree R M] {r : R},
r < 0 → SameRay R x (r • x) → x = 0 | null | true |
SupHom.dual_comp | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Max α] [inst_1 : Max β] [inst_2 : Max γ] (g : SupHom β γ)
(f : SupHom α β), SupHom.dual (g.comp f) = (SupHom.dual g).comp (SupHom.dual f) | null | true |
_private.Std.Do.WP.Sound.0.Std.Do.instWPSoundExceptTExceptPureOfLawfulMonad.match_1.eq_1 | Std.Do.WP.Sound | ∀ {ε α : Type u_1} (motive : Except ε α → Sort u_2) (a : α) (h_1 : (a : α) → motive (Except.ok a))
(h_2 : (a : ε) → motive (Except.error a)),
(match Except.ok a with
| Except.ok a => h_1 a
| Except.error a => h_2 a) =
h_1 a | null | true |
LocallyFiniteOrder.addMonoidHom._proof_1 | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | ∀ (G : Type u_1) [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : LocallyFiniteOrder G],
↑(Finset.Ico 0 0).card - ↑(Finset.Ico 0 (-0)).card = 0 | null | false |
TopologicalSpace.Opens.mapComp_hom_app | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : TopologicalSpace.Opens ↑Z),
(TopologicalSpace.Opens.mapComp f g).hom.app U = CategoryTheory.eqToHom ⋯ | null | true |
CentroidHom.centerToCentroid_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] (z : ↥(NonUnitalSubsemiring.center α)) (a : α),
(CentroidHom.centerToCentroid z) a = ↑z * a | null | true |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.quadrant_II._simp_1_3 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a : α}, (-a < 0) = (0 < a) | null | false |
_private.Lean.Meta.Sym.AlphaShareBuilder.0.Lean.Expr.updateLetS!._sparseCasesOn_1 | Lean.Meta.Sym.AlphaShareBuilder | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Functor.preservesFiniteColimits_of_preservesHomology | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive] [F.PreservesHomology]
[CategoryTheory.Limits.HasZeroO... | An additive which preserves homology preserves finite colimits. | true |
LinearMap.submoduleComap_apply_coe | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
(f : M →ₛₗ[σ₁₂] M₂) (q : Submodule R₂ M₂) (c : ↥(Submodule.comap f q)), ↑((f.submoduleComap... | null | true |
Profinite.NobelingProof.π | Mathlib.Topology.Category.Profinite.Nobeling.Basic | {I : Type u} → Set (I → Bool) → (J : I → Prop) → [(i : I) → Decidable (J i)] → Set (I → Bool) | The image of `Proj π J` | true |
AlgebraicTopology.DoldKan.N₁_obj_X | Mathlib.AlgebraicTopology.DoldKan.FunctorN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C),
(AlgebraicTopology.DoldKan.N₁.obj X).X = AlgebraicTopology.AlternatingFaceMapComplex.obj X | null | true |
isSigmaCompact_iff_isSigmaCompact_univ | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsSigmaCompact s ↔ IsSigmaCompact Set.univ | A subset `s` is σ-compact iff `s` (with the subspace topology) is a σ-compact space. | true |
PowerBasis.finite | Mathlib.RingTheory.PowerBasis | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (pb : PowerBasis R S),
Module.Finite R S | Cannot be an instance because `PowerBasis` cannot be a class. | true |
List.sum_le_sum | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddRightMono M] [AddLeftMono M] {l : List ι}
{f g : ι → M}, (∀ i ∈ l, f i ≤ g i) → (List.map f l).sum ≤ (List.map g l).sum | null | true |
Lean.PrettyPrinter.Formatter.checkNoWsBefore.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter | null | true |
MeasureTheory.Lp.instNormedAddCommGroup._proof_5 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (r : ↥(MeasureTheory.Lp E p μ)), ‖-r‖ = ‖r‖ | null | false |
exists_pow_lt₀ | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} [inst : LinearOrderedCommGroupWithZero G] [MulArchimedean G] {a : G},
a < 1 → ∀ (b : Gˣ), ∃ n, a ^ n < ↑b | null | true |
MvPolynomial.pderiv_C | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} {a : R} [inst : CommSemiring R] {i : σ}, (MvPolynomial.pderiv i) (MvPolynomial.C a) = 0 | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Projection.Reflection.0.Submodule.«_aux_Mathlib_Analysis_InnerProductSpace_Projection_Reflection___macroRules__private_Mathlib_Analysis_InnerProductSpace_Projection_Reflection_0_Submodule_term⟪_,_⟫_1» | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | Lean.Macro | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.sum_bernoulli'._simp_1_1 | Mathlib.NumberTheory.Bernoulli | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
MeasureTheory.vaddInvariantMeasure_map_vadd | Mathlib.MeasureTheory.Group.Action | ∀ {M : Type uM} {N : Type uN} {α : Type uα} [inst : MeasurableSpace α] [inst_1 : VAdd M α] [inst_2 : VAdd N α]
[VAddCommClass N M α] [MeasurableConstVAdd M α] [MeasurableConstVAdd N α] (μ : MeasureTheory.Measure α)
[MeasureTheory.VAddInvariantMeasure M α μ] (n : N),
MeasureTheory.VAddInvariantMeasure M α (Measure... | null | true |
CategoryTheory.Limits.Types.coneOfSection | Mathlib.CategoryTheory.Limits.Types.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
{F : CategoryTheory.Functor J (Type u)} → {s : (j : J) → F.obj j} → s ∈ F.sections → CategoryTheory.Limits.Cone F | Given a section of a functor F into `Type*`,
construct a cone over F with `PUnit` as the cone point. | true |
CategoryTheory.Iso.toIsometryEquiv_toFun | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u} [inst : CommRing R] {X Y : QuadraticModuleCat R} (i : X ≅ Y) (a : ↑X.toModuleCat),
i.toIsometryEquiv a = (QuadraticModuleCat.Hom.toIsometry i.hom) a | null | true |
StieltjesFunction.add_apply | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f g : StieltjesFunction R) (x : R),
↑(f + g) x = ↑f x + ↑g x | null | true |
Array.instLE | Init.Data.Array.Basic | {α : Type u} → [LT α] → LE (Array α) | null | true |
Nat.not_dvd_ordCompl | Mathlib.Data.Nat.Factorization.Basic | ∀ {n p : ℕ}, Nat.Prime p → n ≠ 0 → ¬p ∣ n / p ^ n.factorization p | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.skipSuffixWhile_eq_endPos._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.BackwardPattern pat] {s : String},
s.endsWith pat = s.toSlice.endsWith pat | null | false |
MulLEAddHomClass.rec | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_4} →
{α : Type u_5} →
{β : Type u_6} →
[inst : Mul α] →
[inst_1 : Add β] →
[inst_2 : LE β] →
[inst_3 : FunLike F α β] →
{motive : MulLEAddHomClass F α β → Sort u} →
((map_mul_le_add : ∀ (f : F) (a b : α), f (a * b) ≤ f a + f b) → motive... | null | false |
Std.LawfulRightIdentity.mk | Init.Core | ∀ {α : Sort u} {β : Sort u_1} {op : α → β → α} {o : outParam β} [toRightIdentity : Std.RightIdentity op o],
(∀ (a : α), op a o = a) → Std.LawfulRightIdentity op o | null | true |
ChainComplex.of._proof_3 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
{α : Type u_3} [inst_2 : AddRightCancelSemigroup α] [inst_3 : One α] [inst_4 : DecidableEq α] (X : α → V)
(d : (n : α) → X (n + 1) ⟶ X n),
(∀ (n : α), CategoryTheory.CategoryStruct.comp (d (n + 1)) (... | null | false |
CategoryTheory.Functor.mapAction_obj_V | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} W] (F : CategoryTheory.Functor V W) (G : Type u_3) [inst_2 : Monoid G]
(M : Action V G), ((F.mapAction G).obj M).V = F.obj M.V | null | true |
Lean.Meta.Grind.setENode | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Meta.Grind.ENode → Lean.Meta.Grind.GoalM Unit | null | true |
CategoryTheory.SimplicialObject.Split.casesOn | Mathlib.AlgebraicTopology.SimplicialObject.Split | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.SimplicialObject.Split C → Sort u} →
(t : CategoryTheory.SimplicialObject.Split C) →
((X : CategoryTheory.SimplicialObject C) → (s : X.Splitting) → motive { X := X, s := s }) → motive t | null | false |
Turing.ToPartrec.Code.rec._@.Mathlib.Computability.TuringMachine.ToPartrec.3125930148._hygCtx._hyg.3 | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.ToPartrec.Code → Sort u} →
motive Turing.ToPartrec.Code.zero' →
motive Turing.ToPartrec.Code.succ →
motive Turing.ToPartrec.Code.tail →
((a a_1 : Turing.ToPartrec.Code) → motive a → motive a_1 → motive (a.cons a_1)) →
((a a_1 : Turing.ToPartrec.Code) → motive a → motive a_... | null | false |
List.foldr_range_eq_of_range_eq | Mathlib.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → α → α} {g : γ → α → α},
Set.range f = Set.range g → ∀ (a : α), Set.range (List.foldr f a) = Set.range (List.foldr g a) | null | true |
ENat.mul_iInf' | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_2} {f : ι → ℕ∞} {a : ℕ∞}, (a = 0 → Nonempty ι) → a * ⨅ i, f i = ⨅ i, a * f i | A version of `mul_iInf` with a slightly more general hypothesis. | true |
NonUnitalSubalgebra.topologicalClosure._proof_1 | Mathlib.Topology.Algebra.NonUnitalAlgebra | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : NonUnitalSemiring A] [IsSemitopologicalSemiring A],
ContinuousAdd A | null | false |
UniqueFactorizationMonoid | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | (α : Type u_2) → [CommMonoidWithZero α] → Prop | Unique factorization monoids are defined as cancellative `CommMonoidWithZero`s with well-founded
strict divisibility relations, but this is equivalent to more familiar definitions:
Each element (except zero) is uniquely represented as a multiset of irreducible factors.
Uniqueness is only up to associated elements.
Ea... | true |
Rep.instConcreteCategoryIntertwiningMapVρ._proof_4 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_2} {G : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] {X Y Z : Rep.{u_1, u_2, u_3} k G} (f : X ⟶ Y)
(g : Y ⟶ Z) (x : ↑X), (CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | null | false |
Fin.decodeEmpty | Batteries.Data.Fin.Coding | Fin 0 → Empty | Decode `Empty` from `Fin 0`. | true |
TrivSqZeroExt.inr_injective | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : Zero R], Function.Injective TrivSqZeroExt.inr | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceMod._regBuiltin.Int32.reduceMod.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.158 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
ClosedSubmodule.orthogonal_orthogonal_eq | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : ClosedSubmodule 𝕜 E) [(↑K).HasOrthogonalProjection], Kᗮᗮ = K | null | true |
HomologicalComplex.mapBifunctor₁₂.d₁ | Mathlib.Algebra.Homology.BifunctorAssociator | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₁₂ : Type u_3} →
{C₃ : Type u_5} →
{C₄ : Type u_6} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] →
[inst_... | The first differential on a summand
of `mapBifunctor (mapBifunctor K₁ K₂ F₁₂ c₁₂) K₃ G c₄`. | true |
SSet.skeletonOfMono_obj_eq_top | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {X Y : SSet} (i : X ⟶ Y) {d n : ℕ}, d < n → ((SSet.skeletonOfMono i) n).obj (Opposite.op { len := d }) = ⊤ | null | true |
CategoryTheory.GrothendieckTopology.mk.noConfusion | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{P : Sort u_1} →
{sieves : (X : C) → Set (CategoryTheory.Sieve X)} →
{top_mem' : ∀ (X : C), ⊤ ∈ sieves X} →
{pullback_stable' :
∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve X⦄ (f : Y ⟶ X),
S ∈ sieves X → Cate... | null | false |
IsUniformAddGroup.to_topologicalAddGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α], IsTopologicalAddGroup α | **Alias** of `IsUniformAddGroup.isTopologicalAddGroup`. | true |
Birkhoff_inequalities | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b c : α),
|a ⊔ c - b ⊔ c| ⊔ |a ⊓ c - b ⊓ c| ≤ |a - b| | null | true |
AbsoluteValue.instSetoid | Mathlib.Analysis.AbsoluteValue.Equivalence | {R : Type u_1} →
[inst : Semiring R] → {S : Type u_2} → [inst_1 : Semiring S] → [inst_2 : PartialOrder S] → Setoid (AbsoluteValue R S) | null | true |
BddLat.Hom.casesOn | Mathlib.Order.Category.BddLat | {X Y : BddLat} →
{motive : X.Hom Y → Sort u_1} →
(t : X.Hom Y) → ((hom' : BoundedLatticeHom ↑X.toLat ↑Y.toLat) → motive { hom' := hom' }) → motive t | null | false |
FormalMultilinearSeries.le_radius_of_summable_norm | Mathlib.Analysis.Analytic.ConvergenceRadius | ∀ {𝕜 : Type u_1} {E : Type u_3} {F : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {r : NNReal}
(p : FormalMultilinearSeries 𝕜 E F), (Summable fun n => ‖p n‖ * ↑r ^ n) → ↑r ≤ p.radius | null | true |
Std.Sat.AIG.BinaryRefVec.rhs_get_cast | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig1 aig2 : Std.Sat.AIG α}
(s : aig1.BinaryRefVec len) (idx : ℕ) (hidx : idx < len) (hcast : aig1.decls.size ≤ aig2.decls.size),
(s.cast hcast).rhs.get idx hidx = (s.rhs.get idx hidx).cast hcast | null | true |
Ordinal.veblenWith.match_1 | Mathlib.SetTheory.Ordinal.Veblen | (o : Ordinal.{u_1}) →
(motive : { x // x ∈ Set.Iio o } → Sort u_2) →
(x : { x // x ∈ Set.Iio o }) → ((x : Ordinal.{u_1}) → (property : x ∈ Set.Iio o) → motive ⟨x, property⟩) → motive x | null | false |
gal_zero_isSolvable | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} [inst : Field F], Group.IsSolvable (Polynomial.Gal 0) | null | true |
hnot_le_iff_codisjoint_right | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, ￢b ≤ a ↔ Codisjoint b a | null | true |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.Decl.extractClosed.match_1 | Lean.Compiler.LCNF.ExtractClosed | (motive : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure × Lean.Compiler.LCNF.ExtractClosed.State → Sort u_1) →
(x : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure × Lean.Compiler.LCNF.ExtractClosed.State) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) →
(s : Lean.Compi... | null | false |
LinearMap.instModuleDomMulActOfSMulCommClass._proof_1 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_2} {R' : Type u_3} {S : Type u_1} {M : Type u_4} {M' : Type u_5} [inst : Semiring R]
[inst_1 : Semiring R'] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M]
[inst_5 : Module R' M'] {σ₁₂ : R →+* R'} [inst_6 : Semiring S] [inst_7 : Module S M] [inst_8 : SMulCommClass R S M]
... | null | false |
Finite.Set.finite_replacement | Mathlib.Data.Set.Finite.Range | ∀ {α : Type u} {β : Type v} [Finite α] (f : α → β), Finite ↑{x | ∃ x_1, f x_1 = x} | null | true |
SSet.Subcomplex.Pairing.pairingCore._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) [inst : P.IsProper] {s t : ↑P.II},
{ dim := (↑s).dim + 1, simplex := ((↑(P.p s)).cast ⋯).simplex } =
{ dim := (↑t).dim + 1, simplex := ((↑(P.p t)).cast ⋯).simplex } →
s = t | null | false |
convexOn_norm | Mathlib.Analysis.Normed.Module.Convex | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E},
Convex ℝ s → ConvexOn ℝ s norm | The norm on a real normed space is convex on any convex set. See also `Seminorm.convexOn`
and `convexOn_univ_norm`. | true |
_private.Mathlib.Probability.Kernel.RadonNikodym.0.ProbabilityTheory.Kernel.singularPart_compl_mutuallySingularSetSlice._simp_1_8 | Mathlib.Probability.Kernel.RadonNikodym | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
TopologicalSpace.OpenNhdsOf.instMax | Mathlib.Topology.Sets.Opens | {α : Type u_2} → [inst : TopologicalSpace α] → {x : α} → Max (TopologicalSpace.OpenNhdsOf x) | null | true |
AddGroupExtension.Equiv.Simps.symm_apply.eq_1 | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup E] [inst_2 : AddGroup G]
{S : AddGroupExtension N E G} {E' : Type u_4} [inst_3 : AddGroup E'] {S' : AddGroupExtension N E' G}
(equiv : S.Equiv S'), AddGroupExtension.Equiv.Simps.symm_apply equiv = ⇑equiv.symm | null | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (p : Int.Internal.Linear.Poly) (h : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof),
sizeOf { p := p, h := h } = 1 + sizeOf p + sizeOf h | null | true |
ZeroHom.ctorIdx | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} → {N : Type u_11} → {inst : Zero M} → {inst_1 : Zero N} → ZeroHom M N → ℕ | null | false |
Std.HashSet.Raw.any_eq_not_all_not | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] {p : α → Bool},
m.WF → m.any p = !m.all fun a => !p a | null | true |
Std.DTreeMap.Internal.Cell.of | Std.Data.DTreeMap.Internal.Cell | {α : Type u} → {β : α → Type v} → [inst : Ord α] → (k : α) → β k → Std.DTreeMap.Internal.Cell α β (compare k) | Create a cell with a matching key. Internal implementation detail of the tree map | true |
MeasureTheory.AddContent.mk.injEq | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommMonoid G] {C : Set (Set α)} (toFun : Set α → G) (empty' : toFun ∅ = 0)
(sUnion' : ∀ (I : Finset (Set α)), ↑I ⊆ C → (↑I).PairwiseDisjoint id → ⋃₀ ↑I ∈ C → toFun (⋃₀ ↑I) = ∑ u ∈ I, toFun u)
(toFun_1 : Set α → G) (empty'_1 : toFun_1 ∅ = 0)
(sUnion'_1 :
∀ (I : Finset... | null | true |
PosNum.land._f | Mathlib.Data.Num.Bitwise | (x : PosNum) → PosNum.below (motive := fun x => PosNum → Num) x → PosNum → Num | null | false |
Filter.mem_comap._simp_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {g : Filter β} {m : α → β} {s : Set α}, (s ∈ Filter.comap m g) = ∃ t ∈ g, m ⁻¹' t ⊆ s | null | false |
_private.Lean.Meta.Tactic.Constructor.0.Lean.MVarId.existsIntro._sparseCasesOn_2 | Lean.Meta.Tactic.Constructor | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Graded.equiv_symm_apply_coe | Mathlib.Algebra.GradedFunLike | ∀ {E : Type u_1} {A : Type u_2} {B : Type u_3} {σ : Type u_4} {τ : Type u_5} {ι : Type u_6} [inst : SetLike σ A]
[inst_1 : SetLike τ B] {𝒜 : ι → σ} {ℬ : ι → τ} [inst_2 : EquivLike E A B] [inst_3 : GradedEquivLike E 𝒜 ℬ] (e : E)
(i : ι) (y : ↥(ℬ i)), ↑((Graded.equiv e i).symm y) = EquivLike.inv e ↑y | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | {γ : Type u_1} →
(motive : Option γ → Sort u_2) →
(__do_lift : Option γ) → (Unit → motive none) → ((fb : γ) → motive (some fb)) → motive __do_lift | null | true |
CategoryTheory.inhabitedLiftableCocone | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
(c : CategoryTheory.Limits.Cocone (K.comp (CategoryTheory.Functor.id C))) →
Inhabited (CategoryTheory.LiftableCocone K ... | null | true |
_private.Mathlib.Algebra.Homology.DerivedCategory.TStructure.0.DerivedCategory.TStructure.t._proof_6 | Mathlib.Algebra.Homology.DerivedCategory.TStructure | 0 ≤ 1 | null | false |
R1Space.specializes_or_disjoint_nhds | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_3} {inst : TopologicalSpace X} [self : R1Space X] (x y : X), x ⤳ y ∨ Disjoint (nhds x) (nhds y) | null | true |
Aesop.Frontend.Feature.elab._unsafe_rec | Aesop.Frontend.RuleExpr | Lean.Syntax → Aesop.ElabM Aesop.Frontend.Feature | null | false |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT.0.CategoryTheory.Triangulated.TStructure.isLE_truncLE_obj._proof_1_1 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ (a b : ℤ), a ≤ b → a + 1 ≤ b + 1 | null | false |
Set.self_mem_Iic | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, a ∈ Set.Iic a | null | true |
Submonoid.center.commMonoid'.eq_1 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : MulOneClass M],
Submonoid.center.commMonoid' =
{ toOne := (Submonoid.center M).toMulOneClass.toOne, toMul := (Submonoid.center M).toMulOneClass.toMul,
mul_assoc := ⋯, one_mul := ⋯, mul_one := ⋯, npow := npowRecAuto, npow_zero := ⋯, npow_succ := ⋯, mul_comm := ⋯ } | null | true |
SimpleGraph.IsFiveWheelLike.card_right | Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | ∀ {α : Type u_1} {s : Finset α} {G : SimpleGraph α} {r k : ℕ} [inst : DecidableEq α] {v w₁ w₂ : α} {t : Finset α},
G.IsFiveWheelLike r k v w₁ w₂ s t → t.card = r | null | true |
Lean.Elab.Term.instToStringArg.match_1 | Lean.Elab.Arg | (motive : Lean.Elab.Term.Arg → Sort u_1) →
(x : Lean.Elab.Term.Arg) →
((stx : Lean.Syntax) → motive (Lean.Elab.Term.Arg.stx stx)) →
((e : Lean.Expr) → motive (Lean.Elab.Term.Arg.expr e)) → motive x | null | false |
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith_mk_mul._proof_1_10 | Mathlib.GroupTheory.FreeGroup.Orbit | ∀ {α : Type u_1} [inst : DecidableEq α] {w : α × Bool} (g : FreeGroup α) (hC : 0 < g.toWord.length),
(g.toWord[0].1 = w.1 → g.toWord[0].2 = w.2) →
(List.rec [w] (fun head tail tail_ih => if w.1 = head.1 ∧ w.2 = !head.2 then tail else w :: head :: tail)
(g.toWord.head ⋯ :: g.toWord.tail))[0]? =
som... | null | false |
_private.Mathlib.Tactic.Explode.Pretty.0.Mathlib.Explode.rowToMessageData.match_1 | Mathlib.Tactic.Explode.Pretty | (motive : Mathlib.Explode.Status → Sort u_1) →
(x : Mathlib.Explode.Status) →
(Unit → motive Mathlib.Explode.Status.sintro) →
(Unit → motive Mathlib.Explode.Status.intro) →
(Unit → motive Mathlib.Explode.Status.cintro) →
(Unit → motive Mathlib.Explode.Status.lam) → (Unit → motive Mathlib.E... | null | false |
WithBot.ofDual_le_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x : WithBot αᵒᵈ} {y : WithTop α}, WithBot.ofDual x ≤ y ↔ WithTop.toDual y ≤ x | null | true |
AlgebraicGeometry.Scheme.instIsOpenImmersionMapOfHomAwayAlgebraMap | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {R : Type u_1} [inst : CommRing R] (f : R),
AlgebraicGeometry.IsOpenImmersion
(AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R (Localization.Away f)))) | null | true |
Matrix.adjugate_conjTranspose | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : Matrix n n α), A.adjugate.conjTranspose = A.conjTranspose.adjugate | null | true |
CategoryTheory.GradedNatTrans.naturality_assoc | Mathlib.CategoryTheory.Enriched.Basic | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₂} [inst_3 : CategoryTheory.EnrichedCategory V D]
{A : CategoryTheory.Center V} {F G : CategoryTheory.EnrichedFunctor V C D}
(self : Categor... | `app` is a natural transformation. | true |
Submodule.smithNormalFormOfLE._proof_7 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(N O : Submodule R M) (n : ℕ)
(x : ∃ o, ∃ (hno : n ≤ o), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.castLE hno i))),
∃ (hno : n ≤ Classical.choose x), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.ca... | null | false |
DyckWord.le_add_self | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p q : DyckWord), q ≤ p + q | null | true |
CategoryTheory.Bicategory.Adj.Bicategory.associator_hom_τl | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : CategoryTheory.Bicategory.Adj B} (α : a ⟶ b) (β : b ⟶ c)
(γ : c ⟶ d),
(CategoryTheory.Bicategory.Adj.Bicategory.associator α β γ).hom.τl =
(CategoryTheory.Bicategory.associator α.l β.l γ.l).hom | null | true |
NonAssocRing.mk._flat_ctor | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
(zero : α) →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), 0 • x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n ... | null | false |
upperSemicontinuousOn_iff_restrict._simp_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
UpperSemicontinuous (s.domRestrict f) = UpperSemicontinuousOn f s | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.