name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
String.Slice.getUTF8Byte.eq_1 | Init.Data.String.Basic | ∀ (s : String.Slice) (p : String.Pos.Raw) (h : p < s.rawEndPos),
s.getUTF8Byte p h = s.str.getUTF8Byte (p.offsetBy s.startInclusive.offset) ⋯ | null | true |
Float.beq_nan_eq_false | Batteries.Data.Float.Lemmas | ∀ (f : Float), (f == Float.nan) = false | null | true |
Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries.recOn | Mathlib.Tactic.Translate.UnfoldBoundary | {motive : Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries → Sort u} →
(t : Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries) →
((unfolds : Lean.NameMap Lean.Meta.SimpTheorem) →
(casts : Lean.NameMap (Lean.Name × Lean.Name)) →
(insertionFuns : Lean.NameSet) →
motive { unfolds := unfolds,... | null | false |
ContinuousMap.HomotopicRel.symm | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {S : Set X} ⦃f g : C(X, Y)⦄,
f.HomotopicRel g S → g.HomotopicRel f S | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctorCore._proof_2 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ (B : Type u_5) [inst : CategoryTheory.Bicategory B] (C : Type u_2) [inst_1 : CategoryTheory.Bicategory C]
(obj : B → C) (map : {X Y : B} → (X ⟶ Y) → (obj X ⟶ obj Y)),
(∀ (X : B), map (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (obj X)) →
∀ {a b : B} (f : a ⟶ b),
CategoryTheor... | null | false |
Polynomial.roots_map_of_injective_of_card_eq_natDegree | Mathlib.Algebra.Polynomial.Roots | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : IsDomain A] [inst_3 : IsDomain B]
{p : Polynomial A} {f : A →+* B},
Function.Injective ⇑f → p.roots.card = p.natDegree → Multiset.map (⇑f) p.roots = (Polynomial.map f p).roots | null | true |
Unitization.mk_toProd | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} (x : Unitization R A), Unitization.mk x.toProd = x | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_21 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p₁ : G.Walk u v} {p₂ : G.Walk u' v'} (k : ℕ)
(hk : p₁.support.length + k ≤ p₂.support.length),
(∀ (i : ℕ) (h : i < p₁.support.length), p₂.support[i + k]? = some p₁.support[i]) →
∀ (i : ℕ) (hi : i < p₁.darts.length), p₂.darts[i + k].toProd.1 = p₁.darts[i].toP... | null | false |
Int8.ofUInt8.sizeOf_spec | Init.Data.SInt.Basic | ∀ (toUInt8 : UInt8), sizeOf { toUInt8 := toUInt8 } = 1 + sizeOf toUInt8 | null | true |
LinearAlgebra.FreeProduct.rel'.eq_1 | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ {I : Type u} [inst : DecidableEq I] (R : Type v) [inst_1 : CommSemiring R] (A : I → Type w)
[inst_2 : (i : I) → Semiring (A i)] [inst_3 : (i : I) → Algebra R (A i)],
LinearAlgebra.FreeProduct.rel' R A = Function.onFun (LinearAlgebra.FreeProduct.rel R A) ⇑TensorAlgebra.ofDirectSum | null | true |
Matrix.IsAdjMatrix.apply_diag | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : Zero α] [inst_1 : One α] {A : Matrix V V α},
A.IsAdjMatrix → ∀ (i : V), A i i = 0 | null | true |
SimpleGraph.Walk.darts_cycleBypass_sublist_darts | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {v : V} [inst : DecidableEq V] (w : G.Walk v v), w.cycleBypass.darts.Sublist w.darts | null | true |
Ordnode.repr._f | Mathlib.Data.Ordmap.Ordnode | {α : Type u_2} → [Repr α] → ℕ → (o : Ordnode α) → Ordnode.below o → Std.Format | null | false |
Real.sin_arctan_lt_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, Real.sin (Real.arctan x) < 0 ↔ x < 0 | null | true |
CategoryTheory.Limits.weakLimit.π_comp_eqToHom | Mathlib.CategoryTheory.Limits.WeakLimits.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{v_3, u_3} C] (F : CategoryTheory.Functor J C)
[inst_2 : CategoryTheory.Limits.HasWeakLimit F] {j j' : J} (hj : j = j'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.weakLimit.π F j) (Categ... | null | true |
SSet.N.eq_iff | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} {x y : X.N}, x = y ↔ x.subcomplex = y.subcomplex | null | true |
Aesop.NormalizationState.isNormal | Aesop.Tree.Data | Aesop.NormalizationState → Bool | null | true |
String.Slice.posGT_le_iff | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : String.Pos.Raw} {h : p < s.rawEndPos} {q : s.Pos}, s.posGT p h ≤ q ↔ p < q.offset | null | true |
Zero.ctorIdx | Init.Prelude | {α : Type u} → Zero α → ℕ | null | false |
UniversalEnvelopingAlgebra.lift._proof_6 | Mathlib.Algebra.Lie.UniversalEnveloping | ∀ (R : Type u_1) {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {A : Type u_3}
[inst_3 : Ring A] [inst_4 : Algebra R A] (F : UniversalEnvelopingAlgebra R L →ₐ[R] A),
(fun f => (UniversalEnvelopingAlgebra.ringCon R L).liftₐ ((TensorAlgebra.lift R) ↑f) ⋯)
((fun F => F.toLieHom... | null | false |
Matrix.toLpLinAlgEquiv_symm_apply | Mathlib.Analysis.Normed.Lp.Matrix | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R] (p : ENNReal)
(a : Module.End R (WithLp p (n → R))), (Matrix.toLpLinAlgEquiv p).symm a = (Matrix.toLpLin p p).symm a | null | true |
Cardinal.lt_one_iff | Mathlib.SetTheory.Cardinal.Basic | ∀ {c : Cardinal.{u_1}}, c < 1 ↔ c = 0 | null | true |
Lean.Elab.TerminationBy.synthetic | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.TerminationBy → Bool | If `synthetic := true`, then this `termination_by` clause was
generated by `GuessLex`, and `vars` refers to *all* parameters
of the function, not just the “extra parameters”.
Cf. Lean.Elab.WF.unpackUnary
| true |
Mathlib.Tactic.BicategoryLike.Mor₂.comp.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ (e : Lean.Expr) (isoLift? : Option Mathlib.Tactic.BicategoryLike.IsoLift) (f g h : Mathlib.Tactic.BicategoryLike.Mor₁)
(η θ : Mathlib.Tactic.BicategoryLike.Mor₂),
sizeOf (Mathlib.Tactic.BicategoryLike.Mor₂.comp e isoLift? f g h η θ) =
1 + sizeOf e + sizeOf isoLift? + sizeOf f + sizeOf g + sizeOf h + sizeOf η ... | null | true |
_private.Lean.Meta.Sym.InstantiateS.0.Lean.Meta.Sym.instantiateRevRangeS._proof_1 | Lean.Meta.Sym.InstantiateS | ∀ (beginIdx endIdx : ℕ) (subst : Array Lean.Expr),
¬beginIdx > endIdx →
¬endIdx > subst.size →
∀ (offset idx : ℕ),
idx ≥ beginIdx + offset →
idx < offset + (endIdx - beginIdx) → endIdx - beginIdx - (idx - offset) - 1 < subst.size | null | false |
Manifold.«_aux_Mathlib_Geometry_Manifold_ContMDiffMap___macroRules_Manifold_termC^_⟮_,_;_⟯_1» | Mathlib.Geometry.Manifold.ContMDiffMap | Lean.Macro | null | false |
GradedMonoid.GSMul.rec | Mathlib.Algebra.GradedMulAction | {ιA : Type u_1} →
{ιM : Type u_3} →
{A : ιA → Type u_4} →
{M : ιM → Type u_5} →
[inst : VAdd ιA ιM] →
{motive : GradedMonoid.GSMul A M → Sort u} →
((smul : {i : ιA} → {j : ιM} → A i → M j → M (i +ᵥ j)) → motive { smul := smul }) →
(t : GradedMonoid.GSMul A M) → mo... | null | false |
Std.Time.TimeZone.TZif.TZifV2._sizeOf_inst | Std.Time.Zoned.Database.TzIf | SizeOf Std.Time.TimeZone.TZif.TZifV2 | null | false |
PresheafOfModules.evaluationJointlyReflectsLimits | Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
{J : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] →
(F : CategoryTheory.Functor J (PresheafOfModules R)) →
[∀ (X : Cᵒᵖ),
Small.{v, max u₂ v}
... | A cone in the category `PresheafOfModules R` is limit if it is so after the application
of the functors `evaluation R X` for all `X`. | true |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.instToJsonRpcEncodablePacket.toJson.match_1._@.Lean.Widget.InteractiveDiagnostic.29703178._hygCtx._hyg.38 | Lean.Widget.InteractiveDiagnostic | (motive : Lean.Widget.RpcEncodablePacket✝ → Sort u_1) →
(x : Lean.Widget.RpcEncodablePacket✝) →
((a : Lean.Json) → motive (Lean.Widget.RpcEncodablePacket.strict✝ a)) →
((a : Lean.Json) → motive (Lean.Widget.RpcEncodablePacket.lazy✝ a)) → motive x | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.localization_away_comap_range._simp_1_3 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | null | false |
Mathlib.PrintSorries.State.mk.inj | Mathlib.Util.PrintSorries | ∀ {visited : Lean.NameSet} {sorries : Std.HashSet Lean.Expr} {sorryMsgs : Array Lean.MessageData}
{visited_1 : Lean.NameSet} {sorries_1 : Std.HashSet Lean.Expr} {sorryMsgs_1 : Array Lean.MessageData},
{ visited := visited, sorries := sorries, sorryMsgs := sorryMsgs } =
{ visited := visited_1, sorries := sorri... | null | true |
Submodule.equivMapOfInjective._proof_4 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_1} {M₂ : Type u_2} [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₂) (i : Function.Injective ⇑f) (p : Submodule R M),
Function.RightInvers... | null | false |
NonUnitalStarSubalgebra.toNonUnitalSubring_injective | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A] [inst_3 : Star A],
Function.Injective NonUnitalStarSubalgebra.toNonUnitalSubring | null | true |
Lean.ErrorExplanation.Metadata.removedVersion? | Lean.ErrorExplanation | Lean.ErrorExplanation.Metadata → Option String | null | true |
CategoryTheory.sheafificationNatIso | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type u_1) →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[inst_2 : CategoryTheory.HasWeakSheafify J D] →
CategoryTheory.Functor.id (CategoryTheory.Sheaf J D) ≅
... | The natural isomorphism `𝟭 (Sheaf J D) ≅ sheafToPresheaf J D ⋙ presheafToSheaf J D`. | true |
MulAut.characteristic._proof_9 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [H.Characteristic] (h : ↥H),
↑h ∈ Subgroup.comap (MulEquiv.toMonoidHom 1) H | null | false |
MultilinearMap.domCoprod_alternatization_coe | Mathlib.LinearAlgebra.Alternating.DomCoprod | ∀ {ιa : Type u_1} {ιb : Type u_2} [inst : Fintype ιa] [inst_1 : Fintype ιb] {R' : Type u_3} {Mᵢ : Type u_4}
{N₁ : Type u_5} {N₂ : Type u_6} [inst_2 : CommSemiring R'] [inst_3 : AddCommGroup N₁] [inst_4 : Module R' N₁]
[inst_5 : AddCommGroup N₂] [inst_6 : Module R' N₂] [inst_7 : AddCommMonoid Mᵢ] [inst_8 : Module R'... | A helper lemma for `MultilinearMap.domCoprod_alternatization`. | true |
RelIso.sumLexComplRight_symm_apply | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {x : α} [inst : IsTrans α r] [inst_1 : Std.Trichotomous r] [inst_2 : DecidableRel r]
(a : { x_1 // ¬r x x_1 } ⊕ Subtype (r x)), (RelIso.sumLexComplRight r x) a = (Equiv.sumCompl (r x)) a.swap | null | true |
CategoryTheory.instIsAddModHomNegOfHom | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D]
(A : C) [inst_4 : CategoryTheory.AddMonObj A] {M N : D} [inst_5 : CategoryTheory.AddM... | null | true |
CategoryTheory.ShortComplex.RightHomologyMapData.comp_φQ | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {φ' : S₂ ⟶ S₃} {h₁ : S₁.RightHomologyData}
{h₂ : S₂.RightHomologyData} {h₃ : S₃.RightHomologyData} (ψ : CategoryTheory.ShortComplex.RightHomolog... | null | true |
WithSeminorms.hasBasis_ball | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {p : SeminormFamily 𝕜 E ι},
WithSeminorms p → ∀ {x : E}, (nhds x).HasBasis (fun sr => 0 < sr.2) fun sr => (sr.1.sup p).ball x sr.2 | null | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.getParamInfo | Lean.Elab.App | Lean.Elab.Term.ElabAppArgs.M Lean.BinderInfo | Returns the current parameter's binder info.
Only valid if `fTypeIsForall` has returned `true`.
| true |
List.sortedLE_ofFn_iff | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} {f : Fin n → α}, (List.ofFn f).SortedLE ↔ Monotone f | The list `List.ofFn f` is sorted with respect to `(· ≤ ·)` if and only if `f` is monotone. | true |
Rel.edgeDensity.congr_simp | Mathlib.Combinatorics.SimpleGraph.Density | ∀ {α : Type u_4} {β : Type u_5} (r r_1 : α → β → Prop),
r = r_1 →
∀ {inst : (a : α) → DecidablePred (r a)} [inst_1 : (a : α) → DecidablePred (r_1 a)] (s s_1 : Finset α),
s = s_1 → ∀ (t t_1 : Finset β), t = t_1 → Rel.edgeDensity r s t = Rel.edgeDensity r_1 s_1 t_1 | null | true |
CategoryTheory.CostructuredArrow.toOverCompYoneda._proof_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
(T : CategoryTheory.Over A) {X Y : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.CostructuredArrow.toOver CategoryTheory.... | null | false |
Lean.IR.LogEntry | Lean.Compiler.IR.CompilerM | Type | null | true |
_private.Mathlib.Tactic.Linter.MinImports.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.MinImports.2382540021._hygCtx._hyg.2 | Mathlib.Tactic.Linter.MinImports | IO (IO.Ref Mathlib.Linter.ImportState✝) | null | false |
Differentiable.continuous | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : 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 : E → F} [ContinuousAdd E] [ContinuousSMul 𝕜 E] [ContinuousAdd F]
[C... | null | true |
Int64.sub_mul | Init.Data.SInt.Lemmas | ∀ {a b c : Int64}, (a - b) * c = a * c - b * c | null | true |
OrderHom.gfp_le | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, (∀ b ≤ f b, b ≤ a) → OrderHom.gfp f ≤ a | null | true |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic.0.Algebra.finite_iff_isIntegral_and_finiteType.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(motive : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A → Prop)
(x : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A),
(∀ (h : Algebra.IsIntegral R A) (right : Algebra.FiniteType R A), motive ⋯) → motive x | null | false |
Lean.Compiler.LCNF.instInhabitedLetDecl | Lean.Compiler.LCNF.Basic | {a : Lean.Compiler.LCNF.Purity} → Inhabited (Lean.Compiler.LCNF.LetDecl a) | null | true |
Lean.Parser.Tactic.mcasesPatAlts | Std.Tactic.Do.Syntax | Lean.ParserDescr | null | true |
Nucleus.mem_toSublocale | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {n : Nucleus X} {x : X}, x ∈ n.toSublocale ↔ ∃ y, n y = x | null | true |
CategoryTheory.LaxFunctor.mk.noConfusion | Mathlib.CategoryTheory.Bicategory.Functor.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{P : Sort u} →
{toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C} →
{mapId :
(a : B) →
CategoryTheory.CategoryStruct.id (toPrelaxF... | null | false |
ULift.div | Mathlib.Algebra.Group.ULift | {α : Type u} → [Div α] → Div (ULift.{u_1, u} α) | null | true |
LinearIsometryEquiv.symm_conjStarAlgEquiv | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (e : H ≃ₗᵢ[𝕜] K), e.conjStarAlgEquiv.symm = e.symm.conjStarAlg... | null | true |
CategoryTheory.Functor.prod._proof_2 | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{u_7, u_1} A] {B : Type u_5}
[inst_1 : CategoryTheory.Category.{u_3, u_5} B] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_8, u_2} C]
{D : Type u_6} [inst_3 : CategoryTheory.Category.{u_4, u_6} D] (F : CategoryTheory.Functor A B)
(G : CategoryTheory.Functor C... | null | false |
MeasureTheory.lintegral_lintegral_symm | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] ⦃f : α → β → ENNReal⦄,
AEMeasurable (Function.uncurry f) (μ.prod ν) →
∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (... | The reversed version of **Tonelli's Theorem** (symmetric version). In this version `f` is in
curried form, which makes it easier for the elaborator to figure out `f` automatically. | true |
CompactlySupportedContinuousMap._sizeOf_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_5} →
{β : Type u_6} →
{inst : TopologicalSpace α} →
{inst_1 : Zero β} →
{inst_2 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → CompactlySupportedContinuousMap α β → ℕ | null | false |
Mathlib.Tactic.BicategoryCoherence.LiftHom.recOn | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{motive : Mathlib.Tactic.BicategoryCoherence.LiftHom f → Sort u_1} →
(t : Mathlib.Tactic.BicategoryCoherence.LiftHom f) →
((lift : CategoryTheory.FreeBicategory.of.obj a ⟶ CategoryTheory.FreeBicateg... | null | false |
StarMemClass.rec | Mathlib.Algebra.Star.Basic | {S : Type u_1} →
{R : Type u_2} →
[inst : Star R] →
[inst_1 : SetLike S R] →
{motive : StarMemClass S R → Sort u} →
((star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s) → motive ⋯) → (t : StarMemClass S R) → motive t | null | false |
Std.IterM.stepSize | Std.Data.Iterators.Combinators.Monadic.StepSize | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] → [Std.IteratorAccess α m] → [Monad m] → Std.IterM m β → ℕ → Std.IterM m β | Produces an iterator that emits one value of `it`, then drops `n - 1` elements, then emits another
value, and so on. In other words, it emits every `n`-th value of `it`, starting with the first one.
If `n = 0`, the iterator behaves like for `n = 1`: It emits all values of `it`.
**Marble diagram:**
```
it ... | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._proof_1_6 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (y : BitVec w), ¬2 ^ w - 1 - y.toNat < 2 ^ w → False | null | false |
ContMDiffVAdd.mk._flat_ctor | Mathlib.Geometry.Manifold.Algebra.SMul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {H' : Type u_4}
[inst_4 : TopologicalSpace H'] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : Normed... | null | false |
ContinuousMap.Homotopy.extend_one | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
(F : f₀.Homotopy f₁), F.extend 1 = f₁ | null | true |
MeasureTheory.exists_subordinate_pairwise_disjoint | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {ι : Type u_1} {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [Countable ι] {s : ι → Set α},
(∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) →
Pairwise (Function.onFun (MeasureTheory.AEDisjoint μ) s) →
∃ t,
(∀ (i : ι), t i ⊆ s i) ∧
(∀ (i : ι), s i =ᵐ[μ] t i) ∧... | If `sᵢ` is a countable family of (null) measurable pairwise `μ`-a.e. disjoint sets, then there
exists a subordinate family `tᵢ ⊆ sᵢ` of measurable pairwise disjoint sets such that
`tᵢ =ᵐ[μ] sᵢ`. | true |
RightCancelMonoid.Nat.card_submonoidPowers | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : RightCancelMonoid G] {a : G}, Nat.card ↥(Submonoid.powers a) = orderOf a | See also `orderOf_eq_card_powers`. | true |
_private.Mathlib.Algebra.Lie.Ideal.0.LieIdeal.comap._simp_2 | Mathlib.Algebra.Lie.Ideal | ∀ {M : Type u_1} [inst : AddZeroClass M] {s : AddSubmonoid M} {x : M}, (x ∈ s.toAddSubsemigroup) = (x ∈ s) | null | false |
Mul.recOn | Init.Prelude | {α : Type u} → {motive : Mul α → Sort u_1} → (t : Mul α) → ((mul : α → α → α) → motive { mul := mul }) → motive t | null | false |
SubmoduleClass.module'._proof_2 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u_3} {R : Type u_4} {M : Type u_1} {T : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Semiring S] [inst_3 : Module R M] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M]
[inst_7 : SetLike T M] [inst_8 : SMulMemClass T R M] (t : T) (x : ↥t), 1 • x = x | null | false |
_private.Mathlib.Algebra.Group.Subgroup.Basic.0.Subgroup.normal_iff_map_conj_eq._simp_1_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.Normal = (Subgroup.normalizer ↑H = ⊤) | null | false |
_private.Mathlib.NumberTheory.Divisors.0.Nat.pairwise_divisorsAntidiagonalList_snd._simp_1_4 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
_private.Lean.Compiler.LCNF.DeclHash.0.Lean.Compiler.LCNF.instHashableSignature.hash.match_1 | Lean.Compiler.LCNF.DeclHash | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Signature pu → Sort u_1) →
(x : Lean.Compiler.LCNF.Signature pu) →
((a : Lean.Name) →
(a_1 : List Lean.Name) →
(a_2 : Lean.Expr) →
(a_3 : Array (Lean.Compiler.LCNF.Param pu)) →
(a_4 : Bool) → ... | null | false |
USize.lt_of_le_of_lt | Init.Data.UInt.Lemmas | ∀ {a b c : USize}, a ≤ b → b < c → a < c | null | true |
CategoryTheory.monoidalCategoryMop._proof_11 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(W X Y Z : Cᴹᵒᵖ),
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z.unmop
(CategoryTheory.MonoidalCategoryStruct.associator Y.unmop X.unmop W.unmop).... | null | false |
ZSpan.fract_eq_self | 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] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] {x : E}, ZSpan.fract b x = x ↔ x ∈ ZSpan.fundamentalDomain b | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0._regBuiltin.Nat.isValue.declare_119._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.4243845176._hygCtx._hyg.23 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | null | false |
groupHomology.inhomogeneousChains.d._proof_4 | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ (n : ℕ), NeZero (n + 1) | null | false |
instDecidableIsValidUTF8 | Init.Data.String.Basic | {b : ByteArray} → Decidable b.IsValidUTF8 | null | true |
Matroid.IsBasis'.eRk_eq_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis' I X → M.eRk X = I.encard | null | true |
AddOpposite.coe_symm_opAddEquiv | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} [inst : AddCommMonoid M], ⇑AddOpposite.opAddEquiv.symm = AddOpposite.unop | null | true |
LocalSubring.exists_le_valuationSubring | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_3} [inst : Field K] (A : LocalSubring K), ∃ B, A ≤ B.toLocalSubring | [Stacks Tag 00IA](https://stacks.math.columbia.edu/tag/00IA) | true |
AddMonCat.forget_createsLimit._proof_6 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.forget AddMonCat))) (t : CategoryTheory.Limits.IsLimit c)
(this : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections)
(x : Cate... | null | false |
Complex.tan | Mathlib.Analysis.Complex.Trigonometric | ℂ → ℂ | The complex tangent function, defined as `sin z / cos z` | true |
isMinOn_Iic_of_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b c : ℝ},
ContinuousAt f b →
ContinuousAt f c →
DifferentiableOn ℝ f (Set.Iio b) →
DifferentiableOn ℝ f (Set.Ioo b c) →
(∀ x ∈ Set.Iio b, deriv f x ≤ 0) → (∀ x ∈ Set.Ioo b c, 0 ≤ deriv f x) → IsMinOn f (Set.Iic c) b | Suppose `f : ℝ → ℝ` is continuous at `b` and `c`, the derivative `f'` is nonpositive on
`Iio b` and nonnegative on `Ioo b c`. Then `f` attains its minimum on `Iic c` at `b`. | true |
Finset.sup_eq_bot_of_isEmpty | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] [IsEmpty β] (f : β → α) (S : Finset β),
S.sup f = ⊥ | null | true |
QuasiconcaveOn.convex_gt | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasiconcaveOn 𝕜 s f → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ r < f x} | null | true |
Nat.prod_divisors_prime_pow | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} [inst : CommMonoid α] {k p : ℕ} {f : ℕ → α},
Nat.Prime p → ∏ x ∈ (p ^ k).divisors, f x = ∏ x ∈ Finset.range (k + 1), f (p ^ x) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.IsStrictlyPositive.sqrt._proof_1_8 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A] [inst_5 : Algebra ℝ A]
[inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint], NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint | null | false |
Equiv.semilatticeInf | Mathlib.Order.Lattice | {α : Type u} → {β : Type v} → α ≃ β → [SemilatticeInf β] → SemilatticeInf α | Transfer `SemilatticeInf` across an `Equiv`. | true |
StrictMonoOn.add | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f g : β → α} {s : Set β}
[AddLeftStrictMono α] [AddRightStrictMono α],
StrictMonoOn f s → StrictMonoOn g s → StrictMonoOn (fun x => f x + g x) s | The sum of two strictly monotone functions is strictly monotone. | true |
Submodule.mem_span_set | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : M}
{s : Set M}, m ∈ Submodule.span R s ↔ ∃ c, ↑c.support ⊆ s ∧ (c.sum fun mi r => r • mi) = m | An element `m ∈ M` is contained in the `R`-submodule spanned by a set `s ⊆ M`, if and only if
`m` can be written as a finite `R`-linear combination of elements of `s`.
The implementation uses `Finsupp.sum`. | true |
_private.Init.Data.Int.Gcd.0.Int.lcm_mul_right_dvd_mul_lcm._simp_1_1 | Init.Data.Int.Gcd | ∀ (k m n : ℕ), (k.lcm (m * n) ∣ k.lcm m * k.lcm n) = True | null | false |
MulOpposite.instCancelCommMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : CancelCommMonoid α],
MulOpposite.instCancelCommMonoid = { toCommMonoid := MulOpposite.instCommMonoid, toIsLeftCancelMul := ⋯ } | null | true |
_private.Mathlib.Algebra.MonoidAlgebra.Module.0.MonoidAlgebra.single_mem_span_single._simp_1_2 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {α : Type u_1} (R : Type u_3) [inst : Semiring R] [Nontrivial R] {a : α} {s : Set α},
((fun₀ | a => 1) ∈ Submodule.span R ((fun x => fun₀ | x => 1) '' s)) = (a ∈ s) | null | false |
AdicCompletion.AdicCauchySequence.instAddCommGroup._proof_4 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : AdicCompletion.AdicCauchySequence I M), ↑(-x) = ↑(-x) | null | false |
TrivSqZeroExt.isNilpotent_inr | Mathlib.RingTheory.DualNumber | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M] (x : M), IsNilpotent (TrivSqZeroExt.inr x) | null | true |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset._sparseCasesOn_1 | Lean.Meta.Sym.Offset | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.