name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.toInductive | Lean.Meta.MkIffOfInductiveProp | Lean.MVarId → List Lean.Name → List Lean.Expr → List Lean.Meta.Shape✝ → Lean.FVarId → Lean.MetaM Unit | Proves the right to left direction of a generated iff theorem.
| true |
Path.Homotopy.symm₂._proof_3 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ : X} {p q : Path x₀ x₁} (F : p.Homotopy q) (x : ↑unitInterval),
F ((0, x).1, unitInterval.symm (0, x).2) = p.symm.toContinuousMap x | null | false |
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 |
_private.Mathlib.RingTheory.MvPolynomial.Ideal.0.MvPolynomial.idealOfVars_eq_restrictSupportIdeal._simp_1_4 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {A : Type u_1} {B : outParam (Type u_2)} {inst : Membership B A} {inst_1 : LE A} [self : IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
_private.Std.Internal.Order.PreservesSup.0.Lean.Order.snd_meet | Std.Internal.Order.PreservesSup | ∀ {α : Type u} [inst : Lean.Order.CompleteLattice α] {β : Type v} [inst_1 : Lean.Order.CompleteLattice β]
(p q : α ×' β), (Lean.Order.meet p q).snd = Lean.Order.meet p.snd q.snd | 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 |
NonUnitalSubring.toNonUnitalSubsemiring_strictMono | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R], StrictMono NonUnitalSubring.toNonUnitalSubsemiring | 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 |
_private.ImportGraph.Shake.DeclNeeds.0.ImportGraph.Shake.instBEqDeclDeclNeedsKind.beq._sparseCasesOn_4 | ImportGraph.Shake.DeclNeeds | {motive : ImportGraph.Shake.DeclDeclNeedsKind → Sort u} →
(t : ImportGraph.Shake.DeclDeclNeedsKind) →
((source : ImportGraph.Shake.ComptimeDependency) → motive (ImportGraph.Shake.DeclDeclNeedsKind.comptime source)) →
(Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | 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 |
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 |
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 |
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 |
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 |
_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 |
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 |
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 |
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 |
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 |
_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 |
_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 |
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 |
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 |
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 |
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 |
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 |
_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 |
ImportGraph.Lean.getModule | ImportGraph.Imports.Pretty | Lean.TSyntax `Lean.Parser.Module.header → Option Lean.Syntax | Destructures header syntax (`(module)? (prelude)? $imports*`) into an array of `Import`s
together with the import syntax that gave rise to them. See also `headerToImports`. | true |
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.Basic | ∀ {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 |
PartOrdEmb.isCardinalFiltered_iff | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | ∀ (κ : Cardinal.{u}) [inst : Fact κ.IsRegular] (X : PartOrdEmb),
PartOrdEmb.isCardinalFiltered κ X ↔ CategoryTheory.IsCardinalFiltered (↑X) κ | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Basic.0.Std.Tactic.BVDecide.LRAT.Internal.State.all.go._proof_1 | Std.Tactic.BVDecide.LRAT.Internal.Basic | ∀ (s : Std.Tactic.BVDecide.LRAT.Internal.State), ∀ i < s.formula.size, i < s.formula.size | null | false |
ProbabilityTheory.condIndepFun_iff_condExp_inter_preimage_eq_mul | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{hm' : m' ≤ mΩ} {μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'},
Measurable f →
Measurable g →
(... | null | true |
CategoryTheory.Bimon.instBimonObjXXMon | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → (M : CategoryTheory.Bimon C) → CategoryTheory.BimonObj M.X.X | null | true |
CommMonCat.units._proof_1 | Mathlib.Algebra.Category.Grp.Adjunctions | ∀ (x : CommMonCat),
CommGrpCat.ofHom (Units.map (CommMonCat.Hom.hom (CategoryTheory.CategoryStruct.id x))) =
CategoryTheory.CategoryStruct.id ↧(↑x)ˣ | null | false |
sub_one_mul_padicValNat_choose_eq_sub_sum_digits' | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p k n : ℕ} [hp : Fact (Nat.Prime p)],
(p - 1) * padicValNat p ((n + k).choose k) = (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum | **Kummer's Theorem**
Taking (`p - 1`) times the `p`-adic valuation of the binomial `n + k` over `k` equals the sum of the
digits of `k` plus the sum of the digits of `n` minus the sum of digits of `n + k`, all base `p`.
| true |
CategoryTheory.Endofunctor.Coalgebra.Hom.id._proof_2 | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor C C}
(V : CategoryTheory.Endofunctor.Coalgebra F),
CategoryTheory.CategoryStruct.comp V.str (F.map (CategoryTheory.CategoryStruct.id V.V)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id V.V) V.str | null | false |
_private.Mathlib.Topology.Constructions.SumProd.0.isOpenMap_inr._simp_1_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
IsOpen s = (IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s)) | null | false |
DiscreteQuotient.equivFinsetClopens | Mathlib.Topology.DiscreteQuotient | (X : Type u_2) →
[inst : TopologicalSpace X] →
[inst_1 : CompactSpace X] → DiscreteQuotient X ≃ ↑(Set.range (DiscreteQuotient.finsetClopens X)) | The discrete quotients of a compact space are in bijection with a subtype of the type of
`Finset (Clopens X)`.
TODO: show that this is precisely those finsets of clopens which form a partition of `X`.
| true |
ULiftable.up' | Mathlib.Control.ULiftable | {f : Type u₀ → Type u₁} → {g : Type v₀ → Type v₁} → [ULiftable f g] → f PUnit.{u₀ + 1} → g PUnit.{v₀ + 1} | A version of `up` for a `PUnit` return type. | true |
List.pmap_attach | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {p : { x // x ∈ l } → Prop} {f : (a : { x // x ∈ l }) → p a → β}
(H : ∀ a ∈ l.attach, p a), List.pmap f l.attach H = List.pmap (fun a h => f ⟨a, ⋯⟩ ⋯) l ⋯ | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.errorMessage.match_6 | Mathlib.Tactic.Linter.TextBased | (motive : Mathlib.Linter.TextBased.StyleError✝ → Sort u_1) →
(err : Mathlib.Linter.TextBased.StyleError✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleError.adaptationNote✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleError.windowsLineEnding✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleErro... | null | false |
CategoryTheory.PreOneHypercover.inv_hom_h₁_assoc | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (e : E ≅ F)
{i j : F.I₀} (k : F.I₁ i j) {Z : C} (h : F.Y (e.hom.s₁ (e.inv.s₁ k)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.inv.h₁ k) (CategoryTheory.CategoryStruct.comp (e.hom.h₁ (e.inv.s₁ k)) h) =
Categ... | null | true |
Real.RingHom.unique | Mathlib.Algebra.Order.Archimedean.Real.Hom | Unique (ℝ →+* ℝ) | There exists no nontrivial ring homomorphism `ℝ →+* ℝ`. | true |
Metric.exists_isBounded_image_of_tendsto | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_2} {β : Type u_3} [inst : PseudoMetricSpace β] {l : Filter α} {f : α → β} {x : β},
Filter.Tendsto f l (nhds x) → ∃ s ∈ l, Bornology.IsBounded (f '' s) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKeyD_filter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
LieModule.rank_le_finrank | Mathlib.Algebra.Lie.Rank | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : LieRingModule L M] [inst_8 : LieModule R L M] [inst_9 : Module.Finite R M] [inst_10 : Mo... | null | true |
Set.Finite.isGδ_compl | Mathlib.Topology.Separation.GDelta | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} [T1Space X], s.Finite → IsGδ sᶜ | null | true |
LieAlgebra.Orthogonal.typeB | Mathlib.Algebra.Lie.Classical | (l : Type u_4) →
(R : Type u₂) →
[inst : DecidableEq l] →
[inst_1 : CommRing R] → [inst_2 : Fintype l] → LieSubalgebra R (Matrix (Unit ⊕ l ⊕ l) (Unit ⊕ l ⊕ l) R) | The classical Lie algebra of type B as a Lie subalgebra of matrices associated to the matrix
`JB`. | true |
CategoryTheory.Over.opEquivOpUnder._proof_4 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) {Z Y : (CategoryTheory.Under X)ᵒᵖ} (f : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Under.Hom.right f.unop).op
(CategoryTheory.Over.mk (Opposite.unop Y).hom.op).hom =
(CategoryTheory.Over.mk (Opposite.unop Z).hom.op).hom | null | false |
Array.PrefixTable.step | Batteries.Data.Array.Match | {α : Type u_1} → [BEq α] → (t : Array.PrefixTable α) → α → Fin (t.size + 1) → Fin (t.size + 1) | Transition function for the KMP matcher
Assuming we have an input `xs` with a suffix that matches the pattern prefix `t.pattern[:len]`
where `len : Fin (t.size+1)`. Then `xs.push x` has a suffix that matches the pattern prefix
`t.pattern[:t.step x len]`. If `len` is as large as possible then `t.step x len` will also b... | true |
Finset.sigmaLift | Mathlib.Data.Finset.Sigma | {ι : Type u_1} →
{α : ι → Type u_2} →
{β : ι → Type u_3} →
{γ : ι → Type u_4} → [DecidableEq ι] → (⦃i : ι⦄ → α i → β i → Finset (γ i)) → Sigma α → Sigma β → Finset (Sigma γ) | Lifts maps `α i → β i → Finset (γ i)` to a map `Σ i, α i → Σ i, β i → Finset (Σ i, γ i)`. | true |
CategoryTheory.MonoidalCategory.externalProductBifunctorCurried_obj_map_app_app | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | ∀ (J₁ : Type u₁) (J₂ : Type u₂) (C : Type u₃) [inst : CategoryTheory.Category.{v₁, u₁} J₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.Functor J₁ C) {X_1 Y : CategoryTheory.Functor J₂ C}
(f : X_1 ⟶ Y)... | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.NonemptyCompacts.preconnectedSpace_iff._simp_1_2 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
Std.TreeMap.Raw.Equiv.minEntry?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.minEntry? = t₂.minEntry? | null | true |
MeasureTheory.lintegral_liminf_le' | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ι : Type u_3} {f : ι → α → ENNReal}
{u : Filter ι} [u.IsCountablyGenerated],
(∀ (i : ι), AEMeasurable (f i) μ) →
∫⁻ (a : α), Filter.liminf (fun i => f i a) u ∂μ ≤ Filter.liminf (fun i => ∫⁻ (a : α), f i a ∂μ) u | **Fatou's lemma**, version with `AEMeasurable` functions. | true |
CategoryTheory.MorphismProperty.Under.instCreatesFiniteColimitsTopUnderForget._proof_1 | Mathlib.CategoryTheory.Limits.MorphismProperty | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) [CategoryTheory.Limits.HasPushouts T],
CategoryTheory.Limits.HasColimitsOfShape CategoryTheory.Limits.WalkingSpan (CategoryTheory.Under X) | null | false |
SimpleGraph.killCopies.edgeSet.instFintype | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} →
{W : Type u_2} → {G : SimpleGraph V} → {H : SimpleGraph W} → [Fintype ↑G.edgeSet] → Fintype ↑(G.killCopies H).edgeSet | null | true |
CategoryTheory.ObjectProperty.strictColimitsOfShape_bot | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] [Nonempty J], ⊥.strictColimitsOfShape J = ⊥ | null | true |
Lean.Meta.Sym.Arith.CommSemiring.addFn?._inherited_default | Lean.Meta.Sym.Arith.Types | Option Lean.Expr | null | false |
HasSummableGeomSeries.rec | Mathlib.Analysis.SpecificLimits.Normed | {K : Type u_4} →
[inst : NonUnitalNormedRing K] →
{motive : HasSummableGeomSeries K → Sort u} →
((summable_geometric_of_norm_lt_one : ∀ (ξ : K), ‖ξ‖ < 1 → Summable fun x => (fun x => x * ξ)^[x] ξ) → motive ⋯) →
(t : HasSummableGeomSeries K) → motive t | null | false |
HNNExtension.NormalWord.ReducedWord.prod.eq_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B) (w : HNNExtension.NormalWord.ReducedWord G A B),
HNNExtension.NormalWord.ReducedWord.prod φ w =
HNNExtension.of w.head * (List.map (fun x => HNNExtension.t ^ ↑x.1 * HNNExtension.of x.2) w.toList).prod | null | true |
_private.Mathlib.Probability.Distributions.Gaussian.Multivariate.0.ProbabilityTheory.charFun_stdGaussian._simp_1_5 | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ {α : Type u_1} (s : Finset α) (f : α → ℝ), ∑ i ∈ s, ↑(f i) = ↑(∑ i ∈ s, f i) | null | false |
MeasureTheory.Filtration.mono | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {i j : ι}
(f : MeasureTheory.Filtration ι m), i ≤ j → ↑f i ≤ ↑f j | null | true |
Function.locallyFinsuppWithin.instAddGroup._proof_4 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddGroup Y]
(D : Function.locallyFinsuppWithin U Y) (n : ℕ), ⇑(n • D) = n • ⇑D | null | false |
CategoryTheory.Abelian.Ext.preadditiveYoneda_homologySequenceδ_singleTriangle_apply._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ {n₀ n₁ : ℕ}, 1 + n₀ = n₁ → ↑n₀ + 1 = ↑n₁ | null | false |
Module.Flat.rTensor_exact | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u} (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Flat R M]
⦃N : Type u_1⦄ ⦃N' : Type u_2⦄ ⦃N'' : Type u_3⦄ [inst_4 : AddCommGroup N] [inst_5 : AddCommGroup N']
[inst_6 : AddCommGroup N''] [inst_7 : Module R N] [inst_8 : Module R N'] [inst_9 : Module R N''] ⦃f :... | If `M` is flat then `- ⊗ M` is an exact functor. | true |
WeierstrassCurve.Jacobian.negAddY._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | (2 + 1).AtLeastTwo | null | false |
Std.DTreeMap.Raw.alter | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.LawfulEqCmp cmp] →
Std.DTreeMap.Raw α β cmp → (a : α) → (Option (β a) → Option (β a)) → Std.DTreeMap.Raw α β cmp | Modifies in place the value associated with a given key,
allowing creating new values and deleting values via an `Option` valued replacement function.
This function ensures that the value is used linearly.
| true |
_private.Lean.Meta.Tactic.Generalize.0.Lean.Meta.generalizeCore | Lean.Meta.Tactic.Generalize | Lean.MVarId → Array Lean.Meta.GeneralizeArg → Lean.Meta.TransparencyMode → Lean.MetaM (Array Lean.FVarId × Lean.MVarId) | Telescopic `generalize` tactic. It can simultaneously generalize many terms.
It uses `kabstract` to occurrences of the terms that need to be generalized.
| true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.support_gaussianPDF._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
IsMin.eq_of_ge | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, IsMin a → b ≤ a → a = b | null | true |
DifferentiableOn.congr | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f f₁ : E → F} {s : Set E},
DifferentiableOn 𝕜 f s → (∀ x ∈ s, f₁ x = f... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.