name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.instRankFiniteMapEmbedding._proof_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_2} {β : Type u_1} {M : Matroid α} [M.RankFinite] {f : α ↪ β}, (M.mapEmbedding f).RankFinite | null | false |
EReal.bot_lt_zero | Mathlib.Data.EReal.Basic | ⊥ < 0 | null | true |
ContinuousLineDeriv.rec | Mathlib.Analysis.Distribution.DerivNotation | {V : Type u} →
{E : Type v} →
{F : Type w} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace F] →
[inst_2 : LineDeriv V E F] →
{motive : ContinuousLineDeriv V E F → Sort u_1} →
((continuous_lineDerivOp : ∀ (v : V), Continuous (LineDeriv.lineDerivOp v)) → ... | null | false |
UniqueDiffWithinAt.mono_nhds | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
UniqueDiffWithinAt 𝕜 s x → nhdsWithin x s ≤ nhdsWithin x t → UniqueDiffWithinAt 𝕜 t x | null | true |
eq_of_mabs_div_le_one | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G}, |a / b|ₘ ≤ 1 → a = b | null | true |
Ordnode.dual._f | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → (x : Ordnode α) → Ordnode.below x → Ordnode α | null | false |
Fin.insertNthEquiv_symm_apply | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} (α : Fin (n + 1) → Type u) (p : Fin (n + 1)) (f : (i : Fin (n + 1)) → α i),
(Fin.insertNthEquiv α p).symm f = (f p, p.removeNth f) | null | true |
CategoryTheory.ihom.ev_naturality_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A : C)
[inst_2 : CategoryTheory.Closed A] {X Y : C} (f : X ⟶ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft A ((CategoryTheory.ihom A).map f))
... | null | true |
meromorphicTrailingCoeffAt.eq_1 | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 → E) (x : 𝕜),
meromorphicTrailingCoeffAt f x =
if h₁ : MeromorphicAt f x then if h₂ : meromorphicOrderAt f x = ⊤ then 0 else ⋯.choose x else 0 | null | true |
CommRingCat.instCategory | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.Category.{u_1, u_1 + 1} CommRingCat | null | true |
Representation.mem_stabilizer._simp_1 | Mathlib.RepresentationTheory.Stabilizer | ∀ {k : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Semiring k] {V : Type u_3} [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] {ρ : Representation k G V} {v : V} {g : G}, (g ∈ ρ.stabilizer v) = ((ρ g) v = v) | null | false |
CategoryTheory.Pi.instLaxBraidedForallPi | Mathlib.CategoryTheory.Pi.Monoidal | {I : Type w₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] →
[inst_2 : (i : I) → CategoryTheory.BraidedCategory (C i)] →
{D : I → Type u₂} →
[inst_3 : (i : I) → CategoryTheory.Catego... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Log.0.Complex.exp_two_pi_mul_I_mul_div_eq_one_iff._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {m n : ℕ}, (↑m ∣ ↑n) = (m ∣ n) | null | false |
MonoidWithZero.toMulActionWithZero._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Defs | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] (b : M₀), 1 • b = b | null | false |
exteriorPower.linearMap_ext_iff | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {n : ℕ} {M : Type u_1} {N : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f g : ↥(⋀[R]^n M) →ₗ[R] N},
f = g ↔ f.compAlternatingMap (exteriorPower.ιMulti R n) = g.compAlternatingMap (exteriorPower.ιMulti R n) | null | true |
CliffordAlgebra.EquivEven.e0_mul_e0 | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), CliffordAlgebra.EquivEven.e0 Q * CliffordAlgebra.EquivEven.e0 Q = -1 | null | true |
MeasureTheory.predictablePart | Mathlib.Probability.Martingale.Centering | {Ω : Type u_1} →
{E : Type u_2} →
[inst : NormedAddCommGroup E] →
[NormedSpace ℝ E] →
{m0 : MeasurableSpace Ω} → (ℕ → Ω → E) → MeasureTheory.Filtration ℕ m0 → MeasureTheory.Measure Ω → ℕ → Ω → E | Any `ℕ`-indexed stochastic process can be written as the sum of a martingale and a predictable
process. This is the predictable process. See `martingalePart` for the martingale. | true |
CategoryTheory.yonedaCommGrpGrpObj._proof_6 | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (G : CategoryTheory.CommGrp C) {X Y Z : (CategoryTheory.Grp C)ᵒᵖ}
(f : X ⟶ Y) (g : Y ⟶ Z),
CommGrpCat.ofHom
{ toFun := fun x => CategoryTheory.Cate... | null | false |
_private.Init.Data.Nat.Lemmas.0.Nat.add_eq_three_iff._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {m n : ℕ}, ¬(m + n = 3 ↔ m = 0 ∧ n = 3 ∨ m = 1 ∧ n = 2 ∨ m = 2 ∧ n = 1 ∨ m = 3 ∧ n = 0) → False | null | false |
DoubleCentralizer.coe._proof_9 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {A : Type u_1} [inst : NonUnitalNormedRing A] (a _x _y : A), _x * a * _y = _x * (a * _y) | null | false |
_private.Batteries.Data.Array.Basic.0.Array.scanlMFast._proof_1 | Batteries.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (stop : ℕ), (USize.ofNat (min stop as.size)).toNat ≤ as.size | null | false |
ContinuousMultilinearMap.instCompleteSpace | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup... | null | true |
TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivInverse_map_hom | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasProducts C] {X : TopCat}
(F : TopCat.Presheaf C X) {ι : Type v'} (U : ι → TopologicalSpace.Opens ↑X)
{c c' : CategoryTheory.Limits.Cone (TopCat.Presheaf.SheafConditionEqualizerProducts.diagram F U)} (f : c ⟶ c'),
((TopCat.... | null | true |
ConcaveOn.right_le_of_le_left' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : SMul 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConcaveOn 𝕜 s f... | null | true |
CategoryTheory.PreZeroHypercover.inv_hom_h₀_assoc | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S} (e : E ≅ F)
(i : F.I₀) {Z : C} (h : F.X (e.hom.s₀ (e.inv.s₀ i)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.inv.h₀ i) (CategoryTheory.CategoryStruct.comp (e.hom.h₀ (e.inv.s₀ i)) h) =
CategoryTheory.Catego... | null | true |
RootPairing.pairingIn_eq_add_of_root_eq_add | Mathlib.LinearAlgebra.RootSystem.IsValuedIn | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {S : Type u_6}
[inst_5 : CommRing S] [inst_6 : Algebra S R] [FaithfulSMul S R] [inst_8 : P.IsValuedIn S] {i j k ... | null | true |
aestronglyMeasurable_smul_iff₀ | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} {G₀ : Type u_7} [inst_1 : GroupWithZero G₀] [inst_2 : MulAction G₀ β] [inst_3 : TopologicalSpace G₀]
[ContinuousInv₀ G₀] [TopologicalSpace.MetrizableSpace G₀] [ContinuousSMul G₀ β] {c : α →... | Multiplying by an almost-everywhere nonzero scalar *function* preserves a.e. strong
measurability. This is the varying-scalar analogue of `aestronglyMeasurable_const_smul_iff₀`. | true |
ContinuousLinearMapWOT.seminormFamily | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | {𝕜₁ : Type u_1} →
{𝕜₂ : Type u_2} →
[inst : NormedField 𝕜₁] →
[inst_1 : NormedField 𝕜₂] →
(σ : 𝕜₁ →+* 𝕜₂) →
(E : Type u_3) →
(F : Type u_4) →
[inst_2 : AddCommGroup E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : Module 𝕜₁ E... | The family of seminorms that induce the weak operator topology, namely `‖y (A x)‖` for
all `x` and `y`. | true |
SubarrayIterator.step.eq_1 | Init.Data.Slice.Array.Iterator | ∀ {α : Type u} {m : Type u → Type u_1} (xs : Subarray α),
SubarrayIterator.step { internalState := { xs := xs } } =
if h : xs.start < xs.stop then
have this := ⋯;
have this := ⋯;
Std.IterStep.yield
{
internalState :=
{
xs :=
{
... | null | true |
_private.Init.Data.String.Extra.0.String.removeNumLeadingSpaces.consumeSpaces._mutual._proof_2 | Init.Data.String.Extra | ∀ {s : String} (n : ℕ) (it : s.Pos) (r : String),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun n it => PSigma.casesOn it fun it r => (it, 1)) fun _x =>
PSigma.casesOn _x fun it r => (it, 0))
Prod.instWellFoundedRelation).1
(PSum.inr ⟨it, r⟩) (PSum.inl ⟨... | null | false |
Fin.orderIsoPair.match_1 | Mathlib.Order.Fin.Finset | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α) (motive : ↥{a, b} → Prop) (x : ↥{a, b}),
(∀ (x : α) (hx : x ∈ {a, b}), motive ⟨x, hx⟩) → motive x | null | false |
CategoryTheory.Limits.equalizerPullbackMapIso_hom_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasEqualizers C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] {X Y S T : C} {f g : X ⟶ Y} {s : X ⟶ S} {t : Y ⟶ S}
(hf : CategoryTheory.CategoryStruct.comp f t = s) (hg : CategoryTheory.CategoryStruct.comp g t = s) (v : T ⟶ S... | null | true |
Matrix.conjTranspose_fromRows_eq_fromCols_conjTranspose | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} [inst : Star R] (A₁ : Matrix m₁ n R)
(A₂ : Matrix m₂ n R), (A₁.fromRows A₂).conjTranspose = A₁.conjTranspose.fromCols A₂.conjTranspose | A row partitioned matrix in a Star ring when conjugate transposed gives a column partitioned
matrix with the rows of the initial matrix conjugate transposed to become columns. | true |
MeasureTheory.Measure.count.instSigmaFinite | Mathlib.MeasureTheory.Measure.Count | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] [Countable α],
MeasureTheory.SigmaFinite MeasureTheory.Measure.count | null | true |
_private.Mathlib.CategoryTheory.Functor.Category.0.CategoryTheory.Functor.rightUnitor._proof_5 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (x : C),
(CategoryTheory.CategoryStruct.comp { app := fun X => CategoryTheory.CategoryStruct.id (F.obj X), naturality := ⋯ }
{ app := fun X => Cate... | null | false |
CategoryTheory.MorphismProperty.HasQuotient.mk | Mathlib.CategoryTheory.MorphismProperty.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C}
{homRel : HomRel C} [inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel]
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel],
(∀ ⦃X Y : C⦄ ⦃f g : X ⟶ Y⦄, homRel f g → (W f ↔ W g)) → W.HasQuotie... | null | true |
AddSubgroup.gciToAddSubmonoidSupport._proof_2 | Mathlib.Algebra.Group.Submonoid.Support | ∀ {G : Type u_1} [inst : AddGroup G] (b : AddSubgroup G), b.support ≤ b | null | false |
_private.Mathlib.RingTheory.KrullDimension.Zero.0.Ring.KrullDimLE.eq_maximalIdeal_of_isPrime._proof_1_1 | Mathlib.RingTheory.KrullDimension.Zero | 1 ≠ 0 | null | false |
ProbabilityTheory.strong_law_Lp | Mathlib.Probability.StrongLaw | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [inst_3 : MeasurableSpace E] [BorelSpace E] {p : ENNReal},
1 ≤ p →
p ≠ ⊤ →
∀ (X : ℕ → Ω → E),
MeasureTheory.MemLp (X 0) p μ →
... | **Strong law of large numbers**, Lᵖ version: if `X n` is a sequence of independent
identically distributed random variables in Lᵖ, then `n⁻¹ • ∑ i ∈ range n, X i`
converges in `Lᵖ` to `𝔼[X 0]`. | true |
Std.TreeSet.min!_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.min! ∈ t | null | true |
MulDissociated.subset | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : CommGroup α] {s t : Set α}, s ⊆ t → MulDissociated t → MulDissociated s | null | true |
CategoryTheory.Limits.PullbackCone.combineIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Pullbacks | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_4, u_3} D] {F G H : CategoryTheory.Functor D C} (f : F ⟶ H) (g : G ⟶ H)
(c : (X : D) → CategoryTheory.Limits.PullbackCone (f.app X) (g.app X))
(hc : (X : D) → CategoryTheory.Limits.IsLimit (c X)) (k ... | null | false |
Lean.mkListNode | Lean.Syntax | Array Lean.Syntax → Lean.Syntax | null | true |
CategoryTheory.Arrow.AugmentedCechNerve.extraDegeneracy._proof_3 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
(S : CategoryTheory.SplitEpi f.hom),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp S.secti... | null | false |
SubgroupClass.coe_zpow._simp_2 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {S : Type u_4} {H : S} [inst_1 : SetLike S G] [inst_2 : SubgroupClass S G] (x : ↥H)
(n : ℤ), ↑x ^ n = ↑(x ^ n) | null | false |
Monotone.ae_hasDerivAt | Mathlib.Analysis.Calculus.Monotone | ∀ {f : ℝ → ℝ} (hf : Monotone f),
∀ᵐ (x : ℝ), HasDerivAt f (hf.stieltjesFunction.measure.rnDeriv MeasureTheory.volume x).toReal x | A monotone function is almost everywhere differentiable, with derivative equal to the
Radon-Nikodym derivative of the associated Stieltjes measure with respect to Lebesgue. | true |
CategoryTheory.Limits.coneUnopOfCoconeEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ}
{X Y : (CategoryTheory.Limits.Cocone F)ᵒᵖ} (f : Y ⟶ X) (j : J),
CategoryTheory.CategoryStruct.comp f.unop.hom.unop
((CategoryTheory.Limits.coneUn... | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree.0.groupCohomology.mem_cocycles₁_iff._simp_1_3 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Std.TreeMap.instSliceableRcoSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax | null | false |
CommRingCat.Colimits.Relation.below.mul | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
{motive : (a a_1 : CommRingCat.Colimits.Prequotient F) → CommRingCat.Colimits.Relation F a a_1 → Prop} (j : J)
(x y : ↑(F.obj j)), CommRingCat.Colimits.Relation.below ⋯ | null | true |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.State.found | Lean.Util.ParamMinimizer | Lean.Util.ParamMinimizer.State✝ → Bool | null | true |
nnnorm_pow_le_mul_norm | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedGroup E] {a : E} {n : ℕ}, ‖a ^ n‖₊ ≤ ↑n * ‖a‖₊ | null | true |
Matrix.updateCol_self | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {j : n} {c : m → α} [inst : DecidableEq n],
M.updateCol j c i j = c i | null | true |
Lean.Nat.mkInstPow | Lean.Expr | Lean.Expr | null | true |
WithCStarModule.instUniformSpace | Mathlib.Analysis.CStarAlgebra.Module.Synonym | {A : Type u_3} → {E : Type u_4} → [u : UniformSpace E] → UniformSpace (WithCStarModule A E) | null | true |
Fin.univ_succAbove._proof_1 | Mathlib.Data.Fintype.Basic | ∀ (n : ℕ) (p : Fin (n + 1)), p ∉ Finset.map p.succAboveEmb Finset.univ | null | false |
RingTheory.Sequence.IsRegular.recIterModByRegularWithRing | Mathlib.RingTheory.Regular.RegularSequence | {motive :
(R : Type u) →
[inst : CommRing R] →
(M : Type v) →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (rs : List R) → RingTheory.Sequence.IsRegular M rs → Sort u_7} →
((R : Type u) →
[inst : CommRing R] →
(M : Type v) → [inst_1 : AddCommGroup M] → [ins... | An alternate induction principle from `IsRegular.recIterModByRegular` where
we mod out by successive elements in both the module and the base ring. This is
useful for propagating certain properties of the initial `M`, e.g. faithfulness
or freeness, throughout the induction. | true |
CategoryTheory.ObjectProperty.monotone_retractClosure | Mathlib.CategoryTheory.ObjectProperty.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : CategoryTheory.ObjectProperty C},
P ≤ Q → P.retractClosure ≤ Q.retractClosure | null | true |
PseudoMetricSpace.toPseudoEMetricSpace | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u} → [PseudoMetricSpace α] → PseudoEMetricSpace α | A pseudometric space induces a pseudoemetric space | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getMsbD_add._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {i_lt : i < w}, ¬w - 1 - i < w → False | null | false |
CategoryTheory.ObjectProperty.colimitsClosure.recOn | Mathlib.CategoryTheory.ObjectProperty.ColimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)]
{motive : (a : C) → P.colimitsClosure J a → Prop} {a : C} (t : P.colimitsClosure J a),
(∀ (X : C) (hX : P X), motive X ⋯) →
... | null | false |
CategoryTheory.Center.ofBraidedObj_fst | Mathlib.CategoryTheory.Monoidal.Center | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C), (CategoryTheory.Center.ofBraidedObj X).fst = X | null | true |
_private.Mathlib.Algebra.Order.Star.Basic.0.StarOrderedRing.pos_iff._simp_1_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) | null | false |
Std.ExtDHashMap.getKey!_inter_of_mem_right | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {k : α}, k ∈ m₂ → (m₁ ∩ m₂).getKey! k = m₁.getKey! k | null | true |
CategoryTheory.PreZeroHypercover.pullback₁_X | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T : C} (f : S ⟶ T) (E : CategoryTheory.PreZeroHypercover T)
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback f (E.f i)] (i : E.I₀),
(CategoryTheory.PreZeroHypercover.pullback₁ f E).X i = CategoryTheory.Limits.pullback f (E.f i) | null | true |
Aesop.LIFOQueue.rec | Aesop.Search.Queue | {motive : Aesop.LIFOQueue → Sort u} →
((goals : Array Aesop.GoalRef) → motive { goals := goals }) → (t : Aesop.LIFOQueue) → motive t | null | false |
RKHS.kernel.congr_simp | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] (H : Type u_4) [inst_3 : NormedAddCommGroup H] [inst_4 : InnerProductSpace 𝕜 H]
[inst_5 : RKHS 𝕜 H X V] [inst_6 : CompleteSpace H] [inst_7 : CompleteSpace V] (a a_1 : X),
a = a_1 ... | null | true |
Stoch._proof_1 | Mathlib.Probability.Kernel.Category.Stoch | StochHom.IsMultiplicative | null | false |
Polynomial.zero_notMem_sturmSeq | Mathlib.Algebra.Polynomial.Sturm.Sequence | ∀ {K : Type u_1} [inst : Field K] [inst_1 : DecidableEq K] (p q : Polynomial K), 0 ∉ p.sturmSeq q | null | true |
Metric.sphere_union_ball | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.sphere x ε ∪ Metric.ball x ε = Metric.closedBall x ε | null | true |
Rat.exists_eq_mul_div_num_and_eq_mul_div_den | Mathlib.Data.Rat.Lemmas | ∀ (n : ℤ) {d : ℤ}, d ≠ 0 → ∃ c, n = c * (↑n / ↑d).num ∧ d = c * ↑(↑n / ↑d).den | null | true |
AdicCompletion.AdicCauchySequence.instSMul._proof_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(r : R) (x : AdicCompletion.AdicCauchySequence I M) {m n : ℕ}, m ≤ n → r • ↑x m ≡ r • ↑x n [SMOD I ^ m • ⊤] | null | false |
_private.Mathlib.Data.List.Pairwise.0.List.pairwise_iff_forall_infix._proof_1_115 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {l : List α} (j : ℕ),
2 ≤ (List.take (List.take 1 (List.drop j l)).length (List.drop (List.take j l).length l)).length →
List.take (List.take 1 (List.drop j l)).length (List.drop (List.take j l).length l) ≠ [] | null | false |
RingHom.frobenius_comm | Mathlib.Algebra.CharP.Frobenius | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] (g : R →+* S) (p : ℕ)
[inst_2 : ExpChar R p] [inst_3 : ExpChar S p], g.comp (frobenius R p) = (frobenius S p).comp g | The Frobenius endomorphism commutes with any ring homomorphism. | true |
Insert.mk.noConfusion | Init.Core | {α : outParam (Type u)} →
{γ : Type v} →
{P : Sort u_1} →
{insert insert' : α → γ → γ} → { insert := insert } = { insert := insert' } → (insert ≍ insert' → P) → P | null | false |
MvPolynomial.X_mul_pderiv_monomial | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} [inst : CommSemiring R] {i : σ} {m : σ →₀ ℕ} {r : R},
MvPolynomial.X i * (MvPolynomial.pderiv i) ((MvPolynomial.monomial m) r) = m i • (MvPolynomial.monomial m) r | null | true |
MvPolynomial.constantCoeff_comp_algebraMap | Mathlib.Algebra.MvPolynomial.Basic | ∀ (R : Type u) (σ : Type u_1) [inst : CommSemiring R],
MvPolynomial.constantCoeff.comp (algebraMap R (MvPolynomial σ R)) = RingHom.id R | null | true |
CategoryTheory.Limits.sigmaConstObjCompIso.eq_1 | Mathlib.CategoryTheory.Limits.Preserves.SigmaConst | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
[inst_2 : CategoryTheory.Limits.HasCoproducts C] [inst_3 : CategoryTheory.Limits.HasCoproducts D]
(F : CategoryTheory.Functor C D)
[inst_4 : ∀ (T : Type w), CategoryTheory.Limits.PreservesColimitsO... | null | true |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.quadrant_III._simp_1_4 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) | null | false |
Std.TreeMap.contains_insertIfNew | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k a : α} {v : β},
(t.insertIfNew k v).contains a = (cmp k a == Ordering.eq || t.contains a) | null | true |
IsNonstrictStrictOrder.right_iff_left_not_left | Mathlib.Order.RelClasses | ∀ {α : Type u_1} {r : semiOutParam (α → α → Prop)} {s : α → α → Prop} [self : IsNonstrictStrictOrder α r s] (a b : α),
s a b ↔ r a b ∧ ¬r b a | The relation `r` is the nonstrict relation corresponding to the strict relation `s`. | true |
Ideal.isLocal_of_isMaximal_radical | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, I.radical.IsMaximal → I.IsLocal | null | true |
CategoryTheory.Limits.widePullbackShapeOpMap.eq_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type w) (j : J),
CategoryTheory.Limits.widePullbackShapeOpMap J (some j) none (CategoryTheory.Limits.WidePullbackShape.Hom.term j) =
Quiver.Hom.op (CategoryTheory.Limits.WidePushoutShape.Hom.init j) | null | true |
CategoryTheory.SmallObject.FunctorObjIndex.i | Mathlib.CategoryTheory.SmallObject.Construction | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type w} →
{A B : I → C} →
{f : (i : I) → A i ⟶ B i} → {S X : C} → {πX : X ⟶ S} → CategoryTheory.SmallObject.FunctorObjIndex f πX → I | an element in the index type | true |
star_finsuppSum | Mathlib.Algebra.Star.BigOperators | ∀ {R : Type u_1} {ι : Type u_2} {M : Type u_3} [inst : Zero M] [inst_1 : AddCommMonoid R] [inst_2 : StarAddMonoid R]
(s : ι →₀ M) (f : ι → M → R), star (s.sum f) = s.sum fun i m => star f i m | null | true |
AlgebraicGeometry.StructureSheaf.instAlgebraCarrierStalkCommRingCatObjPresheafTopObjPushforwardTopMapObjFunctorOppositeOpensCarrierTopIsSheafGrothendieckTopologyStructureSheaf | Mathlib.AlgebraicGeometry.Spec | {R S : CommRingCat} →
(f : R ⟶ S) →
(p : PrimeSpectrum ↑R) →
Algebra ↑R
↑(((TopCat.Presheaf.pushforward CommRingCat (AlgebraicGeometry.Spec.topMap f)).obj
(AlgebraicGeometry.Spec.structureSheaf ↑S).obj).stalk
p) | null | true |
_private.Lean.Parser.Extension.0.Lean.Parser.ParserExtension.OLeanEntry.toEntry | Lean.Parser.Extension | Lean.Parser.ParserExtension.State →
Lean.Parser.ParserExtension.OLeanEntry → Lean.ImportM Lean.Parser.ParserExtension.Entry | null | true |
AddCircle.measurableEquivIoc | Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic | (T : ℝ) → [hT : Fact (0 < T)] → (a : ℝ) → AddCircle T ≃ᵐ ↑(Set.Ioc a (a + T)) | The isomorphism `AddCircle T ≃ Ioc a (a + T)` whose inverse is the natural quotient map,
as an equivalence of measurable spaces. | true |
CategoryTheory.functorProdFunctorEquivCounitIso._proof_4 | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u_4) [inst : CategoryTheory.Category.{u_1, u_4} A] (B : Type u_6)
[inst_1 : CategoryTheory.Category.{u_2, u_6} B] (C : Type u_5) [inst_2 : CategoryTheory.Category.{u_3, u_5} C]
{X Y : CategoryTheory.Functor A (B × C)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.functorProdT... | null | false |
CStarAlgebra.ringInverse_le_ringInverse | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] {a b : A},
a ≤ b →
autoParam (IsStrictlyPositive a) CStarAlgebra.ringInverse_le_ringInverse._auto_1 → Ring.inverse b ≤ Ring.inverse a | null | true |
BoundedContinuousFunction.tendsto_integral_of_forall_integral_le_liminf_integral | Mathlib.MeasureTheory.Integral.BoundedContinuousFunction | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] [OpensMeasurableSpace X] {ι : Type u_2}
{L : Filter ι} {μ : MeasureTheory.Measure X} [MeasureTheory.IsProbabilityMeasure μ] {μs : ι → MeasureTheory.Measure X}
[∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μs i)],
(∀ (f : BoundedContinuous... | null | true |
finprod_mem_union | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {s t : Set α},
Disjoint s t →
s.Finite → t.Finite → ∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i = (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i | Given two finite disjoint sets `s` and `t`, the product of `f i` over `i ∈ s ∪ t` equals the
product of `f i` over `i ∈ s` times the product of `f i` over `i ∈ t`. | true |
Quiver.HasInvolutiveReverse.rec | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} →
[inst : Quiver V] →
{motive : Quiver.HasInvolutiveReverse V → Sort u} →
([toHasReverse : Quiver.HasReverse V] →
(inv' : ∀ {a b : V} (f : a ⟶ b), Quiver.reverse (Quiver.reverse f) = f) →
motive { toHasReverse := toHasReverse, inv' := inv' }) →
(t : Quiver.HasInv... | null | false |
_private.Aesop.Forward.State.0.Aesop.InstMap.insertMatch.match_1 | Aesop.Forward.State | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((inst : Lean.Expr) → motive (some inst)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
Finset.prod_Ioc_succ_top | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_3} [inst : CommMonoid M] {a b : ℕ},
a ≤ b → ∀ (f : ℕ → M), ∏ k ∈ Finset.Ioc a (b + 1), f k = (∏ k ∈ Finset.Ioc a b, f k) * f (b + 1) | null | true |
Finset.biUnion_image_sup_left | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] (s t : Finset α),
(s.biUnion fun a => Finset.image (fun x => a ⊔ x) t) = s ⊻ t | null | true |
_private.Lean.Elab.DeclNameGen.0.PSum.casesOn._arg_pusher | Lean.Elab.DeclNameGen | ∀ {α : Sort u} {β : Sort v} {motive : α ⊕' β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : α ⊕' β → α_1 → Prop) (t : α ⊕' β)
(inl : (val : α) → ((y : α_1) → rel (PSum.inl val) y → β_1 y) → motive (PSum.inl val))
(inr : (val : β) → ((y : α_1) → rel (PSum.inr val) y → β_1 y) → mot... | null | false |
Real.tendsto_logb_atTop_of_base_lt_one | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b : ℝ}, 0 < b → b < 1 → Filter.Tendsto (Real.logb b) Filter.atTop Filter.atBot | null | true |
tensorKaehlerQuotKerSqEquiv._proof_3 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_1) (P : Type u_2) (S : Type u_3) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S],
SMulCommClass R (P ⧸ RingHom.ker (algebraMap P S) ^ 2) (P ⧸ RingHom.ker (algebraMap P S) ^ 2) | null | false |
Lean.Compiler.LCNF.JoinPointFinder.find | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.CompilerM Lean.Compiler.LCNF.JoinPointFinder.FindState | Find all `fun` declarations that qualify as a join point, that is:
- are always fully applied
- are always called in tail position
Where a `fun` `f` is in tail position iff it is called as follows:
```
let res := f arg
res
```
The majority (if not all) tail calls will be brought into this form
by the simplifier pass.
... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.