name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasureTheory.integral_Ioi_of_hasDerivAt_of_nonpos | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {g g' : ℝ → ℝ} {a l : ℝ},
ContinuousWithinAt g (Set.Ici a) a →
(∀ x ∈ Set.Ioi a, HasDerivAt g (g' x) x) →
(∀ x ∈ Set.Ioi a, g' x ≤ 0) → Filter.Tendsto g Filter.atTop (nhds l) → ∫ (x : ℝ) in Set.Ioi a, g' x = l - g a | When a function has a limit at infinity `l`, and its derivative is nonpositive, then the
integral of the derivative on `(a, +∞)` is `l - g a` (and the derivative is integrable, see
`integrable_on_Ioi_deriv_of_nonneg`). Version assuming differentiability on `(a, +∞)` and
continuity at `a⁺`. | true |
Std.Do.SVal.uncurry._sunfold | Std.Do.SPred.SVal | {α : Type u} → {σs : List (Type u)} → Std.Do.SVal σs α → Std.Do.SVal.StateTuple σs → α | null | false |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.getParamTypes.go | Lean.Compiler.LCNF.MonoTypes | Lean.Expr → Array Lean.Expr → Array Lean.Expr | null | true |
LocalizedModule.instSemiring._proof_9 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A] {S : Submonoid R}
(a : LocalizedModule S A), a * 0 = 0 | null | false |
Ergodic.toPreErgodic | Mathlib.Dynamics.Ergodic.Ergodic | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → α} {μ : autoParam (MeasureTheory.Measure α) Ergodic._auto_1},
Ergodic f μ → PreErgodic f μ | null | true |
deriv_comp_add_const | Mathlib.Analysis.Calculus.Deriv.Shift | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (f : 𝕜 → F) (a x : 𝕜), deriv (fun x => f (x + a)) x = deriv f (x + a) | Translation in the domain does not change the derivative. | true |
AlgebraicGeometry.IsFinite.mk | Mathlib.AlgebraicGeometry.Morphisms.Finite | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [toIsAffineHom : AlgebraicGeometry.IsAffineHom f],
(∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U → (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.app f U)).Finite) →
AlgebraicGeometry.IsFinite f | null | true |
Fin.map_castAddEmb_Iic | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Finset.map (Fin.castAddEmb m) (Finset.Iic i) = Finset.Iic (Fin.castAdd m i) | null | true |
List.index_of_argmin._f | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder β] {f : α → β} [inst_1 : DecidableEq α] (x : List α)
(f_1 :
List.below (motive := fun x =>
∀ x_1 ∈ List.argmin f x, ∀ x_3 ∈ x, f x_3 ≤ f x_1 → List.idxOf x_1 x ≤ List.idxOf x_3 x) x),
∀ x_1 ∈ List.argmin f x, ∀ x_3 ∈ x, f x_3 ≤ f x_1 → List.idxOf x_1 x ≤... | null | false |
Aesop.Goal.unsafeQueue? | Aesop.Tree.Data | Aesop.Goal → Option Aesop.UnsafeQueue | null | true |
CategoryTheory.CanonicallyOverClass.mk._flat_ctor | Mathlib.CategoryTheory.Comma.Over.OverClass | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → {S : semiOutParam C} → (X ⟶ S) → CategoryTheory.CanonicallyOverClass X S | null | false |
_private.Mathlib.Combinatorics.SetFamily.Compression.Down.0.Finset.nonMemberSubfamily_image_insert._simp_1_1 | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} {s : Finset α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
Equiv.psigmaEquivSigma._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_2} (β : α → Type u_1), Function.RightInverse (fun a => ⟨a.fst, a.snd⟩) fun a => ⟨a.fst, a.snd⟩ | null | false |
Lean.Lsp.CallHierarchyIncomingCallsParams._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CallHierarchyIncomingCallsParams | null | false |
instSMulWithZeroInt._proof_1 | Mathlib.Algebra.Module.NatInt | ∀ {M : Type u_1} [inst : SubtractionMonoid M] (a : M), 0 • a = 0 | null | false |
Lean.Compiler.LCNF.allFVarM | Lean.Compiler.LCNF.FVarUtil | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.Compiler.LCNF.TraverseFVar α] → (Lean.FVarId → m Bool) → α → m Bool | null | true |
UInt16.natCast | Init.GrindInstances.Ring.UInt | NatCast UInt16 | null | true |
Std.Semaphore.ctorIdx | Std.Sync.Semaphore | Std.Semaphore → ℕ | null | false |
_private.Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated.0.MeasurableSpace.generateFrom_iUnion_memPartition._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
zero_isRadical_iff | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_1} [inst : MonoidWithZero R], IsRadical 0 ↔ IsReduced R | null | true |
Cardinal.nat_le_lift_iff | Mathlib.SetTheory.Cardinal.Order | ∀ {n : ℕ} {a : Cardinal.{u}}, ↑n ≤ Cardinal.lift.{v, u} a ↔ ↑n ≤ a | null | true |
_private.Mathlib.Analysis.SpecialFunctions.FrullaniIntegral.0.Frullani.integral_comp_mul_inv_smul._simp_1_3 | Mathlib.Analysis.SpecialFunctions.FrullaniIntegral | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Lean.AxiomVal | Lean.Declaration | Type | null | true |
_private.Mathlib.Data.Sym.Sym2.0.Sym2.fromVector.match_1.eq_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (motive : List.Vector α 2 → Sort u_2) (a b : α) (property : [a, b].length = 2)
(h_1 : (a b : α) → (property : [a, b].length = 2) → motive ⟨[a, b], property⟩),
(match ⟨[a, b], property⟩ with
| ⟨[a, b], property⟩ => h_1 a b property) =
h_1 a b property | null | true |
CategoryTheory.Limits.has_cofiltered_limits_op_of_has_filtered_colimits | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.Limits.HasFilteredColimitsOfSize.{v₂, u₂, v₁, u₁} C],
CategoryTheory.Limits.HasCofilteredLimitsOfSize.{v₂, u₂, v₁, u₁} Cᵒᵖ | null | true |
Lean.Meta.Simp.mkCongrFun | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Result → Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result | null | true |
not_and_of_not_or_not | Init.PropLemmas | ∀ {a b : Prop}, ¬a ∨ ¬b → ¬(a ∧ b) | null | true |
PowerSeries.subst_X | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] {τ : Type u_3} {S : Type u_4} [inst_1 : CommRing S] [inst_2 : Algebra R S]
{a : MvPowerSeries τ S}, PowerSeries.HasSubst a → PowerSeries.subst a PowerSeries.X = a | null | true |
IsLocalization.moduleLid | Mathlib.RingTheory.Localization.BaseChange | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
(A : Type u_2) →
[inst_1 : CommSemiring A] →
[inst_2 : Algebra R A] →
[IsLocalization S A] →
(M₁ : Type u_5) →
[inst_4 : AddCommMonoid M₁] →
[inst_5 : Module R M₁] →
... | If `A` is a localization of `R`, tensoring an `A`-module with `A` over `R` does nothing. | true |
OrderDual.instBiheytingAlgebra | Mathlib.Order.Heyting.Basic | {α : Type u_2} → [BiheytingAlgebra α] → BiheytingAlgebra αᵒᵈ | null | true |
ZFClass.coe_cmem._simp_1 | Mathlib.SetTheory.ZFC.Class | ∀ {A : ZFClass.{u}} {x : ZFSet.{u}}, ZFClass.CMem (↑x) A = (x ∈ A) | null | false |
Ring.KrullDimLE.isNilpotent_iff_mem_maximalIdeal | Mathlib.RingTheory.KrullDimension.Zero | ∀ {R : Type u_1} [inst : CommSemiring R] [Ring.KrullDimLE 0 R] [inst_2 : IsLocalRing R] {x : R},
IsNilpotent x ↔ x ∈ IsLocalRing.maximalIdeal R | null | true |
Fin.predAbove_left_inj | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} {x y : Fin n}, x.predAbove = y.predAbove ↔ x = y | `predAbove` is injective at the pivot | true |
Lean.Order.monotone_bind | Init.Internal.Order.Basic | ∀ (m : Type u → Type v) [inst : Bind m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m]
{α β : Type u} {γ : Sort w} [inst_3 : Lean.Order.PartialOrder γ] (f : γ → m α) (g : γ → α → m β),
Lean.Order.monotone f → Lean.Order.monotone g → Lean.Order.monotone fun x => f x >>= g x | null | true |
_private.Lean.Compiler.NameMangling.0.Lean.parseLowerHex?._f | Lean.Compiler.NameMangling | (s : String) →
(k : ℕ) → Nat.below (motive := fun k => s.Pos → ℕ → Option (s.Pos × ℕ)) k → s.Pos → ℕ → Option (s.Pos × ℕ) | null | false |
Pell.Solution₁.instInhabited | Mathlib.NumberTheory.Pell | {d : ℤ} → Inhabited (Pell.Solution₁ d) | null | true |
SubMulAction.fixingSubgroupEquivFixingSubgroup.congr_simp | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_1} {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] {s t : Set α} {g g_1 : M} (e_g : g = g_1)
(hg : g • t = s), SubMulAction.fixingSubgroupEquivFixingSubgroup hg = SubMulAction.fixingSubgroupEquivFixingSubgroup ⋯ | null | true |
FirstOrder.Language.Theory.IsUniversal.mk | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {T : L.Theory},
(∀ ⦃φ : L.Sentence⦄, φ ∈ T → FirstOrder.Language.BoundedFormula.IsUniversal φ) → T.IsUniversal | null | true |
CategoryTheory.Monad.CreatesColimitOfIsSplitPair.noConfusionType | Mathlib.CategoryTheory.Monad.Monadicity | Sort u →
{C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{G : CategoryTheory.Functor D C} →
CategoryTheory.Monad.CreatesColimitOfIsSplitPair G →
{C' : Type u₁} →
{D' : Ty... | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go_decl_eq | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (distance : ℕ)
(input : aig.RefVec w) (curr : ℕ) (hcurr : curr ≤ w) (s : aig.RefVec curr) (idx : ℕ) (h1 : idx < aig.decls.size)
(h2 :
idx < (Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go aig input distance curr ... | null | true |
Cardinal.toENat_lt_natCast._simp_1 | Mathlib.SetTheory.Cardinal.ENat | ∀ {c : Cardinal.{u}} {n : ℕ}, (Cardinal.toENat c < ↑n) = (c < ↑n) | null | false |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._unary._proof_21 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo hi : Fin as.size), ↑lo ≤ ↑hi → ↑lo ≤ ↑⟨(↑lo + ↑hi) / 2, ⋯⟩ | null | false |
Submodule.coe_torsionBy | Mathlib.Algebra.Module.Torsion.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (a : R),
↑(Submodule.torsionBy R M a) = ⇑(DistribSMul.toLinearMap R M a) ⁻¹' {0} | null | true |
instRingWithIdealFilter._proof_10 | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] (x : IdealFilter A),
autoParam (∀ (x_1 : WithIdealFilter x), 0 • x_1 = 0) AddMonoid.nsmul_zero._autoParam | null | false |
Quot.induction_on | Mathlib.Data.Quot | ∀ {α : Sort u_4} {r : α → α → Prop} {β : Quot r → Prop} (q : Quot r), (∀ (a : α), β (Quot.mk r a)) → β q | null | true |
WithBot.instMonoidWithZero._proof_4 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MonoidWithZero α] [inst_2 : Nontrivial α] (a : WithBot α), a ^ 0 = 1 | null | false |
Std.ExtDHashMap.Const.size_le_size_insertManyIfNewUnit | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} {ρ : Type w} [inst : ForIn Id ρ α]
[inst_1 : EquivBEq α] [inst_2 : LawfulHashable α] {l : ρ},
m.size ≤ (Std.ExtDHashMap.Const.insertManyIfNewUnit m l).size | null | true |
MemHolder.eq_1 | Mathlib.Topology.MetricSpace.HolderNorm | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] (r : NNReal) (f : X → Y),
MemHolder r f = ∃ C, HolderWith C r f | null | true |
CategoryTheory.Limits.isLimitOfPreserves | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
(F : CategoryTheory.Functor C D) →
... | A convenience function for `PreservesLimit`, which takes the functor as an explicit argument to
guide typeclass resolution.
| true |
PosSMulReflectLE.le_of_smul_le_smul_left | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {inst : SMul α β} {inst_1 : Preorder α} {inst_2 : Preorder β} {inst_3 : Zero α}
[self : PosSMulReflectLE α β] ⦃a : α⦄, 0 < a → ∀ ⦃b₁ b₂ : β⦄, a • b₁ ≤ a • b₂ → b₁ ≤ b₂ | Do not use this. Use `le_of_smul_le_smul_left` instead. | true |
List.sortedGT_iff_getElem_gt_getElem_of_lt | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α],
l.SortedGT ↔ ∀ ⦃i j : ℕ⦄ ⦃hi : i < l.length⦄ ⦃hj : j < l.length⦄, j < i → l[i] < l[j] | null | true |
Ordnode.dual.eq_1 | Mathlib.Data.Ordmap.Ordnode | ∀ {α : Type u_1}, Ordnode.nil.dual = Ordnode.nil | null | true |
AlgebraicGeometry.Scheme.Γ_def | Mathlib.AlgebraicGeometry.Scheme | AlgebraicGeometry.Scheme.Γ =
AlgebraicGeometry.Scheme.forgetToLocallyRingedSpace.op.comp AlgebraicGeometry.LocallyRingedSpace.Γ | null | true |
Std.IterM.forIn_filterMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type u_1 → Type u_2} {n : Type u_1 → Type u_3} {α β β₂ γ : Type u_1} [inst : Monad m] [LawfulMonad m]
[inst_2 : Monad n] [LawfulMonad n] [inst_4 : MonadLiftT m n] [LawfulMonadLiftT m n] [inst_6 : Std.Iterator α m β]
[Std.Iterators.Finite α m] [inst_8 : Std.IteratorLoop α m n] [Std.LawfulIteratorLoop α m n] {... | null | true |
continuous_prodMk | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : X → Y} {g : X → Z}, (Continuous fun x => (f x, g x)) ↔ Continuous f ∧ Continuous g | null | true |
CategoryTheory.IsUniversalColimit.whiskerEquivalence_iff | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {J : Type v'} [inst : CategoryTheory.Category.{u', v'} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{K : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} K] (e : J ≌ K) {F : CategoryTheory.Functor K C}
{c : CategoryTheory.Limits.Cocone F},
CategoryTheory.IsUniversalColimit (CategoryTheory.L... | null | true |
CategoryTheory.Limits.biprod.decomp_hom_from | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] {Z : C} (f : X ⊞ Y ⟶ Z),
∃ f₁ f₂,
f =
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.fst f₁ +
CategoryTheory.CategoryS... | null | true |
_private.Mathlib.Order.Bounds.Basic.0.mem_upperBounds_univ._simp_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a : α}, (a ∈ upperBounds s) = ∀ x ∈ s, x ≤ a | null | false |
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.lift._simp_2 | Mathlib.GroupTheory.CoprodI | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_4} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[inst_3 : MulHomClass F M N] (f : F) {x y : M}, (Con.ker f) x y = (f x = f y) | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.Operations.0.RKHS.Add'.projection._proof_1 | Mathlib.Analysis.InnerProductSpace.Reproducing.Operations | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], RingHomCompTriple (RingHom.id 𝕜) (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
OneHom.mk._flat_ctor | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} → {N : Type u_11} → [inst : One M] → [inst_1 : One N] → (toFun : M → N) → toFun 1 = 1 → OneHom M N | null | false |
CategoryTheory.Functor.mapDifferentialObject._proof_2 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddMonoidWithOne S] {C : Type u_5} [inst_1 : CategoryTheory.Category.{u_4, u_5} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S] (D : Type u_2)
[inst_4 : CategoryTheory.Category.{u_1, u_2} D] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms D]
... | null | false |
Lean.Linter.instInhabitedLinterSetsState | Lean.Linter.Init | Inhabited Lean.Linter.LinterSetsState | null | true |
_private.Mathlib.NumberTheory.Divisors.0.Int.mul_mem_one_two_three_iff._simp_1_2 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
Int64.lt_of_le_of_lt | Init.Data.SInt.Lemmas | ∀ {a b c : Int64}, a ≤ b → b < c → a < c | null | true |
Rat.padicValuation_le_one_iff | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {x : ℚ}, (Rat.padicValuation p) x ≤ 1 ↔ ¬p ∣ x.den | null | true |
Module.Basis.repr_symm_single | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Module.Basis ι R M) (i : ι) (c : R), (b.repr.symm fun₀ | i => c) = c • b i | null | true |
ContinuousOn.const_smul | Mathlib.Topology.Algebra.ConstMulAction | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : SMul M α] [ContinuousConstSMul M α]
[inst_3 : TopologicalSpace β] {g : β → α} {s : Set β}, ContinuousOn g s → ∀ (c : M), ContinuousOn (c • g) s | null | true |
Std.Internal.List.getValue?_insertEntry_of_false | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((_ : α) × β)} {k a : α} {v : β},
(k == a) = false →
Std.Internal.List.getValue? a (Std.Internal.List.insertEntry k v l) = Std.Internal.List.getValue? a l | null | true |
WithLp.toLp_sum | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) (V : Type u_4) [inst : AddCommGroup V] {ι : Type u_7} (s : Finset ι) (f : ι → V),
WithLp.toLp p (∑ i ∈ s, f i) = ∑ i ∈ s, WithLp.toLp p (f i) | null | true |
_private.Mathlib.Probability.Kernel.Composition.IntegralCompProd.0.ProbabilityTheory.Kernel.continuous_integral_integral._simp_1_2 | Mathlib.Probability.Kernel.Composition.IntegralCompProd | 0 = ENNReal.ofReal 0 | null | false |
Fin.le_refl._simp_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (a : Fin n), (a ≤ a) = True | null | false |
Std.TreeMap.ordCompare_maxKeyD_modify_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] {t : Std.TreeMap α β compare} {k : α} {f : β → β}
{fallback : α}, compare ((t.modify k f).maxKeyD fallback) (t.maxKeyD fallback) = Ordering.eq | null | true |
DFinsupp.Lex.isBotZeroClass | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → AddCommMonoid (α i)]
[inst_2 : (i : ι) → PartialOrder (α i)] [∀ (i : ι), IsBotZeroClass (α i)], IsBotZeroClass (Lex (Π₀ (i : ι), α i)) | null | true |
AddGrpCat.limitAddGroup._proof_11 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddGrpCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddGrpCat)).sections],
autoParam
(∀ (n : ℕ) (x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget AddGrpCat))).pt)... | null | false |
Lean.Compiler.LCNF.Code.updateJmp! | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu → Lean.FVarId → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Compiler.LCNF.Code pu | null | true |
Nat.ofDigitChars_cons | Init.Data.Nat.ToString | ∀ {b : ℕ} {c : Char} {cs : List Char} {init : ℕ},
b.ofDigitChars (c :: cs) init = b.ofDigitChars cs (b * init + (c.toNat - '0'.toNat)) | null | true |
WeierstrassCurve.Projective.Equation.baseChange | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} {S : Type s} [inst_1 : CommRing S] {A : Type u}
[inst_2 : CommRing A] {B : Type v} [inst_3 : CommRing B] [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [I... | null | true |
QuadraticMap.tmul.congr_simp | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct | ∀ {R : Type uR} {A : Type uA} {M₁ : Type uM₁} {M₂ : Type uM₂} {N₁ : Type uN₁} {N₂ : Type uN₂} [inst : CommRing R]
[inst_1 : CommRing A] [inst_2 : AddCommGroup M₁] [inst_3 : AddCommGroup M₂] [inst_4 : AddCommGroup N₁]
[inst_5 : AddCommGroup N₂] [inst_6 : Algebra R A] [inst_7 : Module R M₁] [inst_8 : Module A M₁] [in... | null | true |
_private.Mathlib.Topology.List.0.List.continuous_insertIdx.match_1_1 | Mathlib.Topology.List | ∀ {α : Type u_1} (motive : α × List α → Prop) (x : α × List α), (∀ (a : α) (l : List α), motive (a, l)) → motive x | null | false |
Cardinal.continuum_mul_aleph0 | Mathlib.SetTheory.Cardinal.Continuum | Cardinal.continuum * Cardinal.aleph0 = Cardinal.continuum | null | true |
String.Slice.Pattern.Model.IsLongestRevMatch.ne_endPos | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[String.Slice.Pattern.Model.StrictPatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatch pat pos → pos ≠ s.endPos | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.hashRoot.match_1 | Lean.Meta.Tactic.Grind.Types | (motive : Option Lean.Meta.Grind.ENode → Sort u_1) →
(x : Option Lean.Meta.Grind.ENode) →
((node : Lean.Meta.Grind.ENode) → motive (some node)) → ((x : Option Lean.Meta.Grind.ENode) → motive x) → motive x | null | false |
_private.Mathlib.Order.Partition.Basic.0.Partition.rel_rfl_iff.match_1_1 | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {x : α} {u : Set α} {P : Partition u} (motive : P.Rel x x → Prop) (x_1 : P.Rel x x),
(∀ (t : Set α) (ht : t ∈ P) (hxP right : x ∈ t), motive ⋯) → motive x_1 | null | false |
Decidable.imp_iff_left_iff | Init.PropLemmas | ∀ {a b : Prop} [Decidable a], (b ↔ a → b) ↔ a ∨ b | null | true |
Sum.Lex.«_aux_Mathlib_Order_Sum_Order___delab_app_Sum_Lex_term_⊕ₗ__1» | Mathlib.Order.Sum.Order | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
HomologicalComplex.singleMapHomologicalComplex_comp_hom_app_assoc | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} {W₃ : Type u_5} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Category.{v_4, u_5} W₃]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms W₂]
... | null | true |
Mathlib.Tactic.Determinant.Cert.noConfusion | Mathlib.Tactic.Determinant.Bird.Cert | {P : Sort u} →
{u : Lean.Level} →
{α : Q(Type u)} →
{rα : Q(CommRing «$α»)} →
{t : Mathlib.Tactic.Determinant.Cert rα} →
{u' : Lean.Level} →
{α' : Q(Type u')} →
{rα' : Q(CommRing «$α'»)} →
{t' : Mathlib.Tactic.Determinant.Cert rα'} →
... | null | false |
DirectSum.instAlgebra | Mathlib.Algebra.DirectSum.Algebra | {ι : Type uι} →
(R : Type uR) →
(A : ι → Type uA) →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → AddCommMonoid (A i)] →
[inst_2 : (i : ι) → Module R (A i)] →
[inst_3 : AddMonoid ι] →
[inst_4 : DirectSum.GSemiring A] →
[DirectSum.GAlgebra R A] → [i... | null | true |
_private.Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage.0.Dynamics.dynEntourage_comp_subset._simp_1_4 | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
MonoidHom.subgroupMap_surjective | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] (f : G →* G') (H : Subgroup G),
Function.Surjective ⇑(f.subgroupMap H) | null | true |
String.Slice.Pattern.Model.not_isLongestMatch_startPos | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[String.Slice.Pattern.Model.StrictPatternModel pat] {s : String.Slice},
¬String.Slice.Pattern.Model.IsLongestMatch pat s.startPos | null | true |
tendsto_measure_Icc_nhdsWithin_right' | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ (μ : MeasureTheory.Measure ℝ) [MeasureTheory.IsFiniteMeasureOnCompacts μ] (b : ℝ),
Filter.Tendsto (fun δ => μ (Set.Icc (b - δ) (b + δ))) (nhdsWithin 0 (Set.Ioi 0)) (nhds (μ {b})) | null | true |
Int.Internal.Linear.Poly.isUnsatDiseq_k | Init.Data.Int.Linear | Int.Internal.Linear.Poly → Bool | null | true |
«_aux_Init_Core___macroRules_term_\__1» | Init.Core | Lean.Macro | null | false |
CategoryTheory.Limits.IsImage.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Images | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{F : CategoryTheory.Limits.MonoFactorisation f} →
CategoryTheory.Limits.IsImage F →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
... | null | false |
_private.Lean.Meta.Tactic.Grind.PropagatorAttr.0.Lean.Meta.Grind.initFn._@.Lean.Meta.Tactic.Grind.PropagatorAttr.3194545076._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.PropagatorAttr | IO (IO.Ref Lean.Meta.Grind.BuiltinPropagators) | null | false |
Nat.pow_padicValNat_mul_divMaxPow | Mathlib.Data.Nat.PadicValNat | ∀ (p n : ℕ), p ^ padicValNat p n * n.divMaxPow p = n | null | true |
CategoryTheory.Pseudofunctor.presheafHom_obj | Mathlib.CategoryTheory.Sites.Descent.IsPrestack | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {S : C}
(M N : ↑(F.obj { as := Opposite.op S })) (T : (CategoryTheory.Over S)ᵒᵖ),
(F.presheafHom M N).obj T =
((F.map (Opposite.unop T).hom.op.toLoc).toFunctor.ob... | null | true |
instLTInt8 | Init.Data.SInt.Basic | LT Int8 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.