name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
fderiv_cos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E},
DifferentiableAt ℝ f x → fderiv ℝ (fun x => Real.cos (f x)) x = -Real.sin (f x) • fderiv ℝ f x | null | true |
MonadWriterAdapter.mk._flat_ctor | Mathlib.Control.Monad.Writer | {ω : outParam (Type u)} → {m : Type u → Type v} → ({α : Type u} → (ω → ω) → m α → m α) → MonadWriterAdapter ω m | null | false |
dirichletSummandHom._proof_1 | Mathlib.NumberTheory.EulerProduct.DirichletLSeries | ∀ {s : ℂ} {n : ℕ} (χ : DirichletCharacter ℂ n), s ≠ 0 → χ ↑0 * ↑0 ^ (-s) = 0 | null | false |
_private.Mathlib.Analysis.CStarAlgebra.Basic.0.«term_⋆» | Mathlib.Analysis.CStarAlgebra.Basic | Lean.TrailingParserDescr | null | true |
CategoryTheory.BraidedCategory.Hexagon.functor₂₃₁'_map_app_app | Mathlib.CategoryTheory.Monoidal.Braided.Multifunctor | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(h : X ⟶ Y) (X_1 Y_1 : C),
(((CategoryTheory.BraidedCategory.Hexagon.functor₂₃₁' C).map h).app X_1).app Y_1 =
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X_1 (CategoryTheory.MonoidalCatego... | null | true |
Down.erase_mem_compression | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α},
s ∈ 𝒜 → s.erase a ∈ Down.compression a 𝒜 | null | true |
CategoryTheory.Limits.WeightedCone.IsLimit.fac_assoc | Mathlib.CategoryTheory.Limits.Weighted.HasWeightedLimit | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{W : CategoryTheory.Functor J (Type w)} {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.WeightedCone W F}
(hc : c.IsLimit) {Z : C} (π : ⦃j : J⦄ → W.obj j → (Z ⟶ F.obj j))
(hπ :
∀ ⦃j... | null | true |
StructureGroupoid.subset_maximalAtlas | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(G : StructureGroupoid H) [HasGroupoid M G], atlas H M ⊆ StructureGroupoid.maximalAtlas M G | The elements of the atlas belong to the maximal atlas for any structure groupoid. | true |
continuousOn_finsetSum | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M]
[inst_2 : AddCommMonoid M] [ContinuousAdd M] {f : ι → X → M} (s : Finset ι) {t : Set X},
(∀ i ∈ s, ContinuousOn (f i) t) → ContinuousOn (fun a => ∑ i ∈ s, f i a) t | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isEmpty_eq_false_iff_exists_containsKey._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [ReflBEq α] {l : List ((a : α) × β a)},
(l.isEmpty = false) = ∃ a, (Std.Internal.List.getEntry? a l).isSome = true | null | false |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.mkIte.match_1 | Lean.Elab.Do.Legacy | (motive : Lean.Elab.Term.Do.CodeBlock × Lean.Elab.Term.Do.CodeBlock → Sort u_1) →
(x : Lean.Elab.Term.Do.CodeBlock × Lean.Elab.Term.Do.CodeBlock) →
((thenBranch elseBranch : Lean.Elab.Term.Do.CodeBlock) → motive (thenBranch, elseBranch)) → motive x | null | false |
ContinuousLinearEquiv.arrowCongrEquivₛₗ._proof_4 | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_5} {R₂ : Type u_7} {R₃ : Type u_8} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_1}
... | null | false |
Std.TreeMap.unitOfArray._auto_1 | Std.Data.TreeMap.Basic | Lean.Syntax | null | false |
SubMulAction.instCompleteLattice._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_2} {M : Type u_1} [inst : SMul R M], Function.Injective SetLike.coe | null | false |
CategoryTheory.Functor.flip₁₃._proof_12 | Mathlib.CategoryTheory.Functor.CurryingThree | ∀ {C₁ : Type u_2} {C₂ : Type u_6} {C₃ : Type u_8} {E : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_5, u_6} C₂] [inst_2 : CategoryTheory.Category.{u_7, u_8} C₃]
[inst_3 : CategoryTheory.Category.{u_3, u_4} E]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C... | null | false |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.isProbabilityMeasure_tilted._simp_1_2 | Mathlib.MeasureTheory.Measure.Tilted | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
_private.Mathlib.LinearAlgebra.AffineSpace.Homogenization.0.Homogenization.congr_eq_refl_iff._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.Homogenization | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {modM : Module R M} {modM₂ : Module S M₂} {σ : R →+* S}
{σ' : S →+* R} [inst_4 : RingHomInvPair σ σ'] [inst_5 : RingHomInvPair σ' σ] {e₁ e₂ : M ≃ₛₗ[σ] M₂},
... | null | false |
Subfield.topEquiv | Mathlib.Algebra.Field.Subfield.Basic | {K : Type u} → [inst : DivisionRing K] → ↥⊤ ≃+* K | The ring equiv between the top element of `Subfield K` and `K`. | true |
Group.ofLeftAxioms._proof_6 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Mul G] [inst_1 : Inv G] [inst_2 : One G] (n : ℕ) (a : G), a ^ ↑n.succ = a ^ ↑n * a | null | false |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual.eq_def | Lean.Compiler.NameMangling | ∀ (s : String)
(x :
(_ : s.Pos) ×' (_ : Lean.Name) ×' ℕ ⊕'
(_ : s.Pos) ×' Lean.Name ⊕' (_ : s.Pos) ×' (_ : Lean.Name) ×' (_ : String) ×' ℕ),
Lean.Name.demangleAux.decodeNum._mutual✝ s x =
PSum.casesOn x
(fun _x =>
PSigma.casesOn _x fun p res =>
PSigma.casesOn res fun res n =>
... | null | false |
IsDedekindDomain.instCommRingFiniteAdeleRing._proof_10 | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K],
autoParam (∀ (x : IsDedekindDomain.FiniteAdeleRing R K), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
Runtime.markPersistent | Init.System.IO | {α : Type} → α → BaseIO α | Marks given value and its object graph closure as persistent. This will remove
reference counter updates but prevent the closure from being deallocated until
the end of the process! It can still be useful to do eagerly when the value
will be marked persistent later anyway and there is available time budget to
mark it n... | true |
Array.foldr_pmap | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {xs : Array α} {P : α → Prop} {f : (a : α) → P a → β} (H : ∀ a ∈ xs, P a)
(g : β → γ → γ) (x : γ), Array.foldr g x (Array.pmap f xs H) = Array.foldr (fun a acc => g (f ↑a ⋯) acc) x xs.attach | null | true |
Complex.imAddGroupHom | Mathlib.Basic.Complex.Basic | ℂ →+ ℝ | The "imaginary part" map, considered as an additive group homomorphism. | true |
HolderWith.smul | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoMetricSpace X] [inst_1 : SeminormedAddCommGroup Y] {C r : NNReal}
{f : X → Y} {α : Type u_4} [inst_2 : SeminormedAddCommGroup α] [inst_3 : SMulZeroClass α Y] [IsBoundedSMul α Y]
(a : α), HolderWith C r f → HolderWith (C * ‖a‖₊) r (a • f) | null | true |
AddGroupExtension.IsAddConj.eq_1 | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup E] [inst_2 : AddGroup G]
(S : AddGroupExtension N E G) (s s' : S.Splitting), S.IsAddConj s s' = ∃ n, ⇑s = fun g => S.inl n + s' g + -S.inl n | null | true |
CategoryTheory.SimplicialObject.whiskering_obj_obj_δ | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(F : CategoryTheory.Functor C D) (X : CategoryTheory.SimplicialObject C) {n : ℕ} (i : Fin (n + 2)),
CategoryTheory.SimplicialObject.δ (CategoryTheory.Functor.comp X F) i = F.map (X.δ i) | null | true |
lowerHemicontinuousAt_iff_frequently | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → Set β} {x : α},
LowerHemicontinuousAt f x ↔ ∀ (t : Set β), IsClosed t → (∃ᶠ (x' : α) in nhds x, f x' ⊆ t) → f x ⊆ t | null | true |
DividedPowerAlgebra.dp.eq_1 | Mathlib.RingTheory.DividedPowerAlgebra.Init | ∀ (R : Type u_2) {M : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (n : ℕ)
(m : M), DividedPowerAlgebra.dp R n m = ↑(MvPolynomial.X (n, m)) | null | true |
FiniteArchimedeanClass.submodule._proof_1 | Mathlib.Algebra.Order.Module.Archimedean | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : Module K M] (k : K) {a : M}, ArchimedeanClass.mk a = ⊤ → ArchimedeanClass.mk (k • a) = ⊤ | null | false |
_private.Mathlib.Order.Monotone.MonovaryOrder.0.monovaryOn_iff_exists_antitoneOn._simp_1_2 | Mathlib.Order.Monotone.MonovaryOrder | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : ι → α} {g : ι → β}
{s : Set ι}, AntivaryOn f g s = ∃ x, MonotoneOn f s ∧ AntitoneOn g s | null | false |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.modify_eq_empty_iff._simp_1_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m = ∅) = (m.isEmpty = true) | null | false |
MvPolynomial.eval_C | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {f : σ → R} (a : R), (MvPolynomial.eval f) (MvPolynomial.C a) = a | null | true |
RingInvo.mk'._proof_2 | Mathlib.RingTheory.RingInvo | ∀ {R : Type u_1} [inst : Semiring R] (f : R →+* Rᵐᵒᵖ) (x y : R), (↑↑f).toFun (x * y) = (↑↑f).toFun x * (↑↑f).toFun y | null | false |
Rep.unitIsoAddEquiv.eq_1 | Mathlib.RepresentationTheory.Rep.Iso | ∀ {k : Type u} {G : Type v} [inst : CommRing k] [inst_1 : Monoid G] {V : Rep.{w, u, v} k G},
Rep.unitIsoAddEquiv =
id (V.ρ.asModuleEquiv.symm.toAddEquiv.trans (RestrictScalars.addEquiv k (MonoidAlgebra k G) V.ρ.asModule).symm) | null | true |
Subspace.dualRestrict_comp_dualLift | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] (W : Subspace K V),
Submodule.dualRestrict W ∘ₗ W.dualLift = 1 | null | true |
orderIsoShrink._proof_1 | Mathlib.Order.Shrink | ∀ (α : Type u_2) [inst : Small.{u_1, u_2} α] [inst_1 : Preorder α] {a b : α},
(equivShrink α) a ≤ (equivShrink α) b ↔ a ≤ b | null | false |
_private.Mathlib.Topology.MetricSpace.UniformConvergence.0.UniformFun.lipschitzOnWith_iff._simp_1_1 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {s : Set α}
{f : α → β}, LipschitzOnWith K f s = LipschitzWith K (s.domRestrict f) | null | false |
ContinuousAlgEquiv.continuous | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (e : A ≃A[R] B), Continuous ⇑e | null | true |
AkraBazziRecurrence.sumTransform_def | Mathlib.Computability.AkraBazzi.SumTransform | ∀ {p : ℝ} {g : ℝ → ℝ} {n₀ n : ℕ},
AkraBazziRecurrence.sumTransform p g n₀ n = ↑n ^ p * ∑ u ∈ Finset.Ico n₀ n, g ↑u / ↑u ^ (p + 1) | null | true |
Lean.Meta.Simp.mkEqTransOptProofResult | Lean.Meta.Tactic.Simp.Types | Option Lean.Expr → Bool → Lean.Meta.Simp.Result → Lean.MetaM Lean.Meta.Simp.Result | null | true |
CategoryTheory.Idempotents.Karoubi.Hom.comm._autoParam | Mathlib.CategoryTheory.Idempotents.Karoubi | Lean.Syntax | null | false |
Lean.CollectFVars.State.mk.sizeOf_spec | Lean.Util.CollectFVars | ∀ (visitedExpr : Lean.ExprSet) (fvarSet : Lean.FVarIdSet) (fvarIds : Array Lean.FVarId),
sizeOf { visitedExpr := visitedExpr, fvarSet := fvarSet, fvarIds := fvarIds } =
1 + sizeOf visitedExpr + sizeOf fvarSet + sizeOf fvarIds | null | true |
CompHausLike.LocallyConstant.sigmaIncl | Mathlib.Condensed.Discrete.LocallyConstant | {P : TopCat → Prop} →
[inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
{Q : CompHausLike P} →
{Z : Type (max u w)} →
(r : LocallyConstant (↑Q.toTop) Z) → (a : Function.Fiber ⇑r) → CompHausLike.LocallyConstant.fiber r a ⟶ Q | The inclusion map from a component of the coproduct induced by `f` into `S`. | true |
Std.DHashMap.Raw.Const.getKey?_alter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k k' : α} {f : Option β → Option β},
m.WF →
(Std.DHashMap.Raw.Const.alter m k f).getKey? k' =
if (k == k') = true then if (f (Std.DHashMap.Raw.Const.get? m k)).isS... | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Basic.0.dist_div_norm_sq_smul._simp_1_7 | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
CategoryTheory.isIso_iff_yoneda_map_bijective | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.IsIso f ↔ ∀ (T : C), Function.Bijective fun x => CategoryTheory.CategoryStruct.comp x f | null | true |
Sigma.curry_mul | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {α : Type u_5} {β : α → Type u_6} {γ : (a : α) → β a → Type u_7} [inst : (a : α) → (b : β a) → Mul (γ a b)]
(x y : (i : (a : α) × β a) → γ i.fst i.snd), Sigma.curry (x * y) = Sigma.curry x * Sigma.curry y | null | true |
InverseSystem.PEquivOn.compat | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_6} {F : ι → Type u_7} {X : ι → Type u_8} [inst : LinearOrder ι] {f : ⦃i j : ι⦄ → i ≤ j → F j → F i}
[inst_1 : SuccOrder ι] {equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} {s : Set ι}
(self : InverseSystem.PEquivOn f equivSucc s) {i : ι} (hsi : Order.succ i ∈ s) (hi : ¬IsMax i)
(x : F... | It is compatible with a family of bijections relating `F i⁺` to `F i`. | true |
Filter.tendsto_atTop_finset_of_monotone | Mathlib.Order.Filter.AtTopBot.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder β] {f : β → Finset α},
Monotone f → (∀ (x : α), ∃ n, x ∈ f n) → Filter.Tendsto f Filter.atTop Filter.atTop | If `f` is a monotone sequence of `Finset`s and each `x` belongs to one of `f n`, then
`Tendsto f atTop atTop`. | true |
LocalSubring._sizeOf_inst | Mathlib.RingTheory.LocalRing.LocalSubring | (R : Type u_1) → {inst : CommRing R} → [SizeOf R] → SizeOf (LocalSubring R) | null | false |
AlgebraicGeometry.IsAffineOpen.fromSpecStalk | Mathlib.AlgebraicGeometry.Stalk | {X : AlgebraicGeometry.Scheme} →
{U : X.Opens} →
AlgebraicGeometry.IsAffineOpen U → {x : ↥X} → x ∈ U → (AlgebraicGeometry.Spec (X.presheaf.stalk x) ⟶ X) | A morphism from `Spec(O_x)` to `X`, which is defined with the help of an affine open
neighborhood `U` of `x`.
| true |
Lean.Elab.Term.ElabElim.Context.casesOn | Lean.Elab.App | {motive : Lean.Elab.Term.ElabElim.Context → Sort u} →
(t : Lean.Elab.Term.ElabElim.Context) →
((elimInfo : Lean.Elab.Term.ElabElimInfo) →
(expectedType : Lean.Expr) → motive { elimInfo := elimInfo, expectedType := expectedType }) →
motive t | null | false |
MeasureTheory.Measure.ext_of_Ioc' | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u_5} [inst : TopologicalSpace α] {m : MeasurableSpace α} [SecondCountableTopology α]
[inst_2 : LinearOrder α] [OrderTopology α] [BorelSpace α] [NoMinOrder α] (μ ν : MeasureTheory.Measure α),
(∀ ⦃a b : α⦄, a < b → μ (Set.Ioc a b) ≠ ⊤) → (∀ ⦃a b : α⦄, a < b → μ (Set.Ioc a b) = ν (Set.Ioc a b)) → μ = ν | Two measures which are finite on closed-open intervals are equal if they agree on all
open-closed intervals. | true |
ULift.module._proof_3 | Mathlib.Algebra.Module.ULift | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : ULift.{u_1, u_2} R), a • 0 = 0 | null | false |
Lean.Elab.Command.State.infoState._default | Lean.Elab.Command | Lean.Elab.InfoState | null | false |
Mathlib.Tactic.BicategoryLike.Atom.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {P : Sort u} →
{t t' : Mathlib.Tactic.BicategoryLike.Atom} → t = t' → Mathlib.Tactic.BicategoryLike.Atom.noConfusionType P t t' | null | false |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.NatIso.cancel_natIso_inv_left._simp_1_2 | Mathlib.CategoryTheory.NatIso | ∀ {α : Sort u_1} {r : α → α → Prop} [Std.Refl r] (a : α), r a a = True | null | false |
DirectLimit.instDivisionSemiring._proof_18 | 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 |
_private.Mathlib.Geometry.Manifold.Riemannian.PathELength.0.Manifold.lintegral_norm_mfderiv_Icc_eq_pathELength_projIcc._simp_1_1 | Mathlib.Geometry.Manifold.Riemannian.PathELength | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {x y : ℝ}
[h : Fact (x < y)] {f : ↑(Set.Icc x y) → M} {w : ↑(Set.Icc x y)},
(mfderiv% f w) 1 ... | null | false |
Filter.HasBasis.uniformity_closeds | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] {ι : Sort u_4} {p : ι → Prop} {s : ι → Set (α × α)},
(uniformity α).HasBasis p s →
(uniformity (TopologicalSpace.Closeds α)).HasBasis p fun i =>
Prod.map SetLike.coe SetLike.coe ⁻¹' hausdorffEntourage (s i) | null | true |
NumberField.mixedEmbedding.fundamentalCone.expMap_single | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | {K : Type u_1} → [inst : Field K] → NumberField.InfinitePlace K → OpenPartialHomeomorph ℝ ℝ | The component of `expMap` at the place `w`.
| true |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.counitIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(F : CategoryTheory.AddMon C),
CategoryTheory.CategoryStruct.comp CategoryTheory.AddMonObj.zero
(CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.counitIsoAux C F).hom =
CategoryTheory.AddMonObj.z... | null | false |
SupHom.coe_top | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Max α] [inst_1 : SemilatticeSup β] [inst_2 : Top β], ⇑⊤ = ⊤ | null | true |
Valued.hasBasis_uniformity | Mathlib.Topology.Algebra.Valued.ValuationTopology | ∀ (R : Type u) [inst : Ring R] (Γ₀ : Type v) [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [_i : Valued R Γ₀],
(uniformity R).HasBasis (fun x => True) fun γ => {p | Valued.v.restrict (p.2 - p.1) < ↑γ} | null | true |
_private.Mathlib.Tactic.NormNum.Result.0.Mathlib.Meta.NormNum.IsNat.to_isInt.match_1_1 | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : Ring α] (motive : (x : α) → (x_1 : ℕ) → Mathlib.Meta.NormNum.IsNat x x_1 → Prop) (x : α)
(x_1 : ℕ) (x_2 : Mathlib.Meta.NormNum.IsNat x x_1), (∀ (n : ℕ), motive (↑n) n ⋯) → motive x x_1 x_2 | null | false |
HomotopicalAlgebra.CofibrantObject.instIsFibrantResolutionObj | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] (X : C)
[HomotopicalAlgebra.IsFibrant X],
HomotopicalAlgebra.IsFibrant (HomotopicalAlgebra.CofibrantObject.HoCat.resolutionObj X) | null | true |
Encodable.decodeSigma.match_1 | Mathlib.Logic.Encodable.Basic | (motive : ℕ × ℕ → Sort u_1) → (x : ℕ × ℕ) → ((n₁ n₂ : ℕ) → motive (n₁, n₂)) → motive x | null | false |
_private.Mathlib.Data.Rat.Lemmas.0.Rat.add_den_dvd_lcm._simp_1_1 | Mathlib.Data.Rat.Lemmas | ∀ {n : ℕ}, (0 < n) = (n ≠ 0) | null | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.monoidalOppositeLeftAction_actionAssocIso_mop_mop | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (c c' : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct... | null | true |
_private.Mathlib.Data.PFun.0.PFun.preimage_asSubtype._simp_1_1 | Mathlib.Data.PFun | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.processAtom | Lean.Elab.Syntax | Lean.Syntax → Lean.Elab.Term.ToParserDescrM (Lean.Term × ℕ) | null | true |
MeasureTheory.Lp.dense_hasCompactSupport_contDiff | Mathlib.Analysis.Normed.Lp.SmoothApprox | ∀ {E : Type u_3} {F : Type u_4} [inst : MeasurableSpace E] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace ℝ E] [FiniteDimensional ℝ E] [BorelSpace E]
[inst_6 : NormedSpace ℝ F] {μ : MeasureTheory.Measure E} [MeasureTheory.IsFiniteMeasureOnCompacts μ] {p : ENNReal},
p ≠ ⊤ → ∀... | null | true |
BitVec.msb_eq_true_iff_two_mul_ge | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x.msb = true ↔ 2 * x.toNat ≥ 2 ^ w | null | true |
Multiset.revzip_powersetAux_perm | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Perm l₂ → (Multiset.powersetAux l₁).revzip.Perm (Multiset.powersetAux l₂).revzip | null | true |
FinEnum.Quotient.enum | Mathlib.Data.FinEnum | {α : Type u} → [FinEnum α] → (s : Setoid α) → [DecidableRel fun x1 x2 => x1 ≈ x2] → FinEnum (Quotient s) | null | true |
PrimeSpectrum.subset_vanishingIdeal_zeroLocus | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ {R : Type u} [inst : CommSemiring R] (s : Set R), s ⊆ ↑(PrimeSpectrum.vanishingIdeal (PrimeSpectrum.zeroLocus s)) | null | true |
CategoryTheory.braiding_rightUnitor | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C),
CategoryTheory.CategoryStruct.comp (β_ (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) X).hom
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X)... | null | true |
OreLocalization.instCommRing | Mathlib.RingTheory.OreLocalization.Ring | {R : Type u_1} →
[inst : CommRing R] → {S : Submonoid R} → [inst_1 : OreLocalization.OreSet S] → CommRing (OreLocalization S R) | null | true |
Polynomial.SplittingFieldAux.algebra | Mathlib.FieldTheory.SplittingField.Construction | (n : ℕ) → {K : Type u} → [inst : Field K] → (f : Polynomial K) → Algebra K (Polynomial.SplittingFieldAux n f) | null | true |
Lean.getMaxHeartbeats | Lean.Util.Heartbeats | Lean.CoreM ℕ | Returns the current `maxHeartbeats`. | true |
AlgebraicGeometry.PresheafedSpace.id_base | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : AlgebraicGeometry.PresheafedSpace C),
(CategoryTheory.CategoryStruct.id X).base = CategoryTheory.CategoryStruct.id ↑X | null | true |
RingHom.IsIntegralElem.of_mul_unit | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) (x y : S) (r : R),
f r * y = 1 → f.IsIntegralElem (x * y) → f.IsIntegralElem x | null | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds.0.HurwitzKernelBounds.exp_lt_aux | Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds | ∀ {t : ℝ}, 0 < t → Real.exp (-Real.pi * t) < 1 | null | true |
Lean.Json.Parser.num | Lean.Data.Json.Parser | Std.Internal.Parsec.String.Parser Lean.JsonNumber | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKeyD_eq_fallback._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 |
Part.mod_def | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : Mod α] (a b : Part α),
a % b = do
let y ← a
Part.map (fun x => y % x) b | null | true |
CategoryTheory.StrictlyUnitaryPseudofunctor.mk'._proof_1 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictlyUnitaryPseudofunctorCore B C) {a b c : B} (f : a ⟶ b) (x x_1 : b ⟶ c) (η : x ⟶ x_1),
S.map₂ (CategoryTheory.Bicategory.whiskerLeft f η) =
CategoryTheory.CategoryStruct.comp (S.... | null | false |
Mathlib.Notation3.Matcher | Mathlib.Util.Notation3 | Type | A matcher is a delaboration function that transforms `MatchState`s. | true |
_private.Std.Sat.AIG.RefVecOperator.Map.0.Std.Sat.AIG.RefVec.map.go_get_aux._simp_1_2 | Std.Sat.AIG.RefVecOperator.Map | ∀ (n : ℕ), (n ≤ n) = True | null | false |
Aesop.AddRapp.mk.inj | Aesop.Tree.AddRapp | ∀ {toRuleApplication : Aesop.RuleApplication} {parent : Aesop.GoalRef} {appliedRule : Aesop.RegularRule}
{successProbability : Aesop.Percent} {toRuleApplication_1 : Aesop.RuleApplication} {parent_1 : Aesop.GoalRef}
{appliedRule_1 : Aesop.RegularRule} {successProbability_1 : Aesop.Percent},
{ toRuleApplication := ... | null | true |
antivary_inv_left₀._simp_1 | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Semifield α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : LinearOrder β] {f : ι → α} {g : ι → β}, StrongLT 0 f → Antivary f⁻¹ g = Monovary f g | null | false |
_private.Init.Core.0.beq_of_eq.match_1_1 | Init.Core | ∀ {α : Type u_1} {a : α} (motive : (b : α) → a = b → Prop) (b : α) (x : a = b), (∀ (_ : Unit), motive a ⋯) → motive b x | null | false |
LinearMap.rTensor_id_apply | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) (N : Type u_5) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (x : TensorProduct R N M),
(LinearMap.rTensor M LinearMap.id) x = x | null | true |
CategoryTheory.Limits.coconeLeftOpOfConeEquiv._proof_3 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {F : CategoryTheory.Functor J Cᵒᵖ}
(X : CategoryTheory.Limits.Cocone F.leftOp),
Opposite.op { hom := (CategoryTheory.CategoryStruct.id X).hom.op, w := ⋯ } =
CategoryTheory.CategoryStru... | null | false |
ApproximatesLinearOn.mono_num | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : 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}
{f' : E →L[𝕜] F} {s : Set E} {c c' : NNReal}, c ≤ c' → ApproximatesLinearOn f f' s c → Approximates... | null | true |
Tree.numNodes | Mathlib.Data.Tree.Basic | {α : Type u_1} → Tree α → ℕ | **Alias** of `BinaryTree.numNodes`. | true |
RelLowerSet.casesOn | Mathlib.Order.Defs.Unbundled | {α : Type u_1} →
[inst : LE α] →
{P : α → Prop} →
{motive : RelLowerSet P → Sort u} →
(t : RelLowerSet P) →
((carrier : Set α) →
(isRelLowerSet' : IsRelLowerSet carrier P) →
motive { carrier := carrier, isRelLowerSet' := isRelLowerSet' }) →
motive ... | null | false |
Lean.IR.LitVal._sizeOf_inst | Lean.Compiler.IR.Basic | SizeOf Lean.IR.LitVal | null | false |
sigmaAntidiagonalEquivProd.eq_1 | Mathlib.NumberTheory.TsumDivisorsAntidiagonal | sigmaAntidiagonalEquivProd =
{ toFun := fun x => divisorsAntidiagonalFactors x.fst x.snd, invFun := fun x => ⟨⟨↑x.1 * ↑x.2, ⋯⟩, ⟨(↑x.1, ↑x.2), ⋯⟩⟩,
left_inv := sigmaAntidiagonalEquivProd._proof_4, right_inv := sigmaAntidiagonalEquivProd._proof_3 } | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.