name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
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 |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.length_eq_match_step.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type u_1} (motive : Std.IterStep (Std.Iter β) β → Sort u_2) (it' : Std.Iter β)
(h_1 : (it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.Iter β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.skip it' with
| Std.Iter... | 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 |
Continuous.of_inv | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [ContinuousInv G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous f⁻¹ → Continuous f | **Alias** of the forward direction of `continuous_inv_iff`. | true |
FormalMultilinearSeries.prod.eq_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u} {E : Type v} {F : Type w} {G : Type x} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E]
[inst_6 : AddCommMonoid F] [inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : Continu... | null | true |
_private.Aesop.Stats.Basic.0.Aesop.profiling.match_1 | Aesop.Stats.Basic | {α : Type} →
(motive : α × Aesop.Nanos → Sort u_1) →
(__discr : α × Aesop.Nanos) → ((result : α) → (elapsed : Aesop.Nanos) → motive (result, elapsed)) → motive __discr | null | false |
Multipliable.div | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} {L : SummationFilter β} [inst : CommGroup α] [inst_1 : TopologicalSpace α]
[IsTopologicalGroup α] {f g : β → α}, Multipliable f L → Multipliable g L → Multipliable (fun b => f b / g b) L | null | true |
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 |
LinearMap.HasFiniteRange.of_isNoetherian_rng | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_4} [inst : Semiring K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V]
[inst_3 : AddCommMonoid V₂] [inst_4 : Module K V₂] [IsNoetherian K V₂] {f : V →ₗ[K] V₂}, f.HasFiniteRange | null | true |
LieSubmodule.toSubmodule_eq_bot._simp_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M), (↑N = ⊥) = (N = ⊥) | null | false |
_private.Mathlib.RepresentationTheory.Continuous.TopRep.0.TopRep.mk.inj | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u} {G : Type v} {inst : TopologicalSpace k} {inst_1 : Ring k} {inst_2 : IsTopologicalRing k}
{inst_3 : Monoid G} {V : Type w} {hV1 : AddCommGroup V} {hV2 : Module k V} {hV3 : TopologicalSpace V}
{hV4 : IsTopologicalAddGroup V} {hV5 : ContinuousSMul k V} {ρ : ContRepresentation k G V} {V_1 : Type w}
{h... | null | 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 |
LinearEquiv.sumArrowLequivProdArrow_apply_fst | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_5}
{β : Type u_6} (f : α ⊕ β → M) (a : α), ((LinearEquiv.sumArrowLequivProdArrow α β R M) f).1 a = f (Sum.inl a) | null | true |
_private.Lean.Elab.SetOption.0.Lean.Elab.elabSetOption.match_1 | Lean.Elab.SetOption | (motive : Lean.Syntax → Sort u_1) →
(val : Lean.Syntax) →
((info : Lean.SourceInfo) → motive (Lean.Syntax.atom info "true")) →
((info : Lean.SourceInfo) → motive (Lean.Syntax.atom info "false")) → ((x : Lean.Syntax) → motive x) → motive val | 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 |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.getHaveTelescopeInfo.collect._f | Lean.Meta.HaveTelescope | (e : Lean.Expr) →
Lean.Expr.below (motive := fun e =>
ℕ → Lean.Meta.HaveTelescopeInfo → Lean.LocalContext → Array Lean.Expr → Lean.MetaM Lean.Meta.HaveTelescopeInfo)
e →
ℕ → Lean.Meta.HaveTelescopeInfo → Lean.LocalContext → Array Lean.Expr → Lean.MetaM Lean.Meta.HaveTelescopeInfo | null | false |
SemiRingCat.limitSemiring._proof_22 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections],
autoParam
(∀ (x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt),
... | null | false |
Ideal.Filtration.smul_le | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(self : I.Filtration M) (i : ℕ), I • self.N i ≤ self.N (i + 1) | null | 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.Eqns.0.Lean.Meta.getEqnsFnsRef | Lean.Meta.Eqns | IO.Ref (List Lean.Meta.GetEqnsFn) | null | true |
CuspForm.ofMulDiscriminant._proof_3 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | (Matrix.SpecialLinearGroup.mapGL ℝ).range.HasDetPlusMinusOne | null | false |
CategoryTheory.Limits.kernelCompMono_hom | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) [inst_2 : CategoryTheory.Limits.HasKernel f] [inst_3 : CategoryTheory.Mono g],
(CategoryTheory.Limits.kernelCompMono f g).hom =
CategoryTheory.Limits.kernel.lift f (Ca... | null | true |
_private.Lean.Elab.Deriving.Basic.0.Lean.Elab.Term.processDefDeriving._sparseCasesOn_22 | Lean.Elab.Deriving.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | 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 |
Lean.Parser.Tactic.Conv.occsWildcard | Init.Conv | Lean.ParserDescr | The `*` occurrence list means to apply to all occurrences of the pattern. | true |
_private.Mathlib.Order.Interval.Finset.Gaps.0.Finset.intervalGapsWithin_fst_le_snd._proof_1_13 | Mathlib.Order.Interval.Finset.Gaps | ∀ {α : Type u_1} (F : Finset (α × α)) {k : ℕ}, ∀ j < k + 1, k - 1 + 1 = k → ¬j - 1 < k → False | null | false |
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 α | null | 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 |
Real.sqPartialHomeomorph._proof_4 | Mathlib.Analysis.SpecialFunctions.Sqrt | ∀ x ∈ Set.Ioi 0, √x ^ 2 = x | null | false |
_private.Plausible.Gen.0.Plausible.instReprGenError.repr.match_1 | Plausible.Gen | (motive : Plausible.GenError → Sort u_1) →
(x : Plausible.GenError) → ((a : String) → motive (Plausible.GenError.genError a)) → motive x | null | false |
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_2} {F : Type u_3} [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 |
MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image | Mathlib.MeasureTheory.Function.Jacobian | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] {s : Set E}
{f : E → E} {f' : E → E →L[ℝ] E} [inst_3 : MeasurableSpace E] [BorelSpace E] (μ : MeasureTheory.Measure E)
[μ.IsAddHaarMeasure],
MeasurableSet s →
(∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) →
Set... | null | true |
gal_zero_isSolvable | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} [inst : Field F], IsSolvable (Polynomial.Gal 0) | null | true |
HasDerivWithinAt.neg | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
HasDerivWithinAt f f' s x → HasDerivWithinAt (-f) (-f') s x | null | true |
CStarAlgebra.toCompleteSpace | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [self : CStarAlgebra A], CompleteSpace A | null | true |
hnot_le_iff_codisjoint_right | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, ￢a ≤ b ↔ Codisjoint a b | null | true |
Finset.recOn | Mathlib.Data.Finset.Defs | {α : Type u_4} →
{motive : Finset α → Sort u} →
(t : Finset α) → ((val : Multiset α) → (nodup : val.Nodup) → motive { val := val, nodup := nodup }) → motive t | null | false |
IsometryEquiv.toRealLinearIsometryEquivOfMapZero._proof_7 | Mathlib.Analysis.Normed.Affine.MazurUlam | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] (f : E ≃ᵢ F),
Function.LeftInverse f.invFun f.toFun | null | false |
GroupExtension.Section.exists_mul_eq_inl_mul_mul | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ : S.Section) (g₁ g₂ : G), ∃ n, σ (g₁ * g₂) = S.inl n * σ g₁ * σ g₂ | null | true |
ContinuousLinearEquiv.restrictScalars_toLinearEquiv | Mathlib.Topology.Algebra.Module.Equiv | ∀ (R : Type u_1) {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [inst_4 : Module S M] [inst_5 : TopologicalSpace M] [inst_6 : LinearMap.CompatibleSMul M M R S]
(f : M ≃L[S] M), ↑(ContinuousLinearEquiv.restrictScalars R f) = LinearEquiv.restri... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceAnd._regBuiltin.BitVec.reduceAnd.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.1101098136._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getLsbD_sshiftRight._simp_1_2 | Init.Data.BitVec.Lemmas | ∀ {a b : Bool}, (b = (a && b)) = (b = true → a = true) | 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 |
List.sublists'Aux.eq_1 | Mathlib.Data.List.Sublists | ∀ {α : Type u} (a : α) (r₁ r₂ : List (List α)), List.sublists'Aux a r₁ r₂ = List.foldl (fun r l => r ++ [a :: l]) r₂ r₁ | null | true |
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 |
Mathlib.Tactic.tacticApply_At_ | Mathlib.Tactic.ApplyAt | Lean.ParserDescr | `apply t at i` uses forward reasoning with `t` at the hypothesis `i`.
Explicitly, if `t : α₁ → ⋯ → αᵢ → ⋯ → αₙ` and `i` has type `αᵢ`, then this tactic adds
metavariables/goals for any terms of `αⱼ` for `j = 1, …, i-1`,
then replaces the type of `i` with `αᵢ₊₁ → ⋯ → αₙ` by applying those metavariables and the
original ... | true |
Subfield.extendScalars_toSubfield | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {L : Type u_2} [inst : Field L] {F E : Subfield L} (h : F ≤ E), (Subfield.extendScalars h).toSubfield = E | 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 |
CategoryTheory.Pretriangulated.isomorphic_distinguished | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Limits.HasZeroObject C}
{inst_2 : CategoryTheory.HasShift C ℤ} {inst_3 : CategoryTheory.Preadditive C}
{inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive} [self : CategoryTheory.Pretriangulated C],
∀ T₁ ∈ CategoryTheory... | a triangle that is isomorphic to a distinguished triangle is distinguished | true |
Std.HashMap.Raw.Equiv.insertIfNew | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ (k : α) (v : β), m₁.Equiv m₂ → (m₁.insertIfNew k v).Equiv (m₂.insertIfNew k v) | null | true |
_private.Mathlib.MeasureTheory.Function.JacobianOneDim.0.MeasureTheory.integral_Icc_deriv_smul_of_deriv_nonpos._proof_1_2 | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {f : ℝ → ℝ} {a b : ℝ}, f '' Set.Ioo a b \ f '' Set.Icc a b = ∅ | null | false |
_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 |
Submodule.involutivePointwiseNeg._proof_1 | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(_S : Submodule R M), - -_S = _S | null | false |
TopologicalSpace.OpenNhdsOf.instMax | Mathlib.Topology.Sets.Opens | {α : Type u_2} → [inst : TopologicalSpace α] → {x : α} → Max (TopologicalSpace.OpenNhdsOf x) | null | true |
AddConGen.Rel.casesOn | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {r : M → M → Prop} {motive : (a a_1 : M) → AddConGen.Rel r a a_1 → Prop} {a a_1 : M}
(t : AddConGen.Rel r a a_1),
(∀ (x y : M) (a : r x y), motive x y ⋯) →
(∀ (x : M), motive x x ⋯) →
(∀ {x y : M} (a : AddConGen.Rel r x y), motive y x ⋯) →
(∀ {x y z : M} (a : AddCon... | null | false |
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.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 |
Module.Basis.flag_le_ker_coord_iff | Mathlib.LinearAlgebra.Basis.Flag | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {n : ℕ}
[Nontrivial R] (b : Module.Basis (Fin n) R M) {k : Fin (n + 1)} {l : Fin n},
b.flag k ≤ (b.coord l).ker ↔ k ≤ l.castSucc | null | true |
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 |
MeasureTheory.preVariation_apply | Mathlib.MeasureTheory.Measure.PreVariation | ∀ {X : Type u_1} [inst : MeasurableSpace X] (f : Set X → ENNReal) (hf : MeasureTheory.IsSigmaSubadditiveSetFun f)
(hf' : f ∅ = 0) (s : Set X),
(MeasureTheory.preVariation f hf hf') s = (MeasureTheory.ennrealPreVariation f hf hf').ennrealToMeasure s | null | true |
ModuleCat.MonModuleEquivalenceAlgebra.Algebra_of_Mon_ | Mathlib.CategoryTheory.Monoidal.Internal.Module | {R : Type u} → [inst : CommRing R] → (A : ModuleCat R) → [inst_1 : CategoryTheory.MonObj A] → Algebra R ↑A | The algebra structure on a monoid object.
This instance is dangerous as it doesn't round trip from a ring to a monoid object and then back
to a ring, since the `npow` field is lost in the middle. Therefore, it is scoped. | 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 |
Std.Roc.Sliceable.mkSlice | Init.Data.Slice.Notation | {α : Type u} → {β : outParam (Type v)} → {γ : outParam (Type w)} → [self : Std.Roc.Sliceable α β γ] → α → Std.Roc β → γ | Slices `carrier` from `range.lower` \(exclusive\) to `range.upper` \(inclusive\).
| true |
Lean.Elab.Tactic.Do.Uses.casesOn | Lean.Elab.Tactic.Do.LetElim | {motive : Lean.Elab.Tactic.Do.Uses → Sort u} →
(t : Lean.Elab.Tactic.Do.Uses) →
motive Lean.Elab.Tactic.Do.Uses.zero →
motive Lean.Elab.Tactic.Do.Uses.one → motive Lean.Elab.Tactic.Do.Uses.many → motive t | null | false |
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 |
_private.Mathlib.Analysis.Convex.Basic.0.Convex.exists_mem_add_smul_eq._simp_1_5 | Mathlib.Analysis.Convex.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | 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.Batteries.Util.ProofWanted.0.classifyWantedRef.match_10 | Batteries.Util.ProofWanted | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((α : Lean.Expr) → motive (some α)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.cycle_zpow_mem_support_iff._simp_1_2 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (n : ℕ), (0 ≤ ↑n) = True | null | false |
Lean.Lsp.CodeActionClientCapabilities.disabledSupport?._default | Lean.Data.Lsp.CodeActions | Option Bool | 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.Data.FunLike.Graded | ∀ {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.Tactic.Linter.Style.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.Style.830885783._hygCtx._hyg.4 | Mathlib.Tactic.Linter.Style | IO (Lean.Option Bool) | null | false |
_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 |
MulEquiv.ofBijective_apply | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} {F : Type u_11} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[inst_3 : MulHomClass F M N] (f : F) (hf : Function.Bijective ⇑f) (a : M), (MulEquiv.ofBijective f hf) a = f a | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.not_matchesAt_of_prefixFunction_eq._simp_1_2 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {a b c : ℕ}, (a - b ≤ c) = (a ≤ c + b) | null | false |
Aesop.Frontend.Feature.elab._unsafe_rec | Aesop.Frontend.RuleExpr | Lean.Syntax → Aesop.ElabM Aesop.Frontend.Feature | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AccLevelState.ctorIdx | Lean.Elab.MutualInductive | Lean.Elab.Command.AccLevelState✝ → ℕ | 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' =
{ toMul := (Submonoid.center M).toMulOneClass.toMul, mul_assoc := ⋯,
toOne := (Submonoid.center M).toMulOneClass.toOne, 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.