name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.IdentDistrib.measure_preimage_eq | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ},
ProbabilityTheory.IdentDistrib f g μ ν → ∀ {s : Set γ}, MeasurableSet s → μ (f ⁻¹' s) = ν (g ⁻¹' s) | **Alias** of `ProbabilityTheory.IdentDistrib.measure_mem_eq`. | true |
_private.Mathlib.Data.Finsupp.MonomialOrder.DegLex.0.Finsupp.DegLex.single_strictAnti._simp_1_1 | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_2} [inst : Preorder α] (x : α), (x < x) = False | null | false |
NNReal.iSup_eq_zero | Mathlib.Basic.NNReal.Defs | ∀ {ι : Sort u_1} {f : ι → NNReal}, BddAbove (Set.range f) → (⨆ i, f i = 0 ↔ ∀ (i : ι), f i = 0) | null | true |
DFinsupp.toMultiset_toDFinsupp | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (f : Π₀ (x : α), ℕ), Multiset.toDFinsupp (DFinsupp.toMultiset f) = f | null | true |
_private.Mathlib.SetTheory.Cardinal.Finite.0.Nat.card_ne_zero._simp_1_2 | Mathlib.SetTheory.Cardinal.Finite | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
Aesop.GoalUnsafe.brecOn_2.eq | Aesop.Tree.Data | ∀ {motive_1 : Aesop.GoalUnsafe → Sort u} {motive_2 : Aesop.MVarClusterUnsafe → Sort u}
{motive_3 : Aesop.RappUnsafe → Sort u} {motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u}
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u}
{motive_6 : Aesop.RappData Aesop... | null | true |
_private.Mathlib.RingTheory.MvPolynomial.Ideal.0.MvPolynomial.idealOfVars_eq_restrictSupportIdeal._simp_1_4 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
PerfectClosure.liftOn.congr_simp | Mathlib.FieldTheory.PerfectClosure | ∀ {K : Type u} [inst : CommRing K] {p : ℕ} [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] {L : Type u_1}
(x x_1 : PerfectClosure K p),
x = x_1 →
∀ (f f_1 : ℕ × K → L) (e_f : f = f_1) (hf : ∀ (x y : ℕ × K), PerfectClosure.R K p x y → f x = f y),
x.liftOn f hf = x_1.liftOn f_1 ⋯ | null | true |
Lean.Meta.getCtorNumPropFields | Lean.Meta.Tactic.Injection | Lean.ConstructorVal → Lean.MetaM ℕ | null | true |
Cycle.coe_eq_coe._simp_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l₁ l₂ : List α}, (↑l₁ = ↑l₂) = (l₁ ~r l₂) | null | false |
Std.TreeSet.Equiv.get?_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α},
t₁.Equiv t₂ → t₁.get? k = t₂.get? k | null | true |
RingHom.IsStandardSmooth.smooth | Mathlib.RingTheory.RingHom.LocallyStandardSmooth | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] {f : R →+* S}, f.IsStandardSmooth → f.Smooth | Any standard smooth ring homomorphism is smooth. | true |
NonUnitalSubring.toNonUnitalSubsemiring_strictMono | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R], StrictMono NonUnitalSubring.toNonUnitalSubsemiring | null | true |
Lean.Language.SnapshotTreeTransform.mk | Lean.Language.Basic | Substring.Raw → Lean.Language.SnapshotTreeTransform | null | true |
ZeroAtInftyContinuousMap.instNormedAddCommGroup._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NormedAddCommGroup β],
autoParam (∀ (x y : ZeroAtInftyContinuousMap α β), dist x y = ‖-x + y‖) NormedAddCommGroup.dist_eq._autoParam | null | false |
RingHom.coe_rangeRestrict | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (f : R →+* S) (x : R),
↑(f.rangeRestrict x) = f x | null | true |
LocallyConstant.constMonoidHom_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : MulOneClass Y] (y : Y),
LocallyConstant.constMonoidHom y = LocallyConstant.const X y | null | true |
Tilt.instField._proof_23 | Mathlib.RingTheory.Perfection | ∀ (K : Type u_1) [inst : Field K] (v : Valuation K NNReal) (O : Type u_2) [inst_1 : CommRing O] [inst_2 : Algebra O K]
(hv : v.Integers O) (p : ℕ) [inst_3 : Fact (Nat.Prime p)] [hvp : Fact (v ↑p ≠ 1)] (this : Fact ¬IsUnit ↑p),
autoParam (∀ (n : ℕ) (x : Tilt K v O hv p), x ^ (n + 1) = x ^ n * x) Monoid.npow_succ._au... | null | false |
Lean.Meta.withIncSynthPending | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → n α → n α | null | true |
_private.Mathlib.RingTheory.Perfectoid.BDeRham.0._aux_Mathlib_RingTheory_Perfectoid_BDeRham___unexpand_BDeRhamPlus_1 | Mathlib.RingTheory.Perfectoid.BDeRham | Lean.PrettyPrinter.Unexpander | null | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateBoxImp._sparseCasesOn_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((ty : Lean.Expr) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.box ty fvarId h)) →
(Nat... | null | false |
ContinuousMultilinearMap.instAddMonoid._proof_5 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u_1} {ι : Type u_2} {M₁ : ι → Type u_3} {M₂ : Type u_4} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
[inst_7 : Continuous... | null | false |
CategoryTheory.GradedNatTrans | 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] →
CategoryTheory.Center V →
... | The type of `A`-graded natural transformations between `V`-functors `F` and `G`.
This is the type of morphisms in `V` from `A` to the `V`-object of natural transformations.
| true |
List.maxIdxOn_lt_length._simp_1 | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {f : α → β} {xs : List α} (h : xs ≠ []),
(List.maxIdxOn f xs h < xs.length) = True | null | false |
OreLocalization.instCommMonoidWithZero._proof_2 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
(a : OreLocalization S R), 0 * a = 0 | null | false |
Std.DTreeMap.Internal.Impl.Const.getEntryLT._proof_4 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] [Std.TransOrd α] (k : α) (size : ℕ) (ky : α) (y : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
(∃ a ∈ Std.DTreeMap.Internal.Impl.inner size ky y l r, compare a k = Ordering.lt) →
¬compare k ky = Ordering.gt → ∃ a ∈ l, compare a k = Ordering.lt | null | false |
MeasureTheory.ae_eq_of_forall_setIntegral_eq_of_sigmaFinite | Mathlib.MeasureTheory.Function.AEEqOfIntegral | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [MeasureTheory.SigmaFinite μ] {f g : α → E},
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → MeasureTheory.IntegrableOn f s μ) →
(∀ (s : Set α), Measurabl... | null | true |
OrderIso.mapSetOfPredMaximal._proof_4 | Mathlib.Order.Minimal | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {t : Set β} (f : ↑s ≃o ↑t)
(x : ↑{x | Maximal (fun x => x ∈ s) x}), ↑⟨↑(f ⟨↑x, ⋯⟩), ⋯⟩ ∈ t | null | false |
CategoryTheory.Mat_.lift_map | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
{X Y... | null | true |
Meromorphic.sub | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f g : 𝕜 → E}, Meromorphic f → Meromorphic g → Meromorphic (f - g) | null | true |
Batteries.Random.MersenneTwister.State.mk.inj | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} {data : Vector (BitVec cfg.wordSize) cfg.stateSize}
{index : Fin cfg.stateSize} {data_1 : Vector (BitVec cfg.wordSize) cfg.stateSize} {index_1 : Fin cfg.stateSize},
{ data := data, index := index } = { data := data_1, index := index_1 } → data = data_1 ∧ index = ind... | null | true |
IsSepClosure.mk._flat_ctor | Mathlib.FieldTheory.IsSepClosed | ∀ {k : Type u} [inst : Field k] {K : Type v} [inst_1 : Field K] [inst_2 : Algebra k K],
IsSepClosed K → Algebra.IsSeparable k K → IsSepClosure k K | null | false |
CategoryTheory.Functor.Final.coconesEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u_2}
[inst_3 : CategoryTheory.Category.{u_1, u_2} E] (G : CategoryTheory.Functor D E)
(c : CategoryTheory.Limits.Cocone (F.com... | null | false |
MeasurableEmbedding.map_withDensity_rnDeriv | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α → β},
MeasurableEmbedding f →
∀ (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ] [MeasureTheory.SigmaFinite ν],
MeasureTheory.Measure.map f (ν.withDensity (μ.rnDeriv ν)) =
(MeasureTheory.Measure.map ... | null | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm.swapRows | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | {α : ℕ → ℕ → Type} →
[self : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm α] → {n m : ℕ} → α n m → ℕ → ℕ → α n m | Swaps two rows. | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.isInvalidContinuationByte_getElem_utf8EncodeChar_one_of_utf8Size_eq_two | Init.Data.String.Decode | ∀ {c : Char} (hc : c.utf8Size = 2),
ByteArray.utf8DecodeChar?.isInvalidContinuationByte (String.utf8EncodeChar c)[1] = false | null | true |
Subgroup.IsArithmetic.conj | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (𝒢 : Subgroup (GL (Fin 2) ℝ)) [𝒢.IsArithmetic] (g : GL (Fin 2) ℚ),
(ConjAct.toConjAct ((Matrix.GeneralLinearGroup.map (Rat.castHom ℝ)) g) • 𝒢).IsArithmetic | Conjugation by `GL(2, ℚ)` preserves arithmetic subgroups. | true |
Submodule.comapSubtypeEquivOfLe_symm_apply | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (hpq : p ≤ q) (x : ↥p), (Submodule.comapSubtypeEquivOfLe hpq).symm x = ⟨⟨↑x, ⋯⟩, ⋯⟩ | null | true |
CategoryTheory.Triangulated.Octahedron.map._proof_5 | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] [inst_4 : CategoryTheory.Limits.HasZeroObject C]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : ∀ (n : ℤ), ... | null | false |
Lean.Syntax.getArg | Init.Prelude | Lean.Syntax → ℕ → Lean.Syntax | Gets the `i`'th argument of the syntax node. This can also be written `stx[i]`.
Returns `missing` if `i` is out of range.
| true |
_private.Lean.Data.Lsp.Extra.0.Lean.Lsp.instFromJsonDependencyBuildMode.fromJson.match_3 | Lean.Data.Lsp.Extra | (motive : Option String → Sort u_1) →
(x : Option String) → ((tag : String) → motive (some tag)) → (Unit → motive none) → motive x | null | false |
Subalgebra.toSubmodule | Mathlib.Algebra.Algebra.Subalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → Subalgebra R A ↪o Submodule R A | The forgetful map from `Subalgebra` to `Submodule` as an `OrderEmbedding` | true |
UInt64.ofNat | Init.Data.UInt.BasicAux | ℕ → UInt64 | Converts a natural number to a 64-bit unsigned integer, wrapping on overflow.
This function is overridden at runtime with an efficient implementation.
Examples:
* `UInt64.ofNat 5 = 5`
* `UInt64.ofNat 65539 = 65539`
* `UInt64.ofNat 4_294_967_299 = 4_294_967_299`
* `UInt64.ofNat 18_446_744_073_709_551_620 = 4`
| true |
GenContFract.first_cont_eq | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K] {gp : GenContFract.Pair K},
g.s.get? 0 = some gp → g.conts 1 = { a := gp.b * g.h + gp.a, b := gp.b } | null | true |
realPart_one | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : Ring A] [inst_1 : StarRing A] [inst_2 : Module ℂ A] [inst_3 : StarModule ℂ A], realPart 1 = 1 | null | true |
CategoryTheory.Functor.weightedLimFlipObjMap_comp_assoc | Mathlib.CategoryTheory.Limits.Weighted.HasWeightedLimit | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{W W' W'' : CategoryTheory.Functor J (Type w)} (g : W ⟶ W') (g' : W' ⟶ W'') (F : CategoryTheory.Functor J C)
[inst_2 : CategoryTheory.Limits.HasWeightedLimit W F] [inst_3 : CategoryTheory.Limits.HasW... | null | true |
IsRightUniformGroup.toIsTopologicalGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {G : Type u_4} {inst : UniformSpace G} {inst_1 : Group G} [self : IsRightUniformGroup G], IsTopologicalGroup G | null | true |
Std.DTreeMap.Internal.Impl.Const.get!_insertManyIfNewUnit_empty_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {l : List α} {k : α},
Std.DTreeMap.Internal.Impl.Const.get!
(↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit Std.DTreeMap.Internal.Impl.empty l ⋯)) k =
() | null | true |
Lean.Meta.LazyDiscrTree.Cache.rec | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.Cache → Sort u} →
((ngen : Lean.NameGenerator) →
(core : Lean.Core.Cache) → («meta» : Lean.Meta.Cache) → motive { ngen := ngen, core := core, «meta» := «meta» }) →
(t : Lean.Meta.LazyDiscrTree.Cache) → motive t | null | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.foldlM.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(x : δ) (a : α) (b : β a) (es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldlM f x (Std.DHashMap.Internal.AssocList.cons a b es) = do
let d ← f x a b
Std.DHashMap.... | null | true |
Finset.zsmul.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Zero α] [inst_2 : Add α] [inst_3 : Neg α],
Finset.zsmul = { smul := fun n s => zsmulRec nsmulRec n s } | null | true |
MeasurableEquiv.map_measurableEquiv_injective | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} [inst : MeasurableSpace β] (e : α ≃ᵐ β),
Function.Injective (MeasureTheory.Measure.map ⇑e) | null | true |
Finsupp.some_zero | Mathlib.Data.Finsupp.Option | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M], Finsupp.some 0 = 0 | null | true |
CategoryTheory.Pi.ext | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type w₀} (C : I → Type u₁) [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i}
{f g : X ⟶ Y}, (∀ (i : I), f i = g i) → f = g | null | true |
CategoryTheory.Limits.ReflectsColimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(J : Type w) → [CategoryTheory.Category.{w', w} J] → CategoryTheory.Functor C D → Prop | A functor `F : C ⥤ D` reflects colimits of shape `J` if
whenever the image of a cocone over some `K : J ⥤ C` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
| true |
CategoryTheory.Limits.PullbackCone.IsLimit.hom_ext | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) {W : C} {k l : W ⟶ t.pt},
CategoryTheory.CategoryStruct.comp k t.fst = CategoryTheory.CategoryStruct.comp l t.fst →
CategoryTheory.Cate... | null | true |
LieAlgebra.lieCharacterEquivLinearDual_symm_apply | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : IsLieAbelian L]
(ψ : Module.Dual R L), LieAlgebra.lieCharacterEquivLinearDual.symm ψ = { toLinearMap := ψ, map_lie' := ⋯ } | null | true |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.empty_isBase_iff._simp_1_4 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M₁ M₂ : Matroid α}, (M₁ = M₂) = (M₁.E = M₂.E ∧ ∀ ⦃I : Set α⦄, I ⊆ M₁.E → (M₁.Indep I ↔ M₂.Indep I)) | null | false |
chart_mem_atlas | Mathlib.Geometry.Manifold.ChartedSpace | ∀ (H : Type u_4) {M : Type u_5} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(x : M), chartAt H x ∈ atlas H M | null | true |
Lean.Meta.SparseCasesOnInfo.recOn | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnInfo → Sort u} →
(t : Lean.Meta.SparseCasesOnInfo) →
((indName : Lean.Name) →
(majorPos arity : ℕ) →
(insterestingCtors : Array Lean.Name) →
motive
{ indName := indName, majorPos := majorPos, arity := arity, insterestingCtors := insteres... | null | false |
IsReduced.mk._flat_ctor | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_5} [inst : Zero R] [inst_1 : Pow R ℕ], (∀ (x : R), IsNilpotent x → x = 0) → IsReduced R | null | false |
CategoryTheory.Limits.FormalCoproduct.evalOpCompInlIsoId._proof_7 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (A : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
{X Y : CategoryTheory.Functor Cᵒᵖ A} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.FormalCoproduct.evalOp C ... | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabFunValues.match_5 | Lean.Elab.MutualDef | (motive : Option Lean.Elab.BodyProcessedSnapshot → Sort u_1) →
(x : Option Lean.Elab.BodyProcessedSnapshot) →
((old : Lean.Elab.BodyProcessedSnapshot) → motive (some old)) →
((x : Option Lean.Elab.BodyProcessedSnapshot) → motive x) → motive x | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.Graph.in₂₁_iff.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {t : Finset (α × β × γ)} {b : β} {c : γ}
(motive : (∃ a, (a, b, c) ∈ t) → Prop) (x : ∃ a, (a, b, c) ∈ t), (∀ (w : α) (h : (w, b, c) ∈ t), motive ⋯) → motive x | null | false |
Std.Internal.Parsec.instReprParseResult | Std.Internal.Parsec.Basic | {α ι : Type} → [Repr α] → [Repr ι] → Repr (Std.Internal.Parsec.ParseResult α ι) | null | true |
Function.mtr | Mathlib.Basic.Logic.Basic | ∀ {a b : Prop}, (¬a → ¬b) → b → a | Provide the reverse of modus tollens (`mt`) as dot notation for implications. | true |
DFinsupp.equivFunOnFintype_symm_coe | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : Fintype ι] (f : Π₀ (i : ι), β i),
DFinsupp.equivFunOnFintype.symm ⇑f = f | null | true |
AddCommGroup.nsmul_add_modEq | Mathlib.Algebra.Group.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoid M] {a p : M} (n : ℕ), n • p + a ≡ a [PMOD p] | null | true |
Mathlib.Tactic.Widget.StringDiagram.Node.recOn | Mathlib.Tactic.Widget.StringDiagram | {motive : Mathlib.Tactic.Widget.StringDiagram.Node → Sort u} →
(t : Mathlib.Tactic.Widget.StringDiagram.Node) →
((a : Mathlib.Tactic.Widget.StringDiagram.AtomNode) → motive (Mathlib.Tactic.Widget.StringDiagram.Node.atom a)) →
((a : Mathlib.Tactic.Widget.StringDiagram.IdNode) → motive (Mathlib.Tactic.Widget.... | null | false |
SimpleGraph.Hom.toCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} →
{W : Type u_2} → {G : SimpleGraph V} → {H : SimpleGraph W} → (f : H →g G) → Function.Injective ⇑f → H.Copy G | An injective homomorphism gives rise to a copy. | true |
List.forIn'_pure_yield_eq_foldl | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {l : List α}
(f : (a : α) → a ∈ l → β → β) (init : β),
(forIn' l init fun a m_1 b => pure (ForInStep.yield (f a m_1 b))) =
pure
(List.foldl
(fun b x =>
match x with
| ⟨a, h⟩ => f a h b)
... | null | true |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.derivative_mul._proof_1_1 | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u_1} [inst : Semiring R] (a b : R) (m n : ℕ),
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(n + 1))) =
(Polynomial.monomial (m + 1 - 1 + (n + 1))) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1 - 1)))... | null | false |
_private.Mathlib.Algebra.Order.Ring.Ordering.Basic.0.RingPreordering.supportAddSubgroup_eq_bot._simp_1_1 | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] {P : RingPreordering R} {x : R}, (x ∈ P.supportAddSubgroup) = (x ∈ P ∧ -x ∈ P) | null | false |
MeasureTheory.LocallyIntegrable | Mathlib.MeasureTheory.Function.LocallyIntegrable | {X : Type u_1} →
{ε : Type u_3} →
[inst : MeasurableSpace X] →
[TopologicalSpace X] →
[inst_2 : TopologicalSpace ε] →
[ContinuousENorm ε] →
(X → ε) → autoParam (MeasureTheory.Measure X) MeasureTheory.LocallyIntegrable._auto_1 → Prop | A function `f : X → ε` is *locally integrable* if it is integrable on a neighborhood of every
point. In particular, it is integrable on all compact sets,
see `LocallyIntegrable.integrableOn_isCompact`. | true |
LieSubalgebra.mem_normalizer_iff' | Mathlib.Algebra.Lie.Normalizer | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) (x : L), x ∈ H.normalizer ↔ ∀ y ∈ H, ⁅y, x⁆ ∈ H | null | true |
IsAlgebraic.nontrivial | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a → Nontrivial R | null | true |
CategoryTheory.Limits.preservesFiniteLimits_of_op | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteColimits F.op],
CategoryTheory.Limits.PreservesFiniteLimits F | If `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite colimits, then `F : C ⥤ D` preserves finite limits. | true |
IsLocalization.AtPrime.inertiaDeg_map_eq_inertiaDeg | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (Rₚ : Type u_3) [inst_4 : CommRing Rₚ] [inst_5 : Algebra R Rₚ] [IsLocalization.AtPrime Rₚ p]
[inst_7 : IsLocalRing Rₚ] (Sₚ : Type u_4) [inst_8 : CommRing Sₚ] [inst_9 : Algebra S Sₚ]
... | null | true |
Cardinal.mk_univ_real | Mathlib.Analysis.Real.Cardinality | Cardinal.mk ↑Set.univ = Cardinal.continuum | The cardinality of the reals, as a set. | true |
Lean.Grind.CommRing.Expr._sizeOf_inst | Init.Grind.Ring.CommSolver | SizeOf Lean.Grind.CommRing.Expr | null | false |
LieRinehartAlgebra | Mathlib.Algebra.LieRinehartAlgebra.Defs | (R : Type u_1) →
(A : Type u_2) →
(L : Type u_3) →
[inst : CommRing A] →
[inst_1 : LieRing L] →
[inst_2 : Module A L] →
[inst_3 : LieRingModule L A] →
[LieRinehartRing A L] → [inst_5 : CommRing R] → [Algebra R A] → [LieAlgebra R L] → Prop | A Lie-Rinehart algebra with coefficients in a commutative ring `R`, is a pair consisting of a
commutative `R`-algebra `A` and a Lie algebra `L` with coefficients in `R`, such that `A` and `L`
are each a module over the other, satisfying compatibility conditions.
As shown below, this data determines a linear map `L → D... | true |
sdiff_right_inj | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], x ≤ z → y ≤ z → (z \ x = z \ y ↔ x = y) | null | true |
MeasureTheory.average | Mathlib.MeasureTheory.Integral.Average | {α : Type u_1} →
{E : Type u_2} →
{m0 : MeasurableSpace α} → [inst : NormedAddCommGroup E] → [NormedSpace ℝ E] → MeasureTheory.Measure α → (α → E) → E | Average value of a function `f` w.r.t. a measure `μ`, denoted `⨍ x, f x ∂μ`.
It is equal to `(μ.real univ)⁻¹ • ∫ x, f x ∂μ`, so it takes value zero if `f` is not integrable or
if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is
equal to its integral.
For the average on ... | true |
Lean.Elab.SyntaxDeprecationEntry.ctorIdx | Lean.Elab.DeprecatedSyntax | Lean.Elab.SyntaxDeprecationEntry → ℕ | null | false |
MvPowerSeries.X_dvd_iff | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {s : σ} {φ : MvPowerSeries σ R},
MvPowerSeries.X s ∣ φ ↔ ∀ (m : σ →₀ ℕ), m s = 0 → (MvPowerSeries.coeff m) φ = 0 | null | true |
intervalIntegral.integral_hasDerivAt_of_tendsto_ae_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {c : E}
{a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
Filter.Tendsto f (nhds b ⊓ MeasureTheory.ae MeasureTheory.volume) (nhds c)... | **Fundamental theorem of calculus-1**: if `f : ℝ → E` is integrable on `a..b` and `f x` has a
finite limit `c` almost surely at `b`, then `u ↦ ∫ x in a..u, f x` has derivative `c` at `b`. | true |
Lean._aux_Lean_Message___macroRules_Lean_termM!__1 | Lean.Message | Lean.Macro | null | false |
CategoryTheory.Preadditive.isSeparator_iff | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsSeparator G ↔
∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : G ⟶ X), CategoryTheory.CategoryStruct.comp h f = 0) → f = 0 | null | true |
_private.Mathlib.RingTheory.WittVector.WittPolynomial.0.xInTermsOfW_vars_aux._proof_1_3 | Mathlib.RingTheory.WittVector.WittPolynomial | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], NeZero p | null | false |
LinearMap.range_eq_top_of_surjective | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [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 : RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂), Function.Surjective ⇑f → f.range = ⊤ | null | true |
_private.Lean.Data.PersistentArray.0.Lean.PersistentArray.foldlMAux.match_1 | Lean.Data.PersistentArray | {α : Type u_1} →
{β : Type u_3} →
(motive : Lean.PersistentArrayNode α → β → Sort u_2) →
(x : Lean.PersistentArrayNode α) →
(x_1 : β) →
((cs : Array (Lean.PersistentArrayNode α)) → (b : β) → motive (Lean.PersistentArrayNode.node cs) b) →
((vs : Array α) → (b : β) → motive (Lean... | null | false |
AnalyticAt.fun_pow | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {A : Type u_7} [inst_3 : NormedRing A] [inst_4 : NormedAlgebra 𝕜 A] {f : E → A} {z : E},
AnalyticAt 𝕜 f z → ∀ (n : ℕ), AnalyticAt 𝕜 (fun i => f i ^ n) z | Eta-expanded form of `AnalyticAt.pow`
---
Powers of analytic functions (into a normed `𝕜`-algebra) are analytic. | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable.0.hasSum_nat_jacobiTheta._simp_1_3 | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
RootPairing.flipEquiv._proof_1 | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ (ι : Type u_1) (R : Type u_2) (M : Type u_3) (N : Type u_4) [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N],
Function.LeftInverse (fun P => P.flip) fun P => P.flip | null | false |
Affine.Simplex.sum_excenterWeights | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1)))
[inst_5 : Decidable (s.ExcenterExists signs)],
∑ i, s.excenterWeights signs i... | null | true |
IsBaseChange.directSumPow | Mathlib.RingTheory.TensorProduct.IsBaseChangePi | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (ι : Type u_3)
{M : Type u_6} {M' : Type u_7} [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid M'] [inst_5 : Module R M]
[inst_6 : Module R M'] [inst_7 : Module S M'] [inst_8 : IsScalarTower R S M'] {ε : M →ₗ[... | Base change for direct sums of a constant module. | true |
_private.Lean.Server.AsyncList.0.Lean.AsyncList.getFinishedPrefix.match_1 | Lean.Server.AsyncList | {ε α : Type} →
(motive : List α × Option ε × Bool → Sort u_1) →
(x : List α × Option ε × Bool) →
((tl : List α) → (e? : Option ε) → (isComplete : Bool) → motive (tl, e?, isComplete)) → motive x | null | false |
List.insert_replicate_self | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {n : ℕ} {a : α},
0 < n → List.insert a (List.replicate n a) = List.replicate n a | null | true |
_private.Mathlib.NumberTheory.SumPrimeReciprocals.0.ite_prime_eq_mulIndicator | Mathlib.NumberTheory.SumPrimeReciprocals | ∀ {M : Type u_1} [inst : CommMonoid M] (f : ℕ → M),
(fun n => if Nat.Prime n then f n else 1) = {n | Nat.Prime n}.mulIndicator f | null | true |
Polynomial.hasStrictDerivAt | Mathlib.Analysis.Calculus.Deriv.Polynomial | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (p : Polynomial 𝕜) (x : 𝕜),
HasStrictDerivAt (fun x => Polynomial.eval x p) (Polynomial.eval x (Polynomial.derivative p)) x | The derivative (in the analysis sense) of a polynomial `p` is given by `p.derivative`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.