name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Internal.IO.Async.Signal.sigxfsz.elim | Std.Internal.Async.Signal | {motive : Std.Internal.IO.Async.Signal → Sort u} →
(t : Std.Internal.IO.Async.Signal) → t.ctorIdx = 16 → motive Std.Internal.IO.Async.Signal.sigxfsz → motive t | false |
MonoidWithZeroHom | Mathlib.Algebra.GroupWithZero.Hom | (α : Type u_7) → (β : Type u_8) → [MulZeroOneClass α] → [MulZeroOneClass β] → Type (max u_7 u_8) | true |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise.0.SubMulAction.instMulOneClass._simp_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | ∀ {R : Type u_1} {M : Type u_2} [inst : Monoid R] [inst_1 : MulAction R M] [inst_2 : Mul M]
[inst_3 : IsScalarTower R M M] {p q : SubMulAction R M} {x : M}, (x ∈ p * q) = ∃ y ∈ p, ∃ z ∈ q, y * z = x | false |
Std.DTreeMap.Internal.Impl.Const.get!_insertIfNew! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
t.WF →
∀ {k a : α} {v : β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.insertIfNew! k v t) a =
if compare k a = Ordering.eq ∧ k ∉ t then v else ... | true |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr.mkBVConst | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr | {w : ℕ} → BitVec w → Lean.Elab.Tactic.BVDecide.Frontend.M Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr | true |
ContDiffOn.continuousOn_fderivWithin_apply | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {f : E → F}
{n : WithTop ℕ∞},
ContDiffOn 𝕜 n f s → UniqueDiffOn 𝕜 s → 1 ≤ n → ContinuousOn (fun ... | true |
MultiplierAlgebra.«_aux_Mathlib_Analysis_CStarAlgebra_Multiplier___macroRules_MultiplierAlgebra_term𝓜(_,_)_1» | Mathlib.Analysis.CStarAlgebra.Multiplier | Lean.Macro | false |
iteratedFDerivWithin_insert | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : ℕ} {y : E}, iteratedFDerivWithin 𝕜 n f (insert x s) y = iteratedFDerivWithin �... | true |
Finite.ciInf_le_of_le | Mathlib.Data.Fintype.Order | ∀ {α : Type u_1} {ι : Type u_2} [Finite ι] [inst : ConditionallyCompleteLattice α] {a : α} {f : ι → α} (c : ι),
f c ≤ a → iInf f ≤ a | true |
AddActionHom.inverse._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {X : Type u_1} [inst : VAdd M X] {Y₁ : Type u_3} [inst_1 : VAdd M Y₁] (f : X →ₑ[id] Y₁) (g : Y₁ → X)
(m : M) (x : Y₁), g (m +ᵥ f (g x)) = g (f (m +ᵥ g x)) | false |
Lean.Meta.Simp.debug.simp.check.have | Lean.Meta.Tactic.Simp.Main | Lean.Option Bool | true |
_private.Aesop.Script.Step.0.Aesop.Script.LazyStep.runFirstSuccessfulTacticBuilder.tryTacticBuilder.match_4 | Aesop.Script.Step | (motive : Option (Lean.Meta.SavedState × List Lean.MVarId) → Sort u_1) →
(tacticResult : Option (Lean.Meta.SavedState × List Lean.MVarId)) →
((actualPostState : Lean.Meta.SavedState) →
(actualPostGoals : List Lean.MVarId) → motive (some (actualPostState, actualPostGoals))) →
((x : Option (Lean.Meta.... | false |
_private.Mathlib.Order.Cover.0.LT.lt.exists_disjoint_Iio_Ioi._proof_1_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, a < b → ∃ a', a < a' ∧ ∃ b' < b, ∀ x < a', ∀ (y : α), b' < y → x < y | false |
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) ⋯ | 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,... | 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 | 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... | 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 | 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 | 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' : V} {p₂ : G.Walk u' v'} (k i : ℕ),
k + i + 1 ≤ p₂.support.length → k + i < p₂.support.length | false |
Int8.ofUInt8.sizeOf_spec | Init.Data.SInt.Basic | ∀ (toUInt8 : UInt8), sizeOf { toUInt8 := toUInt8 } = 1 + sizeOf toUInt8 | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0._regBuiltin.String.reducePush.declare_28._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.1574800046._hygCtx._hyg.14 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars.0.Lean.Meta.Grind.Arith.Cutsat.updateVarCoeff | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | ℤ → Int.Linear.Var → Lean.Meta.Grind.Arith.Cutsat.CollectM✝ Unit | 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 | true |
Ordnode.repr._f | Mathlib.Data.Ordmap.Ordnode | {α : Type u_2} → [Repr α] → ℕ → (o : Ordnode α) → Ordnode.below o → Std.Format | false |
Real.sin_arctan_lt_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, Real.sin (Real.arctan x) < 0 ↔ x < 0 | true |
SSet.N.eq_iff | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} {x y : X.N}, x = y ↔ x.subcomplex = y.subcomplex | true |
Aesop.NormalizationState.isNormal | Aesop.Tree.Data | Aesop.NormalizationState → Bool | 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 | true |
Zero.ctorIdx | Init.Prelude | {α : Type u} → Zero α → ℕ | 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 | true |
Cardinal.lt_one_iff | Mathlib.SetTheory.Cardinal.Basic | ∀ {c : Cardinal.{u_1}}, c < 1 ↔ c = 0 | true |
Lean.Elab.TerminationBy.synthetic | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.TerminationBy → Bool | true |
BoundedContinuousFunction.coe_nsmulRec._f | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : AddMonoid β]
[inst_3 : BoundedAdd β] [inst_4 : ContinuousAdd β] (f : BoundedContinuousFunction α β) (x : ℕ) (f_1 : Nat.below x),
⇑(nsmulRec x f) = x • ⇑f | false |
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 η ... | 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 | false |
Manifold.«_aux_Mathlib_Geometry_Manifold_ContMDiffMap___macroRules_Manifold_termC^_⟮_,_;_⟯_1» | Mathlib.Geometry.Manifold.ContMDiffMap | Lean.Macro | 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... | false |
Std.Time.TimeZone.TZif.TZifV2._sizeOf_inst | Std.Time.Zoned.Database.TzIf | SizeOf Std.Time.TimeZone.TZif.TZifV2 | 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}
... | true |
_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) | false |
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... | 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... | true |
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 | true |
Lean.ErrorExplanation.Metadata.removedVersion? | Lean.ErrorExplanation | Lean.ErrorExplanation.Metadata → Option String | 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) ≅
... | 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 | 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... | 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 | true |
List.sortedLE_ofFn_iff | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} {f : Fin n → α}, (List.ofFn f).SortedLE ↔ Monotone f | 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 | 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.... | false |
Lean.IR.LogEntry | Lean.Compiler.IR.CompilerM | Type | true |
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... | true |
Int64.sub_mul | Init.Data.SInt.Lemmas | ∀ {a b c : Int64}, (a - b) * c = a * c - b * c | true |
OrderHom.gfp_le | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, (∀ b ≤ f b, b ≤ a) → OrderHom.gfp f ≤ a | 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 | false |
Lean.Compiler.LCNF.instInhabitedLetDecl | Lean.Compiler.LCNF.Basic | {a : Lean.Compiler.LCNF.Purity} → Inhabited (Lean.Compiler.LCNF.LetDecl a) | true |
Lean.Parser.Tactic.mcasesPatAlts | Std.Tactic.Do.Syntax | Lean.ParserDescr | 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 | true |
ULift.div | Mathlib.Algebra.Group.ULift | {α : Type u} → [Div α] → Div (ULift.{u_1, u} α) | 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... | false |
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... | 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... | 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 ∂ν ∂μ = ∫⁻ (... | 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 α β → ℕ | 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... | 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 | 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 β | 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 | 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₁ | 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) ∧... | true |
RightCancelMonoid.Nat.card_submonoidPowers | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : RightCancelMonoid G] {a : G}, Nat.card ↥(Submonoid.powers a) = orderOf a | 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) | false |
Mul.recOn | Init.Prelude | {α : Type u} → {motive : Mul α → Sort u_1} → (t : Mul α) → ((mul : α → α → α) → motive { mul := mul }) → motive t | 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 | 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) | 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) → ... | false |
USize.lt_of_le_of_lt | Init.Data.UInt.Lemmas | ∀ {a b c : USize}, a ≤ b → b < c → a < c | true |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.Reorder.permute!.cyclicPermuteAux._unsafe_rec | Mathlib.Tactic.Translate.Reorder | {α : Type u_1} → Array α → List ℕ → α → ℕ → Array α | false |
Lean.Elab.Term.StructInst.SourcesView.noConfusionType | Lean.Elab.StructInst | Sort u → Lean.Elab.Term.StructInst.SourcesView → Lean.Elab.Term.StructInst.SourcesView → Sort u | false |
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).... | 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 | true |
groupHomology.inhomogeneousChains.d._proof_4 | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G) (n : ℕ),
SMulCommClass k k ((Fin n → G) →₀ ↑A) | false |
instDecidableIsValidUTF8 | Init.Data.String.Basic | {b : ByteArray} → Decidable b.IsValidUTF8 | 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 | true |
AddOpposite.coe_symm_opAddEquiv | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} [inst : AddCommMonoid M], ⇑AddOpposite.opAddEquiv.symm = AddOpposite.unop | true |
LocalSubring.exists_le_valuationSubring | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_3} [inst : Field K] (A : LocalSubring K), ∃ B, A ≤ B.toLocalSubring | true |
AddMonCat.forget_createsLimit._proof_6 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
(this : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections)
(s : CategoryTheory.Limits.Cone F) (x y : ↑s.1),
(CategoryTheory.Limits.Types.Small.limitConeIsLimit (F.comp (CategoryTheor... | false |
Complex.tan | Mathlib.Analysis.Complex.Trigonometric | ℂ → ℂ | 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 | 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 = ⊥ | 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} | 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) | 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 | false |
Equiv.semilatticeInf | Mathlib.Order.Lattice | {α : Type u} → {β : Type v} → α ≃ β → [SemilatticeInf β] → SemilatticeInf α | 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 | 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 | 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 | false |
MulOpposite.instCancelCommMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : CancelCommMonoid α],
MulOpposite.instCancelCommMonoid = { toCommMonoid := MulOpposite.instCommMonoid, toIsLeftCancelMul := ⋯ } | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.