name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.CoconeMorphism.inv_hom_id | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {c d : CategoryTheory.Limits.Cocone F} (f : c ≅ d),
CategoryTheory.CategoryStruct.comp f.inv.hom f.hom.hom = CategoryTheory.CategoryStruct.id d.pt | null | true |
_private.Lean.Environment.0.Lean.saveModuleDataParts._proof_1 | Lean.Environment | ∀ (parts : Array (System.FilePath × Lean.ModuleData)), ∀ i ∈ [:parts.size], i < parts.size | null | false |
Pi.Function.module | Mathlib.Algebra.Module.Pi | (I : Type u) →
(α : Type u_1) → (β : Type u_2) → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [Module α β] → Module α (I → β) | A special case of `Pi.module` for non-dependent types. Lean struggles to elaborate
definitions elsewhere in the library without this. | true |
Ideal.sup_height_eq_ringKrullDim | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] [Nontrivial R], ↑(⨆ I, ⨆ (_ : I ≠ ⊤), I.height) = ringKrullDim R | In a nontrivial commutative ring `R`, the supremum of heights of all ideals is equal to the
Krull dimension of `R`. | true |
Std.DTreeMap.foldlM_eq_foldlM_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} {δ : Type w} {m : Type w → Type w'}
[inst : Monad m] [LawfulMonad m] {f : δ → α → m δ} {init : δ},
Std.DTreeMap.foldlM (fun d a x => f d a) init t = List.foldlM f init t.keys | null | true |
Commute.self_pow | Mathlib.Algebra.Group.Commute.Defs | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), Commute a (a ^ n) | null | true |
bilinearIteratedFDerivTwo.eq_1 | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
(x : E), bilinearIteratedFDerivTwo 𝕜 f x = ContinuousLinearMap.toLinearMap₁₂ (fderiv 𝕜 (fderiv 𝕜 ... | null | true |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar.0.MeasureTheory.Measure.tendsto_addHaar_inter_smul_zero_of_density_zero_aux2._simp_1_1 | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] {a : α} [AddRightMono α],
(|a| ≤ 0) = (a = 0) | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.instMonadLiftTermElabMDocM.match_1 | Lean.Elab.DocString | (motive : Lean.Doc.State → Sort u_1) →
(x : Lean.Doc.State) →
((scopes : List Lean.Elab.Command.Scope) →
(openDecls : List Lean.OpenDecl) →
(lctx : Lean.LocalContext) →
(localInstances : Lean.LocalInstances) →
(options : Lean.Options) →
motive
... | null | false |
LinearMap.mem_finiteRange_iff_hasFiniteRange | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_3} [inst : CommRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] [IsNoetherianRing K] {f : V →ₗ[K] V₂},
f ∈ LinearMap.finiteRange K V V₂ ↔ f.HasFiniteRange | null | true |
Lean.InternalExceptionId.toString | Lean.InternalExceptionId | Lean.InternalExceptionId → String | Convert internal exception id into the message "internal exception #<idx>" | true |
Polynomial.isMonicOfDegree_sub_add_two | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Ring R] [Nontrivial R] (a b : R),
(Polynomial.X ^ 2 - Polynomial.C a * Polynomial.X + Polynomial.C b).IsMonicOfDegree 2 | null | true |
Booleanisation.instTop | Mathlib.Order.Booleanisation | {α : Type u_1} → [GeneralizedBooleanAlgebra α] → Top (Booleanisation α) | The top element of `Booleanisation α` is the complement of the bottom element of `α`. | true |
Asymptotics.isLittleO_abs_right | Mathlib.Analysis.Asymptotics.Arith | ∀ {α : Type u_1} {E : Type u_2} [inst : Norm E] {f : α → E} {l : Filter α} {u : α → ℝ},
(f =o[l] fun x => |u x|) ↔ f =o[l] u | null | true |
ContinuousLinearMap.toContinuousAffineMap._proof_2 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_3} {V : Type u_1} {W : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : TopologicalSpace V] [inst_4 : AddCommGroup W] [inst_5 : Module R W] [inst_6 : TopologicalSpace W]
(f : V →L[R] W), Continuous (↑f).toFun | null | false |
CategoryTheory.PreZeroHypercover.interFst._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.PreZeroHypercover S)
[inst_1 : ∀ (i : E.I₀) (j : F.I₀), CategoryTheory.Limits.HasPullback (E.f i) (F.f j)] (x : (E.inter F).I₀),
CategoryTheory.Limits.HasPullback (E.f ((Equiv.sigmaE... | null | false |
Dynamics.netEntropyEntourage_le_coverEntropyEntourage | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} {U : SetRel X X} (T : X → X) (F : Set X),
Dynamics.netEntropyEntourage T F U ≤ Dynamics.coverEntropyEntourage T F U | null | true |
CategoryTheory.PreZeroHypercover.sumInl._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.PreZeroHypercover S) (i : E.I₀),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (E.X i)) ((E.sum F).f (Sum.inl i)) = E.f i | null | false |
_private.Lean.Meta.Sym.InstantiateS.0.Lean.Meta.Sym.instantiateRevBetaS'.visit.match_1 | Lean.Meta.Sym.InstantiateS | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((a : Lean.Literal) → e = Lean.Expr.lit a → motive (Lean.Expr.lit a)) →
((mvarId : Lean.MVarId) → e = Lean.Expr.mvar mvarId → motive (Lean.Expr.mvar mvarId)) →
((fvarId : Lean.FVarId) → e = Lean.Expr.fvar fvarId → motive (Lean.Expr.fvar fvarId)) →
... | null | false |
Lean.Meta.Sym.Simp.Context | Lean.Meta.Sym.Simp.SimpM | Type | Read-only context for the simplifier. | true |
BitVec.getLsb | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → Fin w → Bool | Returns the `i`th least significant bit.
| true |
CategoryTheory.Pseudofunctor.ObjectProperty.noConfusionType | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | Sort u_1 →
{B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat} →
F.ObjectProperty →
{B' : Type u} →
[inst' : CategoryTheory.Bicategory B'] →
{F' : CategoryTheory.Pseudofunctor B' CategoryTheory.Cat} → F'.Ob... | null | false |
SimpleGraph.Hom.map | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} →
{W : Type u_2} → (f : V → W) → (G : SimpleGraph V) → (∀ {u v : V}, G.Adj u v → f u ≠ f v) → G →g SimpleGraph.map f G | A function `f` that is injective on adjacent vertices in a graph `G`
(equivalently `f` is a valid `W`-coloring of `G`, or `G ≤ comap ⊤ f`)
is a homomorphism from `G` to the mapped graph. | true |
PreTilt.instCommRing._proof_27 | Mathlib.RingTheory.Perfection | ∀ (O : Type u_1) [inst : CommRing O] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p]
(a b c : PreTilt O p), (a + b) * c = a * c + b * c | null | false |
Std.Tactic.BVDecide.BoolExpr.toString._unsafe_rec | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | {α : Type} → [ToString α] → Std.Tactic.BVDecide.BoolExpr α → String | null | false |
Matrix.SpecialLinearGroup.exists_list_transvec_mul_diagonal_mul_list_transvec | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
(M : Matrix.SpecialLinearGroup ι F),
∃ L L' D,
∃ (hD : (Matrix.diagonal D).det = 1),
M =
(List.map Matrix.TransvectionStruct.toSpecialLinearGroup L).prod * ⟨Matrix.diagonal D, hD⟩ *
(List.map M... | The `SpecialLinearGroup` analogue of
`Matrix.Pivot.exists_list_transvec_mul_diagonal_mul_list_transvec`:
every element of `SL(ι, F)` is a product of transvections,
a diagonal matrix of determinant `1`, and transvections. | true |
CategoryTheory.Discrete.productEquiv._proof_15 | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} {X Y : CategoryTheory.Discrete J × CategoryTheory.Discrete K} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(({
obj := fun x =>
match x with
| (x, y) => { as := (x.as, y.as) },
map := fun {X Y} x =>
... | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Char.0.String.Slice.startsWith_char_iff_exists_append._simp_1_2 | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {α : Type u_1} {xs : List α} {a : α}, (xs.head? = some a) = ∃ ys, xs = a :: ys | null | false |
CategoryTheory.MonoidalCategory.ofTensorHom._auto_9 | Mathlib.CategoryTheory.Monoidal.Category | Lean.Syntax | null | false |
CategoryTheory.Sum.associativityFunctorEquivNaturalityFunctorIso_hom_app_snd_fst | Mathlib.CategoryTheory.Sums.Products | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {A' : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] {B : Type u} [inst_2 : CategoryTheory.Category.{v, u} B]
(T : Type u_3) [inst_3 : CategoryTheory.Category.{v_3, u_3} T] (X : CategoryTheory.Functor ((A ⊕ A') ⊕ T) B),
((CategoryTheory.Su... | null | true |
Equiv.sumEmpty | Mathlib.Logic.Equiv.Sum | (α : Type u_9) → (β : Type u_10) → [IsEmpty β] → α ⊕ β ≃ α | Sum with `IsEmpty` is equivalent to the original type. | true |
AlgebraicGeometry.IsReduced.mk | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (∀ (U : X.Opens), IsReduced ↑(X.presheaf.obj (Opposite.op U)))
AlgebraicGeometry.IsReduced.component_reduced._autoParam →
AlgebraicGeometry.IsReduced X | null | true |
_private.Lean.Meta.ExprLens.0.Lean.Core.viewBindersCoord._sparseCasesOn_2 | Lean.Meta.ExprLens | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t | null | false |
HomologicalComplex.mapBifunctor₂₃.D₂ | Mathlib.Algebra.Homology.BifunctorAssociator | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₂₃ : Type u_4} →
{C₃ : Type u_5} →
{C₄ : Type u_6} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] →
[inst_... | The second differential on `mapBifunctor K₁ (mapBifunctor K₂ K₃ G₂₃ c₂₃) F c₄`. | true |
_private.Mathlib.Tactic.Linter.HaveLetLinter.0.Mathlib.Linter.haveLet.initFn._@.Mathlib.Tactic.Linter.HaveLetLinter.3906617390._hygCtx._hyg.2 | Mathlib.Tactic.Linter.HaveLetLinter | IO Unit | null | false |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDenseLp.0.MeasureTheory.SimpleFunc.memLp_approxOn._simp_1_2 | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {E : Type u_4} [inst : SeminormedAddCommGroup E] (a b : E), ‖a - b‖ = dist a b | null | false |
ENNReal.HolderTriple.inv_le_inv | Mathlib.Basic.ENNReal.Holder | ∀ (p q r : ENNReal) [p.HolderTriple q r], p⁻¹ ≤ r⁻¹ | null | true |
CovBy.coe_fin | Mathlib.Order.SuccPred.Nat | ∀ {n : ℕ} {a b : Fin n}, a ⋖ b → ↑a ⋖ ↑b | **Alias** of the forward direction of `Fin.covBy_iff`. | true |
List.isSome_max?_of_mem | Init.Data.List.MinMax | ∀ {α : Type u_1} {l : List α} [inst : Max α] {a : α}, a ∈ l → l.max?.isSome = true | null | true |
instSetLikeSubRootedTreeα._proof_3 | Mathlib.Order.SuccPred.Tree | ∀ (t : RootedTree) (a₁ a₂ : SubRootedTree t), (fun v => Set.Ici v.root) a₁ = (fun v => Set.Ici v.root) a₂ → a₁ = a₂ | null | false |
IsCentralVAdd.mk._flat_ctor | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_9} {α : Type u_10} [inst : VAdd M α] [inst_1 : VAdd Mᵃᵒᵖ α],
(∀ (m : M) (a : α), AddOpposite.op m +ᵥ a = m +ᵥ a) → IsCentralVAdd M α | null | false |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.Poly.denote.match_1.eq_2 | Init.Data.Int.Linear | ∀ (motive : Int.Internal.Linear.Poly → Sort u_1) (k : ℤ) (v : Int.Internal.Linear.Var) (p : Int.Internal.Linear.Poly)
(h_1 : (k : ℤ) → motive (Int.Internal.Linear.Poly.num k))
(h_2 :
(k : ℤ) →
(v : Int.Internal.Linear.Var) → (p : Int.Internal.Linear.Poly) → motive (Int.Internal.Linear.Poly.add k v p)),
... | null | true |
Lean.Elab.TermInfo.recOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.TermInfo → Sort u} →
(t : Lean.Elab.TermInfo) →
((toElabInfo : Lean.Elab.ElabInfo) →
(lctx : Lean.LocalContext) →
(expectedType? : Option Lean.Expr) →
(expr : Lean.Expr) →
(isBinder isDisplayableTerm : Bool) →
motive
... | null | false |
_private.Mathlib.RingTheory.Localization.NumDen.0.IsFractionRing.isUnit_den_zero._simp_1_2 | Mathlib.RingTheory.Localization.NumDen | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
IsLocalization.IsInteger R 0 = True | null | false |
IsAlgebraic.algebraMap | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {S : Type u_1} {A : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Ring A]
[inst_3 : Algebra R A] [inst_4 : Algebra R S] [inst_5 : Algebra S A] [IsScalarTower R S A] {a : S},
IsAlgebraic R a → IsAlgebraic R ((algebraMap S A) a) | null | true |
CategoryTheory.Precoverage.ZeroHypercover.Small.casesOn | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Precoverage C} →
{S : C} →
{E : J.ZeroHypercover S} →
{motive : E.Small → Sort u_1} →
(t : E.Small) →
((exists_restrictIndex_mem : ∃ ι f, (E.restrictIndex f).presieve₀ ∈ J.coverings S) ... | null | false |
CategoryTheory.Limits.epi_image_of_epi | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasImage f] [E : CategoryTheory.Epi f],
CategoryTheory.Epi (CategoryTheory.Limits.image.ι f) | null | true |
Nat.infinite_odd_deficient | Mathlib.NumberTheory.FactorisationProperties | {n | Odd n ∧ n.Deficient}.Infinite | null | true |
Ordinal.nfp_zero | Mathlib.SetTheory.Ordinal.FixedPoint | Ordinal.nfp 0 = id | null | true |
String.eq_empty_iff_forall_eq | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String}, s = "" ↔ ∀ (p q : s.Pos), p = q | null | true |
Std.Internal.List.getKey?_eq_getEntry? | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α},
Std.Internal.List.getKey? a l = Option.map (fun x => x.fst) (Std.Internal.List.getEntry? a l) | null | true |
Int.radical_natCast | Mathlib.RingTheory.Radical.NatInt | ∀ {n : ℕ}, UniqueFactorizationMonoid.radical ↑n = ↑(UniqueFactorizationMonoid.radical n) | null | true |
DilationEquiv.smulTorsor._proof_3 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {𝕜 : Type u_3} {E : Type u_2} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module 𝕜 E]
[NormSMulClass 𝕜 E] {P : Type u_1} [inst_4 : PseudoMetricSpace P] [inst_5 : NormedAddTorsor E P] (c : P) {k : 𝕜}
(x y : E), edist (k • x +ᵥ c) (k • y +ᵥ c) = ↑‖k‖₊ * edist x y | null | false |
Sym.fill | Mathlib.Data.Sym.Basic | {α : Type u_1} → {n : ℕ} → α → (i : Fin (n + 1)) → Sym α (n - ↑i) → Sym α n | Fill a term `m : Sym α (n - i)` with `i` copies of `a` to obtain a term of `Sym α n`.
This is a convenience wrapper for `m.append (replicate i a)` that adjusts the term using
`Sym.cast`. | true |
Matrix.toLinearMap₂'Aux._proof_2 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R₁ : Type u_7} {S₁ : Type u_6} {R₂ : Type u_5} {S₂ : Type u_4} {N₂ : Type u_1} {n : Type u_2} {m : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring S₁] [inst_2 : Semiring R₂] [inst_3 : Semiring S₂] [inst_4 : AddCommMonoid N₂]
[inst_5 : Module S₁ N₂] [inst_6 : Module S₂ N₂] [SMulCommClass S₂ S₁ N₂] [inst_8 : Fin... | null | false |
FreeLieAlgebra.Rel.lie_self | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] (a : FreeNonUnitalNonAssocAlgebra R X), FreeLieAlgebra.Rel R X (a * a) 0 | null | true |
DirectLimit.instSemifieldOfRingHomClass._proof_3 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
CochainComplex.mappingCone.map.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁)
(φ₂ : K₂ ⟶ L₂) (a a_1 : K₁ ⟶ K₂) (e_a : a = a_1) (b b_1 : L₁ ⟶ L₂) (e_b : b = b_1)
(comm : CategoryTheory.... | null | true |
iteratedFDerivWithin_eq_iteratedFDeriv | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : 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 : ℕ},
UniqueDiffOn 𝕜 s → ContDiffAt 𝕜 (↑n) f x → x ∈ s → iteratedFDerivWithin... | null | true |
Algebra.IsStandardSmooth.mk | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(∃ ι σ, ∃ (x : Finite σ), Finite ι ∧ Nonempty (Algebra.SubmersivePresentation R S ι σ)) → Algebra.IsStandardSmooth R S | null | true |
Std.Http.Protocol.H1.Direction.swap | Std.Http.Protocol.H1.Message | Std.Http.Protocol.H1.Direction → Std.Http.Protocol.H1.Direction | Inverts the message direction.
| true |
CategoryTheory.shrinkYonedaEquiv_shrinkYoneda_map | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.shrinkYonedaEquiv (CategoryTheory.shrinkYoneda.{w, v, u}.map f) =
CategoryTheory.shrinkYonedaObjObjEquiv.symm f | null | true |
skyscraperPresheafCoconeOfSpecializes | Mathlib.Topology.Sheaves.Skyscraper | {X : TopCat} →
(p₀ : ↑X) →
[inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] →
{C : Type v} →
[inst_1 : CategoryTheory.Category.{u, v} C] →
(A : C) →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
{y : ↑X} →
p₀ ⤳ y →
... | The cocone at `A` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∈ closure {p₀}`
| true |
CategoryTheory.instInhabitedFreeMonoidalCategory.default | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} → CategoryTheory.FreeMonoidalCategory C | null | true |
TestFunction.instZero._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞}, ContDiff ℝ ↑n fun x => 0 | null | false |
CompactlySupportedContinuousMap.toReal_apply | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} [inst : TopologicalSpace α] (f : CompactlySupportedContinuousMap α NNReal) (x : α), f.toReal x = ↑(f x) | null | true |
Aesop.mvarIdToSubgoal | Aesop.RuleTac.Basic | Lean.MVarId → Lean.MVarId → Aesop.BaseM Aesop.Subgoal | null | true |
OpenNormalAddSubgroup.instSetLike | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → SetLike (OpenNormalAddSubgroup G) G | null | true |
Std.HashMap.Raw.Equiv.of_forall_getKey?_unit_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {m₁ m₂ : Std.HashMap.Raw α Unit},
m₁.WF → m₂.WF → (∀ (k : α), m₁.getKey? k = m₂.getKey? k) → m₁.Equiv m₂ | null | true |
ContinuousAlternatingMap.toContinuousMultilinearMap_zero | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N], ContinuousAlternatingMap.toContinuousMultilinearMap 0 = 0 | null | true |
IsFreeAddGroup.mk._flat_ctor | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | ∀ {G : Type u} [inst : AddGroup G], (∃ ι, Nonempty (FreeAddGroupBasis ι G)) → IsFreeAddGroup G | null | false |
ArchimedeanClass.FiniteResidueField.instArchimedean | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
Archimedean (ArchimedeanClass.FiniteResidueField K) | null | true |
Interval.instPreorder._proof_4 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Preorder α] (a b c : Interval α), a ≤ b → b ≤ c → a ≤ c | null | false |
SimplexCategory.δ₀Iter_apply | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (i : ℕ) {n m : ℕ} (j : Fin (n + 1)) (hi : autoParam (n + i = m) SimplexCategory.δ₀Iter_apply._auto_1),
(CategoryTheory.ConcreteCategory.hom (SimplexCategory.δ₀Iter i hi)) j = ⟨↑j + i, ⋯⟩ | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeContext.lctx | Lean.Elab.MutualInductive | Lean.Elab.Command.FinalizeContext✝ → Lean.LocalContext | null | true |
FirstOrder.Language.Theory.Model.realize_of_mem | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} {inst : L.Structure M} {T : L.Theory} [self : M ⊨ T], ∀ φ ∈ T, M ⊨ φ | null | true |
and_imp._simp_1 | Init.SimpLemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
_private.Lean.Meta.DecLevel.0.Lean.Meta.decAux?.match_8 | Lean.Meta.DecLevel | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((a : Lean.Name) → motive (Lean.Level.param a)) →
((mvarId : Lean.LMVarId) → motive (Lean.Level.mvar mvarId)) →
((u : Lean.Level) → motive u.succ) → ((u : Lean.Level) → motive u) → motive x | null | false |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.sizeOf_spec | Lean.DocString.Extension | ∀ (content : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(priorParts : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)) (titleString : String)
(title : Array (Lean.Doc.Inline Lean.ElabInline)),
sizeOf { content := content, priorParts := priorParts, titleString := titleString, title := title ... | null | true |
Std.TreeMap.Raw.modify | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α → (β → β) → Std.TreeMap.Raw α β cmp | Modifies in place the value associated with a given key.
This function ensures that the value is used linearly.
| true |
AlgebraicGeometry.Scheme.AffineZariskiSite.mem_grothendieckTopology | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} {U : X.AffineZariskiSite} {S : CategoryTheory.Sieve U},
S ∈ (AlgebraicGeometry.Scheme.AffineZariskiSite.grothendieckTopology X) U ↔
∀ x ∈ U.toOpens, ∃ V f, S.arrows f ∧ x ∈ V.toOpens | null | true |
List.isPrefixOfAux_toArray_succ' | Init.Data.List.ToArray | ∀ {α : Type u_1} [inst : BEq α] (l₁ l₂ : List α) (hle : l₁.length ≤ l₂.length) (i : ℕ),
l₁.toArray.isPrefixOfAux l₂.toArray hle (i + 1) =
(List.drop (i + 1) l₁).toArray.isPrefixOfAux (List.drop (i + 1) l₂).toArray ⋯ 0 | null | true |
AdjoinRoot.coe_ofAlgHom | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommSemiring S] [inst_2 : Algebra S R] (p : Polynomial R),
⇑(AdjoinRoot.ofAlgHom S p) = ⇑(AdjoinRoot.of p) | null | true |
ProofWidgets.HtmlDisplayProps.mk.sizeOf_spec | ProofWidgets.Component.HtmlDisplay | ∀ (html : ProofWidgets.Html), sizeOf { html := html } = 1 + sizeOf html | null | true |
RelEmbedding.swapEquiv_symm_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : Function.swap r ↪r Function.swap s),
RelEmbedding.swapEquiv.symm f = f.swap | null | true |
MeasureTheory.Filtration.IsRightContinuous.RC | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} {inst : PartialOrder ι} {𝓕 : MeasureTheory.Filtration ι m}
[self : 𝓕.IsRightContinuous], 𝓕.rightCont ≤ 𝓕 | The right continuity property. | true |
LinearEquiv.domMulActCongrRight._proof_5 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_4} {R₁' : Type u_5} {R₂' : Type u_6} {M₁ : Type u_2} {M₁' : Type u_1} {M₂' : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁' M₁']
[inst_8... | null | false |
AddMagma.FreeAddSemigroup.map.eq_1 | Mathlib.Algebra.Free | ∀ {α : Type u} [inst : Add α] {β : Type v} [inst_1 : Add β] (f : α →ₙ+ β),
AddMagma.FreeAddSemigroup.map f = AddMagma.FreeAddSemigroup.lift (AddMagma.FreeAddSemigroup.of.comp f) | null | true |
AntitoneOn.map_bddBelow | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
AntitoneOn f t → s ⊆ t → (lowerBounds s ∩ t).Nonempty → BddAbove (f '' s) | The image under an antitone function of a set which is bounded below is bounded
above. | true |
Lean.Grind.Linarith.Poly.NonnegCoeffs.add | Init.Grind.Module.NatModuleNorm | ∀ (a : ℤ) (x : Lean.Grind.Linarith.Var) (p : Lean.Grind.Linarith.Poly),
a ≥ 0 → p.NonnegCoeffs → (Lean.Grind.Linarith.Poly.add a x p).NonnegCoeffs | null | true |
Function.Surjective.mulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
{A' : Type u_8} →
[inst : MonoidWithZero M₀] →
[inst_1 : Zero A] →
[inst_2 : MulActionWithZero M₀ A] →
[inst_3 : Zero A'] →
[inst_4 : SMul M₀ A'] →
(f : ZeroHom A A') →
Function.Surjective ⇑f → (... | Pushforward a `MulActionWithZero` structure along a surjective zero-preserving homomorphism. | true |
SSetPair.homology_exact₃._auto_1 | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Relative | Lean.Syntax | null | false |
Finsupp.split_apply | Mathlib.Data.Finsupp.Basic | ∀ {ι : Type u_4} {M : Type u_5} {αs : ι → Type u_12} [inst : Zero M] (l : (i : ι) × αs i →₀ M) (i : ι) (x : αs i),
(l.split i) x = l ⟨i, x⟩ | null | true |
Ideal.associatesEquivIsPrincipal._proof_3 | Mathlib.RingTheory.Ideal.IsPrincipal | ∀ (R : Type u_1) [inst : CommRing R] (I : { I // Submodule.IsPrincipal I }), Submodule.IsPrincipal ↑I | null | false |
LipschitzWith.mapsTo_closedBall | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ (x : α) (r : ℝ), Set.MapsTo f (Metric.closedBall x r) (Metric.closedBall (f x) (↑K * r)) | null | true |
Nat.Coprime.sum_divisors_mul | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {m n : ℕ}, m.Coprime n → ∑ d ∈ (m * n).divisors, d = (∑ d ∈ m.divisors, d) * ∑ d ∈ n.divisors, d | null | true |
Real.isTheta_exp_comp_exp_comp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} {l : Filter α} {f g : α → ℝ},
((fun x => Real.exp (f x)) =Θ[l] fun x => Real.exp (g x)) ↔
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l fun x => |f x - g x| | null | true |
Std.ExtDTreeMap.union_insert_right_eq_insert_union | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{p : (a : α) × β a}, t₁ ∪ t₂.insert p.fst p.snd = (t₁ ∪ t₂).insert p.fst p.snd | null | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁.instMonoHomologyMapIntι._proof_2 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (n₁ : ℤ), n₁ - 1 = n₁ - 1 | null | false |
Vector.insertIdx_eraseIdx._proof_3 | Init.Data.Vector.InsertIdx | ∀ {n i : ℕ}, i < n → i + 1 < n + 1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.