name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Elab.TacticInfo.goalsBefore | Lean.Elab.InfoTree.Types | Lean.Elab.TacticInfo → List Lean.MVarId | null | true |
Localization.exists_awayMap_bijective_of_localRingHom_bijective | Mathlib.RingTheory.Unramified.LocalRing | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal R}
[inst_3 : p.IsPrime] {q : Ideal S} [inst_4 : q.IsPrime],
p.primesOver S = {q} →
∀ [Module.Finite R S] [inst_6 : q.LiesOver p],
(RingHom.ker (algebraMap R S)).FG →
Function.Bijective ⇑(Loc... | null | true |
RingOfIntegers.exponent | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | {K : Type u_1} → [inst : Field K] → NumberField.RingOfIntegers K → ℕ | The smallest positive integer `d` contained in the conductor of `θ`. It is the smallest integer
such that `d • 𝓞 K ⊆ ℤ[θ]`, see `exponent_eq_sInf`. It is set to `0` if `d` does not exists.
| true |
CategoryTheory.CommMon.toMon | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommMon C → CategoryTheory.Mon C | A commutative monoid object is a monoid object. | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.State.mk.noConfusion | Std.Sync.Channel | {α : Type} →
{P : Sort u} →
{values : Std.Queue α} →
{consumers : Std.Queue (Std.CloseableChannel.Consumer✝ α)} →
{closed : Bool} →
{values' : Std.Queue α} →
{consumers' : Std.Queue (Std.CloseableChannel.Consumer✝ α)} →
{closed' : Bool} →
{ values ... | null | false |
CategoryTheory.MorphismProperty.comp_mem | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
[W.IsStableUnderComposition] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
W f → W g → W (CategoryTheory.CategoryStruct.comp f g) | null | true |
ContMDiff.piecewise | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSp... | Given two `C^n` functions `f` and `g` which coincide locally around the frontier of a set `s`,
then the piecewise function defined using `f` on `s` and `g` elsewhere is `C^n`. | true |
FirstOrder.Language.mk.injEq | Mathlib.ModelTheory.Basic | ∀ (Functions : ℕ → Type u) (Relations : ℕ → Type v) (Functions_1 : ℕ → Type u) (Relations_1 : ℕ → Type v),
({ Functions := Functions, Relations := Relations } = { Functions := Functions_1, Relations := Relations_1 }) =
(Functions = Functions_1 ∧ Relations = Relations_1) | null | true |
linearOrderOfCompares._proof_8 | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : Preorder α] (cmp : α → α → Ordering),
(∀ (a b : α), (cmp a b).Compares a b) → ∀ (a b : α), a ≤ b ∨ b ≤ a | null | false |
_private.Mathlib.GroupTheory.Goursat.0.Subgroup.mk_goursatFst_eq_iff_mk_goursatSnd_eq._simp_1_1 | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} [inst : Group G] {N : Subgroup G} [nN : N.Normal] {x y : G}, (↑x = ↑y) = (x / y ∈ N) | null | false |
Mathlib.Tactic.Linarith.LinarithConfig.splitHypotheses._default | Mathlib.Tactic.Linarith.Frontend | Bool | null | false |
ZMod.χ₈' | Mathlib.NumberTheory.LegendreSymbol.ZModChar | MulChar (ZMod 8) ℤ | Define the second primitive quadratic character on `ZMod 8`, `χ₈'`.
It corresponds to the extension `ℚ(√-2)/ℚ`. | true |
Lean.Lsp.SignatureInformation._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureInformation → ℕ | null | false |
TopologicalAddGroup.IsSES.pushforward_def | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {E : Type u_4} [inst : AddGroup A] [inst_1 : AddGroup B]
[inst_2 : AddGroup C] [inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C]
{φ : A →+ B} {ψ : B →+ C} (H : TopologicalAddGroup.IsSES φ ψ) [inst_6 : IsTopologicalAddGroup A]
[... | null | true |
NonUnitalCommRing.toNonUnitalCommSemiring._proof_2 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [s : NonUnitalCommRing α] (a b c : α), a * (b + c) = a * b + a * c | null | false |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Frontend.0.Lean.Elab.Tactic.Do.Internal.runTacticM | Lean.Elab.Tactic.Do.Internal.VCGen.Frontend | {α : Type} → Lean.Elab.Tactic.TacticM α → optParam (List Lean.MVarId) [] → Lean.Elab.TermElabM α | A local helper for running config elaborators in TermElabM. | true |
Lean.removeRoot | Lean.Data.OpenDecl | Lean.Name → Lean.Name | null | true |
Std.Http.Status.multiStatus.elim | Std.Http.Data.Status | {motive : Std.Http.Status → Sort u} →
(t : Std.Http.Status) → t.ctorIdx = 11 → motive Std.Http.Status.multiStatus → motive t | null | false |
_private.Mathlib.Topology.Order.0.continuous_sInf_rng._simp_1_1 | Mathlib.Topology.Order | ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β},
Continuous f = (TopologicalSpace.coinduced f t₁ ≤ t₂) | null | false |
Std.Http.Status.ofCode | Std.Http.Data.Status | Option { x // Std.Http.IsValidReasonPhrase x } → UInt16 → Option Std.Http.Status | Converts a `UInt16` to `Status`.
| true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.Const.alter.match_1.eq_1 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | null | true |
ModularForm.mul._proof_2 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k_1 k_2 : ℤ} [inst : Γ.HasDetPlusMinusOne] (f : ModularForm Γ k_1)
(g : ModularForm Γ k_2) {c : OnePoint ℝ},
IsCusp c Γ →
∀ (γ : GL (Fin 2) ℝ),
γ • OnePoint.infty = c →
UpperHalfPlane.IsBoundedAtImInfty (SlashAction.map (k_1 + k_2) γ (f.mul g.toSlashInvariantForm).... | null | false |
Real.sin_pi_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.sin (Real.pi - x) = Real.sin x | null | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._proof_15 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ),
autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1 → k + 1 + 2 < n + 3 + 1 | null | false |
OrderType.card_monotone | Mathlib.Order.Types.Arithmetic | Monotone OrderType.card | null | true |
CategoryTheory.inclusion | Mathlib.CategoryTheory.ConnectedComponents | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
(j : CategoryTheory.ConnectedComponents J) → CategoryTheory.Functor j.Component (CategoryTheory.Decomposed J) | The inclusion of each component into the decomposed category. This is just `sigma.incl` but having
this abbreviation helps guide typeclass search to get the right category instance on `decomposed J`.
| true |
ContDiffMapSupportedInClass.casesOn | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {B : Type u_5} →
{E : Type u_6} →
{F : Type u_7} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace ℝ E] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
{motive ... | null | false |
Lean.Meta.Cache._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.Cache → ℕ | null | false |
_private.Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary.0.DifferentiableAt.mem_interior_convex_of_surjective_fderiv.match_1_1 | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {E : Type u_2} {H : Type u_1} [inst : NormedAddCommGroup H] [inst_1 : NormedSpace ℝ H] {f : E → H} {x : E} {s : Set H}
(motive : (∃ f_1, ∀ a ∈ interior s, f_1 a < f_1 (f x)) → Prop) (x_1 : ∃ f_1, ∀ a ∈ interior s, f_1 a < f_1 (f x)),
(∀ (F : StrongDual ℝ H) (hF : ∀ a ∈ interior s, F a < F (f x)), motive ⋯) → moti... | null | false |
RingQuot.instSemiring | Mathlib.Algebra.RingQuot | {R : Type uR} → [inst : Semiring R] → (r : R → R → Prop) → Semiring (RingQuot r) | null | true |
IsLocalization.Away.commutes | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_5} [inst : CommSemiring R] (S₁ : Type u_6) (S₂ : Type u_7) (T : Type u_8) [inst_1 : CommSemiring S₁]
[inst_2 : CommSemiring S₂] [inst_3 : CommSemiring T] [inst_4 : Algebra R S₁] [inst_5 : Algebra R S₂]
[inst_6 : Algebra R T] [inst_7 : Algebra S₁ T] [inst_8 : Algebra S₂ T] [IsScalarTower R S₁ T] [IsSca... | If `S₁` is the localization of `R` away from `f` and `S₂` is the localization away from `g`,
then any localization `T` of `S₂` away from `f` is also a localization of `S₁` away from `g`. | true |
GradedRingHom.instOne | Mathlib.RingTheory.GradedAlgebra.RingHom | {ι : Type u_1} →
{A : Type u_2} → {σ : Type u_6} → [inst : Semiring A] → [inst_1 : SetLike σ A] → {𝒜 : ι → σ} → One (𝒜 →+*ᵍ 𝒜) | null | true |
ExteriorAlgebra.lift_symm_apply | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ (R : Type u1) [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {A : Type u_1}
[inst_3 : Semiring A] [inst_4 : Algebra R A] (a : ExteriorAlgebra R M →ₐ[R] A),
(ExteriorAlgebra.lift R).symm a = ⟨a.toLinearMap ∘ₗ CliffordAlgebra.ι 0, ⋯⟩ | null | true |
Subring.list_sum_mem | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : NonAssocRing R] (s : Subring R) {l : List R}, (∀ x ∈ l, x ∈ s) → l.sum ∈ s | Sum of a list of elements in a subring is in the subring. | true |
CochainComplex.mapBifunctorHomologicalComplexShift₁Iso | Mathlib.Algebra.Homology.BifunctorShift | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] →
[inst_3 : CategoryTheory.Preadditive C₁] →
[inst_4 : Category... | Auxiliary definition for `mapBifunctorShift₁Iso`. | true |
GenContFract.coe_toGenContFract | Mathlib.Algebra.ContinuedFractions.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Coe α β] {g : GenContFract α},
↑g = { h := Coe.coe g.h, s := Stream'.Seq.map GenContFract.Pair.coeFn g.s } | null | true |
Mathlib.Tactic.IntervalCases.Methods.bisect._unsafe_rec | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods →
Lean.MVarId →
Subarray Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal →
Mathlib.Tactic.IntervalCases.Bound →
Mathlib.Tactic.IntervalCases.Bound → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Unit | null | false |
CommRingCat.Colimits.Relation.right_distrib | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
(x y z : CommRingCat.Colimits.Prequotient F),
CommRingCat.Colimits.Relation F ((x.add y).mul z) ((x.mul z).add (y.mul z)) | null | true |
UniformConvergenceCLM.neg_apply | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : Neg β}
{inst_2 : Neg F} [self : IsNegApply F α β] (f : F) (x : α), (-f) x = -f x | **Alias** of `neg_apply`. | true |
Lean.Grind.AC.Seq.sort'_k | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | null | true |
_private.Mathlib.NumberTheory.FermatPsp.0.Nat.exists_infinite_pseudoprimes._proof_1_6 | Mathlib.NumberTheory.FermatPsp | ∀ (m : ℕ), 1 < 2 * (m + 2) | null | false |
Mathlib.Tactic.RingNF.RingMode.ctorElimType | Mathlib.Tactic.Ring.RingNF | {motive : Mathlib.Tactic.RingNF.RingMode → Sort u} → ℕ → Sort (max 1 u) | null | false |
Complex.lim_re | Mathlib.Analysis.Complex.Norm | ∀ (f : CauSeq ℂ fun x => ‖x‖), (Complex.cauSeqRe f).lim = f.lim.re | null | true |
IsUnifLocDoublingMeasure | Mathlib.MeasureTheory.Measure.Doubling | {α : Type u_1} → [PseudoMetricSpace α] → [inst : MeasurableSpace α] → MeasureTheory.Measure α → Prop | A measure `μ` is said to be a uniformly locally doubling measure if there exists a constant `C`
such that for all sufficiently small radii `ε`, and for any centre, the measure of a ball of radius
`2 * ε` is bounded by `C` times the measure of the concentric ball of radius `ε`.
Note: it is important that this definitio... | true |
_private.Mathlib.Topology.Order.0.isClosed_induced._simp_1_1 | Mathlib.Topology.Order | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ | null | false |
enorm_prod_le_of_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {ι : Type u_3} {ε : Type u_8} [inst : TopologicalSpace ε] [inst_1 : ESeminormedCommMonoid ε] (s : Finset ι)
{f : ι → ε} {n : ι → ENNReal}, (∀ b ∈ s, ‖f b‖ₑ ≤ n b) → ‖∏ b ∈ s, f b‖ₑ ≤ ∑ b ∈ s, n b | null | true |
Matrix.replicateRow_inj._simp_1 | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {n : Type u_3} {α : Type v} {ι : Type u_6} [Nonempty ι] {v w : n → α},
(Matrix.replicateRow ι v = Matrix.replicateRow ι w) = (v = w) | null | false |
CStarAlgebra.instNegPart | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | {A : Type u_1} →
[inst : NonUnitalRing A] →
[inst_1 : Module ℝ A] →
[inst_2 : SMulCommClass ℝ A A] →
[inst_3 : IsScalarTower ℝ A A] →
[inst_4 : StarRing A] →
[inst_5 : TopologicalSpace A] → [NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] → NegPart A | null | true |
_private.Mathlib.Analysis.Hofer.0._aux_Mathlib_Analysis_Hofer___macroRules__private_Mathlib_Analysis_Hofer_0_termD_1 | Mathlib.Analysis.Hofer | Lean.Macro | null | false |
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Ico_pow_dvd_eq_Ico_of_lt._simp_1_3 | Mathlib.Data.Nat.Factorization.Basic | ∀ {a c b : Prop}, (a ∧ c ↔ b ∧ c) = (c → (a ↔ b)) | null | false |
Lean.Elab.Term.ToDepElimPattern.State | Lean.Elab.Match | Type | null | true |
_private.Mathlib.Order.Directed.0.directedOn_iff_directed._simp_1_5 | Mathlib.Order.Directed | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
MonoidHom.CompTriple.IsId.eq_id | Mathlib.Algebra.Group.Hom.CompTypeclasses | ∀ {M : Type u_1} {inst : Monoid M} {σ : M →* M} [self : MonoidHom.CompTriple.IsId σ], σ = MonoidHom.id M | null | true |
Equiv.prodPiEquivSumPi_apply | Mathlib.Logic.Equiv.Prod | ∀ {ι : Type u_9} {ι' : Type u_10} (π : ι → Type u) (π' : ι' → Type u)
(a : ((i : ι) → Sum.elim π π' (Sum.inl i)) × ((i' : ι') → Sum.elim π π' (Sum.inr i'))) (i : ι ⊕ ι'),
(Equiv.prodPiEquivSumPi π π') a i = (Equiv.sumPiEquivProdPi (Sum.elim π π')).symm a i | null | true |
CategoryTheory.Functor.descOfIsLeftKanExtension_fac_app | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : F ⟶ L.comp F') [inst... | null | true |
Aesop.ForwardStateStats.mk.noConfusion | Aesop.Stats.Basic | {P : Sort u} →
{ruleStateStats ruleStateStats' : Array Aesop.ForwardRuleStateStats} →
{ ruleStateStats := ruleStateStats } = { ruleStateStats := ruleStateStats' } →
(ruleStateStats = ruleStateStats' → P) → P | null | false |
CategoryTheory.ShortComplex.LeftHomologyData.copy._proof_5 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) {K' : C} (eK : K' ≅ h.K),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.parallelPair (h.hi.lift (CategoryTheory.Limits.Ke... | null | false |
Lean.Grind.CommRing.Poly.insert.go.induct_unfolding | Init.Grind.Ring.CommSolver | ∀ (k : ℤ) (m : Lean.Grind.CommRing.Mon) (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Prop),
(∀ (k_1 : ℤ),
motive (Lean.Grind.CommRing.Poly.num k_1) (Lean.Grind.CommRing.Poly.add k m (Lean.Grind.CommRing.Poly.num k_1))) →
(∀ (k_1 : ℤ) (m_1 : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRin... | null | true |
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.graph_map_fst_eq_domain._simp_1_6 | Mathlib.LinearAlgebra.LinearPMap | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
Lean.Server.DirectImports.noConfusionType | Lean.Server.References | Sort u → Lean.Server.DirectImports → Lean.Server.DirectImports → Sort u | null | false |
Function.Surjective.addGroup.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₂] [inst_1 : Zero M₂] [inst_2 : SMul ℕ M₂] [inst_3 : Neg M₂]
[inst_4 : Sub M₂] [inst_5 : SMul ℤ M₂] [inst_6 : AddGroup M₁] (f : M₁ → M₂) (hf : Function.Surjective f)
(one : f 0 = 0) (mul : ∀ (x y : M₁), f (x + y) = f x + f y) (inv : ∀ (x : M₁), f (-x) = -f x)
(div : ... | null | true |
Std.DTreeMap.Internal.Impl.maxKey?_eq_back?_keysArray | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → t.maxKey? = t.keysArray.back? | null | true |
MeasureTheory.exp_neg_llr | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.SigmaFinite μ]
[MeasureTheory.SigmaFinite ν],
μ.AbsolutelyContinuous ν → (fun x => Real.exp (-MeasureTheory.llr μ ν x)) =ᵐ[μ] fun x => (ν.rnDeriv μ x).toReal | null | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.TopologicalSpace.Compacts.instCompleteSpace.match_9 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] (U : SetRel α α) (K x : TopologicalSpace.Compacts α)
(motive : x ∈ {x | (fun K' => (↑K, ↑K') ∈ hausdorffEntourage U) x} → Prop)
(x_1 : x ∈ {x | (fun K' => (↑K, ↑K') ∈ hausdorffEntourage U) x}),
(∀ (left : (↑K, ↑x).1 ⊆ U.preimage (↑K, ↑x).2) (h : (↑K, ↑x).2 ⊆ U.image (↑K, ↑... | null | false |
Aesop.instInhabitedGoalDiff.default | Aesop.RuleTac.GoalDiff | Aesop.GoalDiff | null | true |
ContDiff.fourierPowSMulRight | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} {k : WithTop ℕ∞},
ContDiff ℝ k f → ∀ (n : ℕ), ContDiff ℝ... | null | true |
orderOf_one | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G], orderOf 1 = 1 | null | true |
_private.Mathlib.Geometry.Euclidean.Inversion.Basic.0.EuclideanGeometry.dist_inversion_center._simp_1_6 | Mathlib.Geometry.Euclidean.Inversion.Basic | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
CochainComplex.mappingCocone.triangle_obj₂ | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C],
(CochainComplex.mappingCocone.triangle φ).obj₂ = K | null | true |
CategoryTheory.Limits.sigmaConstCokernelCofork_pt | Mathlib.CategoryTheory.Limits.Preserves.SigmaConst | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (R : C)
{α : Type u_1} {β : Type u_2} (f : α → β) [inst_2 : CategoryTheory.Limits.HasCoproduct fun x => R]
[inst_3 : CategoryTheory.Limits.HasCoproduct fun x => R] [inst_4 : CategoryTheory.Limits.HasCoproduc... | null | true |
Asymptotics.isBigO_congr | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {l : Filter α} {f₁ f₂ : α → E}
{g₁ g₂ : α → F}, f₁ =ᶠ[l] f₂ → g₁ =ᶠ[l] g₂ → (f₁ =O[l] g₁ ↔ f₂ =O[l] g₂) | null | true |
Std.Time.Modifier.x.injEq | Std.Time.Format.Basic | ∀ (presentation presentation_1 : Std.Time.OffsetX),
(Std.Time.Modifier.x presentation = Std.Time.Modifier.x presentation_1) = (presentation = presentation_1) | null | true |
TopModuleCat | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [Ring R] → [TopologicalSpace R] → Type (max u (v + 1)) | The category of topological modules. | true |
CategoryTheory.Limits.FormalCoproduct.isoOfComponents._proof_7 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {X Y : CategoryTheory.Limits.FormalCoproduct C}
(e : X.I ≃ Y.I) (h : (i : X.I) → X.obj i ≅ Y.obj (e i)),
CategoryTheory.CategoryStruct.comp
{ f := ⇑e.symm, φ := fun i => CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (h (e.symm i)).... | null | false |
SeminormedCommRing.mk | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} → [toSeminormedRing : SeminormedRing α] → (∀ (a b : α), a * b = b * a) → SeminormedCommRing α | null | true |
Lean.Lsp.Ipc.CallHierarchy.rec_2 | Lean.Data.Lsp.Ipc | {motive_1 : Lean.Lsp.Ipc.CallHierarchy → Sort u} →
{motive_2 : Array Lean.Lsp.Ipc.CallHierarchy → Sort u} →
{motive_3 : List Lean.Lsp.Ipc.CallHierarchy → Sort u} →
((item : Lean.Lsp.CallHierarchyItem) →
(fromRanges : Array Lean.Lsp.Range) →
(children : Array Lean.Lsp.Ipc.CallHierarchy)... | null | false |
CategoryTheory.InducedCategory.hasForget₂._proof_1 | Mathlib.CategoryTheory.ConcreteCategory.Forget | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} D] {FD : outParam (D → D → Type u_5)}
{CD : outParam (D → Type u_3)} [inst_1 : outParam ((X Y : D) → FunLike (FD X Y) (CD X) (CD Y))]
[inst_2 : CategoryTheory.ConcreteCategory D FD] (f : C → D),
(CategoryTheory.inducedFunctor f).comp (Cate... | null | false |
CategoryTheory.SmallObject.hasPushouts | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [I.IsCardinalForSmallObjectArgument κ],
CategoryTheory.Limits.HasPushouts C | null | true |
AddSubgroup.op.instNormal | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : AddGroup G] {H : AddSubgroup G} [H.Normal], H.op.Normal | null | true |
LinearMap.BilinForm.apply_apply_same_eq_zero_iff | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] (B : LinearMap.BilinForm R M),
(∀ (x : M), 0 ≤ (B x) x) → LinearMap.IsSymm B → ∀ {x : M}, (B x) x = 0 ↔ x ∈ LinearMap.ker B | null | true |
AnalyticAt.comp_of_eq' | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {g : F → G} {f : E → F} {y : F} {x : ... | **Alias** of `AnalyticAt.fun_comp_of_eq`.
---
Eta-expanded form of `AnalyticAt.comp_of_eq`
---
Version of `AnalyticAt.comp` where point equality is a separate hypothesis. | true |
Equiv.piCongr'.eq_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (b : β) → W (h₁.symm b) ≃ Z b),
h₁.piCongr' h₂ = (h₁.symm.piCongr fun b => (h₂ b).symm).symm | null | true |
CategoryTheory.LaxFunctor.mapComp'.congr_simp | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.LaxFunctor B C) {b₀ b₁ b₂ : B} (f : b₀ ⟶ b₁) (g : b₁ ⟶ b₂) (fg : b₀ ⟶ b₂)
(h : CategoryTheory.CategoryStruct.comp f g = fg), F.mapComp' f g fg h = F.mapComp' f g fg h | null | true |
Fin.cast_addNat | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Fin.cast ⋯ (i.addNat m) = Fin.natAdd m i | null | true |
CategoryTheory.Limits.IsZero.iso.congr_simp | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (hX : CategoryTheory.Limits.IsZero X)
(hY : CategoryTheory.Limits.IsZero Y), hX.iso hY = hX.iso hY | null | true |
CategoryTheory.Functor.CommShift₂.commShiftObj | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_3, u_3} C₂} →
{inst_2 : CategoryTheory.Category.{v_5, u_5} D} →
{M : Type u_6} →
{inst_3 : AddCommMonoid M} →
... | null | true |
_private.Mathlib.Topology.Metrizable.Uniformity.0.UniformSpace.metrizable_uniformity._simp_1_5 | Mathlib.Topology.Metrizable.Uniformity | ∀ {α : Sort u_1} (a : α), (a = a) = True | null | false |
List.nodup_iff_forall_not_duplicate | Mathlib.Data.List.Duplicate | ∀ {α : Type u_1} {l : List α}, l.Nodup ↔ ∀ (x : α), ¬List.Duplicate x l | null | true |
_private.Batteries.Linter.UnnecessarySeqFocus.0.Batteries.Linter.initFn._@.Batteries.Linter.UnnecessarySeqFocus.2411125583._hygCtx._hyg.4 | Batteries.Linter.UnnecessarySeqFocus | IO (Lean.Option Bool) | null | false |
PNat.instMetricSpace._proof_8 | Mathlib.Topology.Instances.PNat | autoParam (∀ (x y : ℕ+), PNat.instMetricSpace._aux_6 x y = ENNReal.ofReal (dist x y))
PseudoMetricSpace.edist_dist._autoParam | null | false |
instLinearOrderEReal._aux_10 | Mathlib.Data.EReal.Basic | DecidableEq EReal | null | false |
LiouvilleWith.sub_nat_iff._simp_1 | Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | ∀ {p x : ℝ} {n : ℕ}, LiouvilleWith p (x - ↑n) = LiouvilleWith p x | null | false |
Multiset.le_iff_exists_add | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} {s t : Multiset α}, s ≤ t ↔ ∃ u, t = s + u | null | true |
Lean.InductiveVal.numNested | Lean.Declaration | Lean.InductiveVal → ℕ | Number of auxiliary data types produced from nested occurrences.
An inductive definition `T` is nested when there is a constructor with an argument `x : F T`,
where `F : Type → Type` is some suitably behaved (ie strictly positive) function (Eg `Array T`, `List T`, `T × T`, ...). | true |
CategoryTheory.Subfunctor.Subpresheaf.toPresheaf_map_coe | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type w)}
(G : CategoryTheory.Subfunctor F) {X Y : C} (i : X ⟶ Y),
G.toFunctor.map i = TypeCat.ofHom fun x => ⟨(CategoryTheory.ConcreteCategory.hom (F.map i)) ↑x, ⋯⟩ | **Alias** of `CategoryTheory.Subfunctor.toFunctor_map`. | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_invariant_helper._proof_1_20 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ}
(acc :
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment ×
Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) × Bool × Bool)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (k : Fin (List.length acc.2.1 + 1)) (k' : ℕ)
(k'_succ_in_bounds : k' + 1 < (l :: acc.2.1... | null | false |
RBTree.RBNode.balance2_eq | BatteriesRecycling.RBTree.WF | ∀ {α : Type u_1} {c : RBTree.RBColor} {n : ℕ} {l : RBTree.RBNode α} {v : α} {r : RBTree.RBNode α},
r.Balanced c n → l.balance2 v r = RBTree.RBNode.node RBTree.RBColor.black l v r | The `balance2` function does nothing if the second argument is already balanced. | true |
_private.Mathlib.CategoryTheory.Idempotents.Karoubi.0.CategoryTheory.Idempotents.instEssSurjKaroubiToKaroubiOfIsIdempotentComplete._simp_1 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | null | false |
_private.Mathlib.Analysis.Complex.JensenFormula.0.herglotzLogIntegrand_circleAverage_tendsto._simp_1_3 | Mathlib.Analysis.Complex.JensenFormula | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Std.TreeMap.Raw.insertMany_list_equiv_foldl | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ : Std.TreeMap.Raw α β cmp} {l : List (α × β)},
(t₁.insertMany l).Equiv (List.foldl (fun acc p => acc.insert p.1 p.2) t₁ l) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.