name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Submonoid.decidableMemCentralizer | Mathlib.GroupTheory.Submonoid.Centralizer | {M : Type u_1} →
{S : Set M} →
[inst : Monoid M] → (a : M) → [Decidable (∀ b ∈ S, b * a = a * b)] → Decidable (a ∈ Submonoid.centralizer S) | null | true |
CategoryTheory.Monad.ReflectsColimitOfIsSplitPair.recOn | Mathlib.CategoryTheory.Monad.Monadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{G : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Monad.ReflectsColimitOfIsSplitPair G → Sort u} →
(t : CategoryTheory.Monad.ReflectsColimitOf... | null | false |
Localization.localRingHom_bijective_of_not_conductor_le | Mathlib.RingTheory.Conductor | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S} {P : Ideal S}
[inst_3 : P.IsPrime],
¬conductor R x ≤ P →
∀ {s : Subalgebra R S},
s = R[x] →
∀ (p : Ideal ↥s) [inst_4 : p.IsPrime] [inst_5 : P.LiesOver p],
Function.Bijective ⇑(Localiz... | null | true |
Module.instAEval._proof_7 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ (R : Type u_1) (M : Type u_2) {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [inst_6 : IsScalarTower R A M] (x : A)
(r s : R) (x_1 : Module.AEval R M x), (r + s) • x_1 = r • x_1 + s • x_1 | null | false |
_private.Mathlib.Algebra.Star.Unitary.0.Unitary.smul_mem_of_mem._simp_1_1 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, (U ∈ unitary R) = (star U * U = 1 ∧ U * star U = 1) | null | false |
Int32.or_eq_zero_iff._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32}, (a ||| b = 0) = (a = 0 ∧ b = 0) | null | false |
Part.mk._flat_ctor | Mathlib.Data.Part | {α : Type u} → (Dom : Prop) → (Dom → α) → Part α | null | false |
FirstOrder.Field.fieldOfModelACF | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | (p : ℕ) →
(K : Type u_2) → [inst : FirstOrder.Language.ring.Structure K] → [h : K ⊨ FirstOrder.Language.Theory.ACF p] → Field K | A model for the Theory of algebraically closed fields is a Field. After introducing
this as a local instance on a particular Type, you should usually also introduce
`modelField_of_modelACF p M`, `compatibleRingOfModelField` and `isAlgClosed_of_model_ACF` | true |
Algebra.SubmersivePresentation.basisKaehler.eq_1 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ),
P.basisKaehler = P.basisKaehlerOfIsCompl ⋯ ⋯ | null | true |
cfcₙ_tsub | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : NonUnitalRing A] [inst_2 : PartialOrder A] [inst_3 : StarRing A]
[inst_4 : StarOrderedRing A] [inst_5 : Module ℝ A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : SMulCommClass ℝ A A]
[IsTopologicalRing A] [T2Space A] [inst_10 : NonUnitalContinuousFunctionalCalculus ... | null | true |
Lean.Elab.Term.ElabAppArgs.Context.mk | Lean.Elab.App | Bool → Bool → Bool → ℕ → Lean.Elab.Term.ElabAppArgs.Context | null | true |
Int.clog_of_left_le_one | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
{b : ℕ}, b ≤ 1 → ∀ (r : R), Int.clog b r = 0 | null | true |
quasiconvexOn_iff_le_max | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasiconvexOn 𝕜 s f ↔
Convex 𝕜 s ∧
∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b =... | null | true |
Vector.getElem_add | Init.Data.Vector.Algebra | ∀ {α : Type u_1} {n : ℕ} [inst : Add α] (xs ys : Vector α n) (i : ℕ) (h : i < n), (xs + ys)[i] = xs[i] + ys[i] | null | true |
OpenPartialHomeomorph.EqOnSource.source_eq | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e e' : OpenPartialHomeomorph X Y}, e ≈ e' → e.source = e'.source | Two equivalent open partial homeomorphisms have the same source. | true |
Lean.MonadHashMapCacheAdapter.ctorIdx | Lean.Util.MonadCache | {α β : Type} → {m : Type → Type} → {inst : BEq α} → {inst_1 : Hashable α} → Lean.MonadHashMapCacheAdapter α β m → ℕ | null | false |
SSet.PtSimplex.MulStruct.assoc' | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | {X : SSet} →
{n : ℕ} →
{x : X.obj (Opposite.op { len := 0 })} →
[X.KanComplex] →
{f₀₁ f₁₂ f₂₃ f₀₂ f₁₃ f₀₃ : X.PtSimplex n x} →
{i : Fin n} →
f₀₁.MulStruct f₁₂ f₀₂ i → f₁₂.MulStruct f₂₃ f₁₃ i → f₀₂.MulStruct f₂₃ f₀₃ i → f₀₁.MulStruct f₁₃ f₀₃ i | Given `f₀₁`, `f₁₂`, `f₂₃`, `f₀₂`, `f₁₃` and `f₀₃` in `X.PtSimplex n x`,
if "the" multiplication of `f₀₁` and `f₁₂` is `f₀₂`,
the multiplication of `f₁₂` and `f₂₃` is `f₁₃`,
and the multiplication of `f₀₂` and `f₂₃` is `f₀₃`,
then the multiplication of `f₀₁` and `f₁₃` is `f₀₃`. | true |
Nat.decreasingInduction_self | Mathlib.Data.Nat.Init | ∀ {n : ℕ} {motive : (m : ℕ) → m ≤ n → Sort u_1} (of_succ : (k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯)
(self : motive n ⋯), Nat.decreasingInduction of_succ self ⋯ = self | null | true |
_private.Mathlib.Analysis.Fourier.FourierTransformDeriv.0.VectorFourier.fourierIntegral_fderiv._simp_1_1 | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {α : Type u_1} {𝕜 : Type u_4} [inst : NormedDivisionRing 𝕜] {G : Type u_5} [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace ℝ G] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst_3 : Module 𝕜 G]
[NormSMulClass 𝕜 G] [SMulCommClass ℝ 𝕜 G] (c : 𝕜) (f : α → G), c • ∫ (a : α), f a ∂μ = ∫ (a : α), ... | null | false |
_private.Mathlib.Data.ENat.Monoid.0.ENat.instUniqueUnits._simp_1 | Mathlib.Data.ENat.Monoid | (⊤ = 1) = False | null | false |
HeckeCosetModule.instAddCommMonoid._aux_3 | Mathlib.NumberTheory.HeckeRing.Defs | {G : Type u_1} →
[inst : Group G] →
(Δ : Submonoid G) →
(H₁ H₂ : Subgroup G) →
(Z : Type u_2) →
[inst_1 : AddCommMonoid Z] →
HeckeCosetModule Δ H₁ H₂ Z → HeckeCosetModule Δ H₁ H₂ Z → HeckeCosetModule Δ H₁ H₂ Z | null | false |
Lean.Grind.Linarith.Poly.denote._sunfold | Init.Grind.Ordered.Linarith | {α : Type u_1} → [Lean.Grind.IntModule α] → Lean.Grind.Linarith.Context α → Lean.Grind.Linarith.Poly → α | null | false |
ProbabilityTheory.IdentDistrib.const_add | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ}
[inst_3 : Add γ] [MeasurableAdd γ],
ProbabilityTheory.IdentDistrib f g μ ν →
∀ (c : γ), Probab... | null | true |
MulDistribMulActionHom.inverse._proof_3 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_3} [inst : Monoid M] {A : Type u_1} [inst_1 : Monoid A] [inst_2 : MulDistribMulAction M A] {B₁ : Type u_2}
[inst_3 : Monoid B₁] [inst_4 : MulDistribMulAction M B₁] (f : A →*[M] B₁) (g : B₁ → A)
(h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f), (↑((↑f).inverse g h₁ h₂)).toFun 1 = 1 | null | false |
ContinuousLinearMap.compLeftContinuous._proof_4 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (R : Type u_4) {M : Type u_2} [inst : TopologicalSpace M] {M₂ : Type u_3} [inst_1 : TopologicalSpace M₂]
[inst_2 : Semiring R] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid M₂] [inst_5 : ContinuousAdd M]
[inst_6 : Module R M] [inst_7 : ContinuousConstSMul R M] [inst_8 : ContinuousAdd M₂] [inst_9 : Module R M... | null | false |
ExistsAndEq.mkNestedExists._sunfold | Mathlib.Tactic.Simproc.ExistsAndEq | List ExistsAndEq.VarQ → Q(Prop) → Lean.MetaM Q(Prop) | null | false |
FirstOrder.Language.quotientStructure | Mathlib.ModelTheory.Quotients | {L : FirstOrder.Language} → {M : Type u_1} → {s : Setoid M} → [ps : L.Prestructure s] → L.Structure (Quotient s) | null | true |
Ordinal.univLE_of_injective | Mathlib.SetTheory.Cardinal.UnivLE | ∀ {f : Ordinal.{u} → Ordinal.{v}}, Function.Injective f → UnivLE.{u, v} | null | true |
_private.Mathlib.Tactic.CasesM.0.Mathlib.Tactic.constructorMatching.go._unsafe_rec | Mathlib.Tactic.CasesM | (Lean.Expr → Lean.MetaM Bool) → Lean.MVarId → optParam (Array Lean.MVarId) #[] → Lean.MetaM (Array Lean.MVarId) | null | false |
Inclusion.ExprInclusionBody.casesOn | Mathlib.Tactic.Inclusion.Core.Types | {motive : Inclusion.ExprInclusionBody → Sort u} →
(t : Inclusion.ExprInclusionBody) →
((inclusionBody proofBody : Lean.Expr) → motive { inclusionBody := inclusionBody, proofBody := proofBody }) →
motive t | null | false |
_private.Mathlib.NumberTheory.Multiplicity.0.odd_sq_dvd_geom_sum₂_sub._simp_1_2 | Mathlib.NumberTheory.Multiplicity | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a - (b + c) = a - b - c | null | false |
fixedPoints_submonoid_iSup | Mathlib.GroupTheory.GroupAction.FixingSubgroup | ∀ (M : Type u_1) (α : Type u_2) [inst : Monoid M] [inst_1 : MulAction M α] {ι : Sort u_3} {P : ι → Submonoid M},
MulAction.fixedPoints (↥(iSup P)) α = ⋂ i, MulAction.fixedPoints (↥(P i)) α | Fixed points of iSup of submonoids is intersection | true |
CategoryTheory.Bicategory.Adj.instCategoryHom._proof_4 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {X Y : a ⟶ b} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f | null | false |
Rep.FiniteCyclicGroup.groupHomologyIsoEven._proof_6 | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep.{u_1, u_1, u_1} k G)
(g : G), (Rep.FiniteCyclicGroup.subCompNormHom A g).HasHomology | null | false |
AddCon.pi._proof_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {ι : Type u_1} {f : ι → Type u_2} [inst : (i : ι) → Add (f i)] (C : (i : ι) → AddCon (f i)) {w x y z : (i : ι) → f i},
piSetoid w x → piSetoid y z → ∀ (i : ι), (C i) (w i + y i) (x i + z i) | null | false |
_private.Mathlib.RingTheory.Polynomial.Ideal.0.Polynomial.ker_evalRingHom._simp_1_1 | Mathlib.RingTheory.Polynomial.Ideal | ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, (x ∈ Ideal.span {y}) = (y ∣ x) | null | false |
_private.Init.Data.Slice.Array.Lemmas.0.Subarray.size_mkSlice_roi._simp_1_1 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α}, Std.Slice.size xs = (Std.Slice.toList xs).length | null | false |
CategoryTheory.instDivisionRingEndOfHasKernelsOfSimple._proof_14 | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X : C}
(a b c : CategoryTheory.End X), a * b * c = a * (b * c) | null | false |
Vector.any_iff_exists | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {p : α → Bool} {xs : Vector α n}, xs.any p = true ↔ ∃ i, ∃ (x : i < n), p xs[i] = true | null | true |
Module.toMulActionWithZero._proof_1 | Mathlib.Algebra.Module.Defs | ∀ {R : Type u_2} {M : Type u_1} {x : Semiring R} {x_1 : AddCommMonoid M} [inst : Module R M] (a : R), a • 0 = 0 | null | false |
Lean.Elab.Info.ofMacroExpansionInfo.injEq | Lean.Elab.InfoTree.Types | ∀ (i i_1 : Lean.Elab.MacroExpansionInfo),
(Lean.Elab.Info.ofMacroExpansionInfo i = Lean.Elab.Info.ofMacroExpansionInfo i_1) = (i = i_1) | null | true |
Nat.Partition.ofSym_map | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ {n : ℕ} {σ : Type u_1} {τ : Type u_2} [inst : DecidableEq σ] [inst_1 : DecidableEq τ] (e : σ ≃ τ) (s : Sym σ n),
Nat.Partition.ofSym (Sym.map (⇑e) s) = Nat.Partition.ofSym s | null | true |
Set.zero.eq_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Zero α], Set.zero = { zero := {0} } | null | true |
intervalIntegral.integral_hasStrictFDerivAt_of_tendsto_ae | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {ca cb : E}
{a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
StronglyMeasurableAtFilter f (nhds a) MeasureTheory.volume →
StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
F... | **Fundamental theorem of calculus-1**, strict differentiability in both endpoints.
If `f : ℝ → E` is integrable on `a..b` and `f x` has finite limits `ca` and `cb` almost surely as
`x` tends to `a` and `b`, respectively, then
`(u, v) ↦ ∫ x in u..v, f x` has derivative `(u, v) ↦ v • cb - u • ca` at `(a, b)`
in the sens... | true |
cfc_comp_star._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
_private.Init.Data.Rat.Lemmas.0.Rat.le_of_mul_le_mul_left._simp_1_1 | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, (b ≤ a) = ¬a < b | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.one_sub_eps_mul_card_nonuniformWitness_le_card_star | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {V : Finset α},
V ∈ P.parts →
U ≠ V →
¬G.IsUniform ε U V →
100 ≤ 4 ^ P.parts.card * ε ^ 5... | null | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.decreaseKey.eq_1 | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} [inst : Ord α] (heap : Batteries.BinaryHeap α) (i : Fin heap.size) (x : α),
heap.decreaseKey i x = { arr := (Batteries.BinaryHeap.heapifyDown (heap.vector.set (↑i) x ⋯) i).toArray } | null | true |
Float.Model.UnpackedFloat.ExtendedMantissa.mk.sizeOf_spec | Init.Data.Float.Model.Unpacked.Round | ∀ (mantissa : ℕ) (roundBit stickyBit : Bool),
sizeOf { mantissa := mantissa, roundBit := roundBit, stickyBit := stickyBit } =
1 + sizeOf mantissa + sizeOf roundBit + sizeOf stickyBit | null | true |
Lean.Meta.Grind.SymbolPriorityEntry.ctorIdx | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.SymbolPriorityEntry → ℕ | null | false |
Set.Ico.instIsCancelMulZero | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] [inst_3 : NeZero 1]
[IsCancelMulZero R], IsCancelMulZero ↑(Set.Ico 0 1) | null | true |
MeasureTheory.addEquivAddHaarChar | Mathlib.MeasureTheory.Measure.Haar.MulEquivHaarChar | {G : Type u_1} →
[inst : AddGroup G] →
[inst_1 : TopologicalSpace G] →
[inst_2 : MeasurableSpace G] →
[BorelSpace G] → [IsTopologicalAddGroup G] → [LocallyCompactSpace G] → G ≃ₜ+ G → NNReal | If `φ : A ≃ₜ+ A` then `addEquivAddHaarChar φ` is the positive
real factor by which `φ` scales Haar measures on `A`. | true |
_private.Mathlib.Data.Multiset.Replicate.0.Multiset.nodup_iff_ne_cons_cons.match_1_1 | Mathlib.Data.Multiset.Replicate | ∀ {α : Type u_1} {s : Multiset α} (a : α) (motive : (∃ u, s = a ::ₘ a ::ₘ 0 + u) → Prop)
(x : ∃ u, s = a ::ₘ a ::ₘ 0 + u), (∀ (t : Multiset α) (s_eq : s = a ::ₘ a ::ₘ 0 + t), motive ⋯) → motive x | null | false |
Std.ExtHashSet.casesOn | Std.Data.ExtHashSet.Basic | {α : Type u} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Std.ExtHashSet α → Sort u_1} →
(t : Std.ExtHashSet α) → ((inner : Std.ExtHashMap α Unit) → motive { inner := inner }) → motive t | null | false |
meromorphicNFAt_prod | Mathlib.Analysis.Meromorphic.NormalForm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {ι : Type u_3} {s : Finset ι} {f : ι → 𝕜 → 𝕜},
(∀ i ∈ s, MeromorphicNFAt (f i) x) → {σ | σ ∈ s ∧ f σ x = 0}.Subsingleton → MeromorphicNFAt (∏ i ∈ s, f i) x | A product of meromorphic functions in normal form is in normal form if at most one of the factors
vanishes.
| true |
List.concat | Init.Prelude | {α : Type u} → List α → α → List α | Adds an element to the *end* of a list.
The added element is the last element of the resulting list.
Examples:
* `List.concat ["red", "yellow"] "green" = ["red", "yellow", "green"]`
* `List.concat [1, 2, 3] 4 = [1, 2, 3, 4]`
* `List.concat [] () = [()]`
| true |
_private.Init.Data.Int.Order.0.Int.add_le_add_left.match_1_1 | Init.Data.Int.Order | ∀ {a b : ℤ} (motive : (∃ n, a + ↑n = b) → Prop) (x : ∃ n, a + ↑n = b),
(∀ (n : ℕ) (hn : a + ↑n = b), motive ⋯) → motive x | null | false |
fderiv_eq_smul_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} (y : 𝕜), (fderiv 𝕜 f x) y = y • deriv f x | null | true |
MeasureTheory.Lp.edist_def | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f g : ↥(MeasureTheory.Lp E p μ)), edist f g = MeasureTheory.eLpNorm (↑↑f - ↑↑g) p μ | null | true |
PiTensorProduct.finite | Mathlib.LinearAlgebra.PiTensorProduct.Finite | ∀ {R : Type u_1} [inst : CommSemiring R] {ι : Type u_2} [Finite ι] {M : ι → Type u_3}
[inst_2 : (i : ι) → AddCommMonoid (M i)] [inst_3 : (i : ι) → Module R (M i)] [∀ (i : ι), Module.Finite R (M i)],
Module.Finite R (PiTensorProduct R fun i => M i) | The tensor product `⨂[R] i, M i` of a finite collection of finite modules `M i` over a
`CommSemiring` is finite.
| true |
Aesop.ClusterState.rec | Aesop.Forward.State | {motive : Aesop.ClusterState → Sort u} →
((slots : Array Aesop.Slot) →
(conclusionDeps : Array Aesop.PremiseIndex) →
(variableMap : Aesop.VariableMap) →
(completeMatches : Lean.PHashSet Aesop.Match) →
(haveHypForEachSlot : Bool) →
(slotQueues : Array (Array Aesop.RawH... | null | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.zero_lt_getElem!_toArray_ric_iff._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
prime_mul_iff | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [IsCancelMulZero M] {x y : M},
Prime (x * y) ↔ Prime x ∧ IsUnit y ∨ IsUnit x ∧ Prime y | null | true |
RootPairing.RootPositiveForm.noConfusion | Mathlib.LinearAlgebra.RootSystem.RootPositive | {P : Sort u} →
{ι : Type u_1} →
{R : Type u_2} →
{S : Type u_3} →
{M : Type u_4} →
{N : Type u_5} →
{inst : CommRing S} →
{inst_1 : LinearOrder S} →
{inst_2 : CommRing R} →
{inst_3 : Algebra S R} →
{inst_4 : Ad... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.getVert.match_1.eq_3 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} (motive : (v : V) → G.Walk u v → ℕ → Sort u_2) (v v_1 : V)
(h : G.Adj u v_1) (q : G.Walk v_1 v) (n : ℕ) (h_1 : (x : ℕ) → motive u SimpleGraph.Walk.nil x)
(h_2 : (v v_2 : V) → (h : G.Adj u v_2) → (p : G.Walk v_2 v) → motive v (SimpleGraph.Walk.cons h p) 0)
(h_3 : (v v_2... | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.instIdemCommSemiring._proof_3 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (x : X.IdealSheafData), x ^ 0 = 1 | null | false |
Matroid.indep_iff_forall_closure_sdiff_ne | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {I : Set α}, M.Indep I ↔ ∀ ⦃e : α⦄, e ∈ I → M.closure (I \ {e}) ≠ M.closure I | null | true |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj.presheafMap_comp | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} A]
[inst_3 : C... | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.erase0_rhs.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Types | ∀ (c : Lean.Meta.Grind.AC.EqCnstr), sizeOf (Lean.Meta.Grind.AC.EqCnstrProof.erase0_rhs c) = 1 + sizeOf c | null | true |
Lean.LLVM.Target.recOn | Lean.Compiler.IR.LLVMBindings | {ctx : Lean.LLVM.Context} →
{motive : Lean.LLVM.Target ctx → Sort u} →
(t : Lean.LLVM.Target ctx) → ((ptr : USize) → motive { ptr := ptr }) → motive t | null | false |
CategoryTheory.Limits.BinaryBicone.ofColimitCocone_inl | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{t : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsColimit t),
(CategoryTheory.Limits.BinaryBicone.ofColimitCocone ht).inl = t.ι.app { as := CategoryTheory.Limits... | null | true |
TopologicalSpace.isClosed_range_singleton | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] [T2Space α] {t : TopologicalSpace (Set α)},
IsOpen {∅} → (∀ {U : Set α}, IsOpen U → IsOpen {s | (s ∩ U).Nonempty}) → IsClosed (Set.range fun x => {x}) | Auxiliary lemma showing that singleton sets form a closed set. It takes the required topological
properties as arguments, so that it applies to both the Vietoris topology and the Hausdorff
uniformity. | true |
Lean.getPPAnalyzeTrustSubst | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Options → Bool | null | true |
_private.Lean.Widget.Commands.0.Lean.Widget.elabShowPanelWidgetsCmd._sparseCasesOn_4 | Lean.Widget.Commands | {motive : Lean.AttributeKind → Sort u} →
(t : Lean.AttributeKind) → motive Lean.AttributeKind.local → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
btw_rfl_right | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularOrder α] {a b : α}, btw a b b | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopTreeTarget.len | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} → {w : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopTreeTarget aig w → ℕ | null | true |
ProbabilityTheory.parallelProd_posterior_comp_copy_comp | Mathlib.Probability.Kernel.Posterior | ∀ {Ω : Type u_1} {𝓧 : Type u_2} {mΩ : MeasurableSpace Ω} {m𝓧 : MeasurableSpace 𝓧} {κ : ProbabilityTheory.Kernel Ω 𝓧}
{μ : MeasureTheory.Measure Ω} [inst : MeasureTheory.IsFiniteMeasure μ] [inst_1 : ProbabilityTheory.IsFiniteKernel κ]
[inst_2 : StandardBorelSpace Ω] [inst_3 : Nonempty Ω],
((μ.bind ⇑κ).bind ⇑(P... | The main property of the posterior, as equality of the following diagrams:
```
-- id -- κ
μ -- κ -| = μ -|
-- κ†μ -- id
``` | true |
CochainComplex.shiftShortComplexFunctor'._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence | IsRightCancelAdd ℤ | null | false |
IsClosed.rec | Mathlib.Topology.Defs.Basic | {X : Type u} →
[inst : TopologicalSpace X] →
{s : Set X} →
{motive : IsClosed s → Sort u_1} → ((isOpen_compl : IsOpen sᶜ) → motive ⋯) → (t : IsClosed s) → motive t | null | false |
isMinOn_univ_of_anti_mono | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type u_1} [inst : LinearOrder α] [inst_1 : Preorder β] {b : α} {f : α → β},
AntitoneOn f (Set.Iic b) → MonotoneOn f (Set.Ici b) → IsMinOn f Set.univ b | If `f` is antitone on `Iic b` and monotone on `Ici b`, then the minimum of `f` is attained
at `b`. | true |
CategoryTheory.Lax.OplaxTrans.vComp_naturality_naturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.LaxFunctor B C} (η : CategoryTheory.Lax.OplaxTrans F G)
(θ : CategoryTheory.Lax.OplaxTrans G H) {a b : B} {f g : a ⟶ b} (β : f ⟶ g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.... | null | true |
_private.Mathlib.RingTheory.Ideal.AssociatedPrime.Localization.0.Module.associatedPrimes.comap_mem_associatedPrimes_of_mem_associatedPrimes_of_isLocalizedModule_of_fg._simp_1_4 | Mathlib.RingTheory.Ideal.AssociatedPrime.Localization | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
{x : M} {r : R}, (r ∈ N.colon {x}) = (r • x ∈ N) | null | false |
_aux_Mathlib_Topology_Algebra_ContinuousAffineMap___unexpand_ContinuousAffineMap_1 | Mathlib.Topology.Algebra.ContinuousAffineMap | Lean.PrettyPrinter.Unexpander | null | false |
SSet.Subcomplex.MulticoequalizerDiagram.isColimit'._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.SubcomplexColimits | ∀ {X : SSet} {A : X.Subcomplex} {ι : Type u_2} {U : ι → X.Subcomplex} {V : ι → ι → X.Subcomplex}
(h : A.MulticoequalizerDiagram U V) (x x_1 : ι),
CategoryTheory.CategoryStruct.comp (SSet.Subcomplex.toSSetFunctor.mapIso (CategoryTheory.eqToIso ⋯)).hom
(((CompleteLattice.MulticoequalizerDiagram.multispanIndex h... | null | false |
Int.Internal.Linear.Expr.ctorElim | Init.Data.Int.Linear | {motive : Int.Internal.Linear.Expr → Sort u} →
(ctorIdx : ℕ) →
(t : Int.Internal.Linear.Expr) → ctorIdx = t.ctorIdx → Int.Internal.Linear.Expr.ctorElimType ctorIdx → motive t | null | false |
Plausible.retry | Plausible.Testable | {p : Prop} → Plausible.Gen (Plausible.TestResult p) → ℕ → Plausible.Gen (Plausible.TestResult p) | Execute `cmd` and repeat every time the result is `gaveUp` (at most `n` times). | true |
Homeomorph.instGroup._proof_5 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} [inst : TopologicalSpace X] (n : ℕ) (a : X ≃ₜ X), a ^ ↑n.succ = a ^ ↑n * a | null | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.coeff_mul_single_add._simp_1_4 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
WeierstrassCurve.natDegree_preΨ | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) {n : ℤ},
↑n ≠ 0 → (W.preΨ n).natDegree = (n.natAbs ^ 2 - if Even n then 4 else 1) / 2 | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsEulerian.card_filter_odd_degree._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {n : ℕ}, Odd n = ¬Even n | null | false |
Group.isNilpotent_of_product_of_sylow_group | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [hG : Group G] [Finite G] (e : ((p : ↥(Nat.card G).primeFactors) → (P : Sylow (↑p) G) → ↥↑P) ≃* G),
Group.IsNilpotent G | If a finite group is the direct product of its Sylow groups, it is nilpotent | true |
_private.Mathlib.MeasureTheory.Measure.HasOuterApproxClosed.0.HasOuterApproxClosed.measure_le_lintegral._simp_1_1 | Mathlib.MeasureTheory.Measure.HasOuterApproxClosed | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
_private.Mathlib.CategoryTheory.Abelian.Projective.Dimension.0.CategoryTheory.Retract.projectiveDimension_le._simp_1_1 | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, (⊤ < a) = False | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors.0.MvPowerSeries.mem_nonZeroDivisorsRight_of_constantCoeff._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
Finset.apply_inf_eq_inf_comp_of_linearOrder | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} {ι : Type u_5} [inst : LinearOrder α] [inst_1 : OrderTop α] {s : Finset ι} {f : ι → α}
[inst_2 : SemilatticeInf β] [inst_3 : OrderTop β] (g : α → β), Monotone g → g ⊤ = ⊤ → g (s.inf f) = s.inf (g ∘ f) | null | true |
Lean.Lsp.TextDocumentPositionParams.rec | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.TextDocumentPositionParams → Sort u} →
((textDocument : Lean.Lsp.TextDocumentIdentifier) →
(position : Lean.Lsp.Position) → motive { textDocument := textDocument, position := position }) →
(t : Lean.Lsp.TextDocumentPositionParams) → motive t | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CStarAlgebra.isStrictlyPositive_iff_isStrictlyPositive_sqrt_and_eq_sqrt_mul_sqrt._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | 1 ≠ 0 | null | false |
_private.Lean.Elab.Tactic.Monotonicity.0.Lean.Meta.Monotonicity.initFn._@.Lean.Elab.Tactic.Monotonicity.1250514167._hygCtx._hyg.2 | Lean.Elab.Tactic.Monotonicity | IO Unit | Registers a monotonicity theorem for `partial_fixpoint`.
Monotonicity theorems should have `Lean.Order.monotone ...` as a conclusion. They are used in the
`monotonicity` tactic (scoped in the `Lean.Order` namespace) to automatically prove monotonicity
for functions defined using `partial_fixpoint`.
| false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.getVert_comp_val_eq_get_support._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.getVert ∘ Fin.val = p.support.get | null | false |
CategoryTheory.Limits.binaryCofanZeroLeftIsColimit | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
(X : C) → CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.binaryCofanZeroLeft X) | The colimit cocone for the coproduct with a zero object is colimiting. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.