name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
subsetSupSet | Mathlib.Order.CompleteLatticeIntervals | {α : Type u_2} → (s : Set α) → [Preorder α] → [SupSet α] → [Inhabited ↑s] → SupSet ↑s | `SupSet` structure on a nonempty subset `s` of a preorder with `SupSet`. This definition is
non-canonical (it uses `default s`); it should be used only as here, as an auxiliary instance in the
construction of the `ConditionallyCompleteLinearOrder` structure. | true |
_private.Mathlib.GroupTheory.SpecificGroups.Quaternion.0.QuaternionGroup.mul.eq_2 | Mathlib.GroupTheory.SpecificGroups.Quaternion | ∀ {n : ℕ} (a a_1 : ZMod (2 * n)),
QuaternionGroup.mul✝ (QuaternionGroup.a a) (QuaternionGroup.xa a_1) = QuaternionGroup.xa (a_1 - a) | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.psi_eq_sum_mul_log_prime._proof_1_14 | Mathlib.NumberTheory.Chebyshev | ∀ (k : ℕ), 0 < k → 1 ≤ k | null | false |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.algebra₀._proof_3 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ (R : Type u_2) [inst : CommRing R] {A : Type u_1} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra A B] (D : Algebra.Smooth.DescentAux✝ A B) (r : R)
(x : ↥(Algebra.Smooth.DescentAux.subalgebra✝ R D)),
(Algebra.Smooth.DescentAux.algebra₀._aux_1✝ R D) r * x = x *... | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.shortComplexMap._proof_10 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ (n₀ n₁ n₂ : ℤ), ¬0 ≤ 1 → False | null | false |
ProbabilityTheory.integral_id_stdGaussian | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [BorelSpace E], ∫ (x : E), x ∂ProbabilityTheory.stdGaussian E = 0 | null | true |
_private.Mathlib.Analysis.SpecialFunctions.FrullaniIntegral.0.Frullani.integral_comp_mul_inv_smul._simp_1_6 | Mathlib.Analysis.SpecialFunctions.FrullaniIntegral | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Init.Data.Array.Monadic.0.List.forIn'_eq_foldlM.match_1.eq_2 | Init.Data.Array.Monadic | ∀ {β : Type u_1} (motive : ForInStep β → Sort u_2) (b : β) (h_1 : (b : β) → motive (ForInStep.yield b))
(h_2 : (b : β) → motive (ForInStep.done b)),
(match ForInStep.done b with
| ForInStep.yield b => h_1 b
| ForInStep.done b => h_2 b) =
h_2 b | null | true |
_private.Mathlib.Analysis.Calculus.LogDeriv.0.logDeriv_comp_neg._simp_1_1 | Mathlib.Analysis.Calculus.LogDeriv | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Subgroup.centerToMulOpposite_apply_coe | Mathlib.GroupTheory.Subgroup.Center | ∀ (G : Type u_1) [inst : Group G] (r : ↥(Subsemigroup.center G)),
↑((Subgroup.centerToMulOpposite G) r) = MulOpposite.op ↑r | null | true |
Lean.instInhabitedLocalInstance | Lean.MetavarContext | Inhabited Lean.LocalInstance | null | true |
AddGroupFilterBasis.mk._flat_ctor | Mathlib.Topology.Algebra.FilterBasis | {A : Type u} →
[inst : AddGroup A] →
(sets : Set (Set A)) →
sets.Nonempty →
(∀ {x y : Set A}, x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y) →
(∀ {U : Set A}, U ∈ sets → 0 ∈ U) →
(∀ {U : Set A}, U ∈ sets → ∃ V ∈ sets, V + V ⊆ U) →
(∀ {U : Set A}, U ∈ sets → ∃ V ∈ se... | null | false |
MeasureTheory.Measure.setLIntegral_condKernel_univ_right | Mathlib.Probability.Kernel.Disintegration.Integral | ∀ {β : Type u_1} {Ω : Type u_2} {mβ : MeasurableSpace β} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [inst_3 : MeasureTheory.IsFiniteMeasure ρ]
{f : β × Ω → ENNReal},
Measurable f →
∀ {s : Set β},
MeasurableSet s →
∫⁻ (b : ... | null | true |
Ideal.instIsTwoSidedComap | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
{K : Ideal S} [inst_3 : RingHomClass F R S] [K.IsTwoSided], (Ideal.comap f K).IsTwoSided | null | true |
CategoryTheory.Subgroupoid.inclusion_trans | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {R S T : CategoryTheory.Subgroupoid C} (k : R ≤ S) (h : S ≤ T),
CategoryTheory.Subgroupoid.inclusion ⋯ =
(CategoryTheory.Subgroupoid.inclusion k).comp (CategoryTheory.Subgroupoid.inclusion h) | null | true |
Affine.Simplex.mongePoint.eq_1 | Mathlib.Geometry.Euclidean.MongePoint | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n),
s.mongePoint = (↑(n + 1) / ↑(n - 1)) • (Finset.centroid ℝ Finset.univ s.points -ᵥ s.circumcenter) +ᵥ s.circumcenter | null | true |
Heyting.Regular.instBooleanAlgebra._proof_10 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (a : Heyting.Regular α), ⊤ ≤ a ⊔ aᶜ | null | false |
MonoidHom.smulOneHom.eq_1 | Mathlib.Algebra.Group.Action.Hom | ∀ {M : Type u_4} {N : Type u_5} [inst : Monoid M] [inst_1 : MulOneClass N] [inst_2 : MulAction M N]
[inst_3 : IsScalarTower M N N], MonoidHom.smulOneHom = { toFun := fun x => x • 1, map_one' := ⋯, map_mul' := ⋯ } | null | true |
ProofWidgets.Html.noConfusionType | ProofWidgets.Data.Html | Sort u → ProofWidgets.Html → ProofWidgets.Html → Sort u | null | false |
Std.ExtTreeMap.ext_getKey?_unit | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {t₁ t₂ : Std.ExtTreeMap α Unit cmp},
(∀ (k : α), t₁.getKey? k = t₂.getKey? k) → t₁ = t₂ | null | true |
MeasureTheory.FiniteMeasure.tendsto_iff_forall_testAgainstNN_tendsto | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{γ : Type u_3} {F : Filter γ} {μs : γ → MeasureTheory.FiniteMeasure Ω} {μ : MeasureTheory.FiniteMeasure Ω},
Filter.Tendsto μs F (nhds μ) ↔
∀ (f : BoundedContinuousFunction Ω NNReal),
Filter.Tendsto ... | null | true |
Lean.LocalContext.lastDeclM | Mathlib.Lean.LocalContext | {m : Type u → Type v} → [AlternativeMonad m] → {β : Type u} → Lean.LocalContext → (Lean.LocalDecl → m β) → m β | Return the result of `f` on the last local declaration on which `f` succeeds. | true |
Monovary.inv_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : CommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α]
[inst_3 : PartialOrder β] {f : ι → α} {g : ι → β}, Monovary f g → Antivary f⁻¹ g | **Alias** of the reverse direction of `antivary_inv_left`. | true |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.IsCyclotomicExtension.instSubsingleton._simp_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {S : Subalgebra R A},
(S = ⊤) = ∀ (x : A), x ∈ S | null | false |
CategoryTheory.ComposableArrows.scMap_τ₂ | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S₁ S₂ : CategoryTheory.ComposableArrows C n} (φ : S₁ ⟶ S₂) (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i : ℕ)
(hi : autoParam (i + 2 ≤ n) CategoryTheory.ComposableArrows.scMap._auto_1),
(Catego... | null | true |
associatedPrimes.nonempty | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[IsNoetherianRing R] [Nontrivial M], (associatedPrimes R M).Nonempty | null | true |
_private.Mathlib.RingTheory.Ideal.Height.0.Ideal.isMaximal_of_height_eq_ringKrullDim._simp_1_1 | Mathlib.RingTheory.Ideal.Height | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b ≤ a) = ¬a < b | null | false |
_private.Mathlib.Algebra.Group.Semiconj.Basic.0.SemiconjBy.inv_symm_left_iff._simp_1_1 | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a = b * c⁻¹) = (a * c = b) | null | false |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_5 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : ↥(Unitization.unitsFstOne R A)),
PreQuasiregular.equiv (↑↑x⁻¹).toProd.2 * PreQuasiregular.equiv (↑↑x).toProd.2 = 1 | null | false |
Module.Free.instIsTorsionFree | Mathlib.LinearAlgebra.FreeModule.Basic | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Free R M],
Module.IsTorsionFree R M | null | true |
Mathlib.CountHeartbeats.«_aux_Mathlib_Util_CountHeartbeats___elabRules_Mathlib_CountHeartbeats_command#count_heartbeatsApproximatelyIn___1» | Mathlib.Util.CountHeartbeats | Lean.Elab.Command.CommandElab | `#count_heartbeats in cmd` counts the heartbeats used in the enclosed command `cmd`.
Use `#count_heartbeats` to count the heartbeats in *all* the following declarations.
This is most useful for setting sufficient but reasonable limits via `set_option maxHeartbeats`
for long-running declarations.
If you do so, please ... | false |
ModuleCat.isColimitCokernelCofork._proof_1 | Mathlib.Algebra.Category.ModuleCat.Kernels | ∀ {R : Type u_2} [inst : Ring R] {M N P : ModuleCat R} (f : M ⟶ N) (g : N ⟶ P),
Function.Exact ⇑(ModuleCat.Hom.hom f) ⇑(ModuleCat.Hom.hom g) → (ModuleCat.Hom.hom g).ker = (ModuleCat.Hom.hom f).range | null | false |
Lean.Grind.Semiring.add_zero | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Semiring α] (a : α), a + 0 = a | Zero is the right identity for addition. | true |
Finset.Nonempty.of_add_right | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Add α] {s t : Finset α}, (s + t).Nonempty → t.Nonempty | null | true |
GradedAlgHom.coe_fn_injective | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {ι : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : Grade... | null | true |
OreLocalization.nsmul_eq_nsmul | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddCommMonoid X] [inst_3 : Module R X] (n : ℕ) (x : OreLocalization S X), n • x = n • x | null | true |
instModUSize | Init.Data.UInt.Basic | Mod USize | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.revMatchesAt_iff_splits.match_1_5 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos : s.Pos} (motive : (∃ t₁ t₂, pos.Splits (t₁ ++ pat.copy) t₂) → Prop)
(x : ∃ t₁ t₂, pos.Splits (t₁ ++ pat.copy) t₂),
(∀ (t₁ t₂ : String) (ht : pos.Splits (t₁ ++ pat.copy) t₂), motive ⋯) → motive x | null | false |
Topology.RelCWComplex.Finite.rec | Mathlib.Topology.CWComplex.Classical.Finite | {X : Type u_1} →
[inst : TopologicalSpace X] →
{C D : Set X} →
[inst_1 : Topology.RelCWComplex C D] →
{motive : Topology.RelCWComplex.Finite C → Sort u} →
([toFiniteDimensional : Topology.RelCWComplex.FiniteDimensional C] →
[toFiniteType : Topology.RelCWComplex.FiniteType C] ... | null | false |
TopCat.coneOfConeForget_pt | Mathlib.Topology.Category.TopCat.Limits.Basic | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J TopCat}
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.forget TopCat))),
(TopCat.coneOfConeForget c).pt = ↧(TopCat.conePtOfConeForget c) | null | true |
ZeroAtInftyContinuousMap.instSMulWithZero._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β]
{R : Type u_3} [inst_3 : Zero R] [inst_4 : SMulWithZero R β] [inst_5 : ContinuousConstSMul R β]
(m : ZeroAtInftyContinuousMap α β), 0 • m = 0 | null | false |
Vector.toArray_injective | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {v w : Vector α n}, v.toArray = w.toArray → v = w | null | true |
Std.DTreeMap.Raw.find?_toArray_eq_some_iff_get?_eq_some | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k : α} {v : β k}, Array.find? (fun x => cmp x.fst k == Ordering.eq) t.toArray = some ⟨k, v⟩ ↔ t.get? k = some v | null | true |
Complex.UnitDisc.instInvolutiveStar | Mathlib.Analysis.Complex.UnitDisc.Basic | InvolutiveStar Complex.UnitDisc | null | true |
Option.get.hcongr_3 | Std.Http.Internal.IndexMultiMap | ∀ (α α' : Type u),
α = α' →
∀ (o : Option α) (o' : Option α'),
o ≍ o' → ∀ (a : o.isSome = true) (a' : o'.isSome = true), a ≍ a' → o.get a ≍ o'.get a' | null | true |
Tactic.ComputeAsymptotics.Majorized.add | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Majorized | ∀ {f g b : ℝ → ℝ} {exp f_exp g_exp : ℝ},
Tactic.ComputeAsymptotics.Majorized f b f_exp →
Tactic.ComputeAsymptotics.Majorized g b g_exp →
f_exp ≤ exp → g_exp ≤ exp → Tactic.ComputeAsymptotics.Majorized (f + g) b exp | The sum of two functions that are majorized with exponents `f_exp` and `g_exp` is
majorized with exponent `exp` whenever `exp ≥ max f_exp g_exp`. | true |
ZNum.neg_of_int | Mathlib.Data.Num.ZNum | ∀ (n : ℤ), ↑(-n) = -↑n | null | true |
SNum.recOn | Mathlib.Data.Num.Bitwise | {motive : SNum → Sort u} →
(t : SNum) → ((a : Bool) → motive (SNum.zero a)) → ((a : NzsNum) → motive (SNum.nz a)) → motive t | null | false |
_private.Mathlib.NumberTheory.ModularForms.RamanujanFormula.0.Derivative.serreDerivativeOne_E2_slash | Mathlib.NumberTheory.ModularForms.RamanujanFormula | ∀ (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ),
SlashAction.map 4 γ (Derivative.serreDerivative 1 EisensteinSeries.E2) =
Derivative.serreDerivative 1 EisensteinSeries.E2 | Although `E₂` is only quasi-modular, its weight-1 Serre derivative `∂₁ E₂ = D E₂ - E₂² / 12`
is invariant under the weight-4 slash action of `SL(2, ℤ)`. | true |
ConvexBody.instAdd | Mathlib.Analysis.Convex.Body | {V : Type u_1} →
[inst : TopologicalSpace V] →
[inst_1 : AddCommGroup V] → [inst_2 : Module ℝ V] → [ContinuousAdd V] → Add (ConvexBody V) | null | true |
TensorProduct.LieModule.mapIncl | Mathlib.Algebra.Lie.TensorProduct | {R : Type u} →
[inst : CommRing R] →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
... | Given Lie submodules `M' ⊆ M` and `N' ⊆ N`, this is the natural map: `M' ⊗ N' → M ⊗ N`. | true |
ScottContinuous.prodMk | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
{f : α → β} {g : α → γ}, ScottContinuous f → ScottContinuous g → ScottContinuous fun x => (f x, g x) | null | true |
Real.sin_antiperiodic | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Function.Antiperiodic Real.sin Real.pi | null | true |
CategoryTheory.GradedObject.mapBifunctorMap._proof_4 | Mathlib.CategoryTheory.GradedObject.Bifunctor | ∀ {C₁ : Type u_8} {C₂ : Type u_2} {C₃ : Type u_6} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_9} {J : Type u_1} {K : Type u_4}
(p : I × J ... | null | false |
List.Cursor.ext | Std.Do.Triple.SpecLemmas | ∀ {α : Type u} {l : List α} {x y : l.Cursor}, x.prefix = y.prefix → x.suffix = y.suffix → x = y | null | true |
SimplexCategoryGenRel.IsAdmissible.getElemAsFin | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | {m : ℕ} → {L : List ℕ} → SimplexCategoryGenRel.IsAdmissible m L → (k : ℕ) → k < L.length → Fin (m + k + 1) | An element of an `m`-admissible list, as an element of the appropriate `Fin` | true |
List.orM | Mathlib.Data.List.Defs | {m : Type → Type v} → [Monad m] → List (m Bool) → m Bool | `orM xs` runs the actions in `xs`, returning true if any of them returns
true. `orM` short-circuits, so if an action returns true, later actions are
not run. | true |
Module.Projective.of_shrink | Mathlib.Algebra.Module.Projective | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_3} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Small.{w, u_3} M] [Module.Projective R (Shrink.{w, u_3} M)], Module.Projective R M | null | true |
EST.Out.error.injEq | Init.System.ST | ∀ {ε σ α : Type} (a : ε) (a_1 : Void σ) (a_2 : ε) (a_3 : Void σ),
(EST.Out.error a a_1 = EST.Out.error a_2 a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
ONote.scale | Mathlib.SetTheory.Ordinal.Notation | ONote → ONote → ONote | `scale x o` is the ordinal notation for `ω ^ x * o`. | true |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedHomogeneousComponent_finsupp._simp_1_3 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
Batteries.DList.recOn | Batteries.Data.DList.Basic | {α : Type u} →
{motive : Batteries.DList α → Sort u_1} →
(t : Batteries.DList α) →
((apply : List α → List α) →
(invariant : ∀ (l : List α), apply l = apply [] ++ l) → motive { apply := apply, invariant := invariant }) →
motive t | null | false |
Lean.Compiler.LCNF.CompilerM.run | Lean.Compiler.LCNF.CompilerM | {α : Type} →
Lean.Compiler.LCNF.CompilerM α →
optParam Lean.Compiler.LCNF.CompilerM.State { } →
optParam Lean.Compiler.LCNF.Phase Lean.Compiler.LCNF.Phase.base → Lean.CoreM α | null | true |
QuadraticMap.toBilin._proof_4 | Mathlib.LinearAlgebra.QuadraticForm.Basis | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N], SMulCommClass R R (M →ₗ[R] N) | null | false |
Sylow.commutator_eq_bot_or_commutator_eq_self | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] {p : ℕ} [Fact (Nat.Prime p)] [Finite G] (P : Sylow p G) [IsCyclic ↥↑P] [(↑P).Normal]
{K : Subgroup G}, K.IsComplement' ↑P → ⁅K, ↑P⁆ = ⊥ ∨ ⁅K, ↑P⁆ = ↑P | If a normal cyclic Sylow `p`-subgroup `P` has a complement `K`, then either `⁅K, P⁆ = ⊥` or
`⁅K, P⁆ = P`. | true |
tendsto_inv_nhdsWithin_Iic_inv | Mathlib.Topology.Algebra.Group.Order | ∀ {H : Type u_1} [inst : TopologicalSpace H] [inst_1 : CommGroup H] [inst_2 : PartialOrder H] [IsOrderedMonoid H]
[ContinuousInv H] {a : H}, Filter.Tendsto Inv.inv (nhdsWithin a⁻¹ (Set.Iic a⁻¹)) (nhdsWithin a (Set.Ici a)) | **Alias** of `tendsto_inv_nhdsLE_inv`. | true |
Std.Roc.HasRcoIntersection.ctorIdx | Init.Data.Range.Polymorphic.PRange | {α : Type w} → Std.Roc.HasRcoIntersection α → ℕ | null | false |
ContinuousMultilinearMap.norm_compContinuous_linearIsometryEquiv | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {E₁ : ι → Type wE₁} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : (i : ι) → SeminormedAddCommGroup (E₁ i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (E₁ i)]
[inst_5 : S... | null | true |
nnnorm_sub_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] (a b : E), ‖a - b‖₊ ≤ ‖a‖₊ + ‖b‖₊ | null | true |
MeasurableSpace.measurableSet_iUnion | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_6} (self : MeasurableSpace α) (f : ℕ → Set α),
(∀ (i : ℕ), MeasurableSpace.MeasurableSet' self (f i)) → MeasurableSpace.MeasurableSet' self (⋃ i, f i) | The union of a sequence of measurable sets is a measurable set. Use a more general
`MeasurableSet.iUnion` instead. | true |
Equiv.Perm.perm_symm_mapsTo_iff_mapsTo._simp_1 | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u} {f : Equiv.Perm α} {s : Set α} [Finite ↑s], Set.MapsTo (⇑(Equiv.symm f)) s s = Set.MapsTo (⇑f) s s | null | false |
instInfiniteFreeRing | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u_1), Infinite (FreeRing α) | null | true |
NonUnitalRingHom.srangeRestrict | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] → [inst_1 : NonUnitalNonAssocSemiring S] → (f : R →ₙ+* S) → R →ₙ+* ↥f.srange | Restriction of a non-unital ring homomorphism to its range interpreted as a
non-unital subsemiring.
This is the bundled version of `Set.rangeFactorization`. | true |
Mathlib.Tactic.ToDual.unfoldBoundaries | Mathlib.Tactic.Translate.ToDual | Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaryExt | The `insert_cast`/`insert_cast_fun` attributes create an abstraction boundary for the tagged
constant when translating it. For example, `Set.Icc`, `Monotone`, `DecidableLT`, `WCovBy` are all
morally self-dual, but their definition is not self-dual. So, in order to allow these constants
to be self-dual, we need to not u... | true |
WithConv.addEquiv_symm_apply_ofConv | Mathlib.Algebra.WithConv | ∀ (A : Type u_2) [inst : AddMonoid A] (ofConv : A), ((WithConv.addEquiv A).symm ofConv).ofConv = ofConv | null | true |
NumberField.RingOfIntegers.mk_one | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K], ⟨1, ⋯⟩ = 1 | null | true |
MeasureTheory.Measure.tendsto_IicSnd_atBot | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) [MeasureTheory.IsFiniteMeasure ρ]
{s : Set α}, MeasurableSet s → Filter.Tendsto (fun r => (ρ.IicSnd ↑r) s) Filter.atBot (nhds 0) | null | true |
List.prev_eq_getElem_idxOf_pred_of_ne_head | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α} (ha : a ∈ l),
a ≠ l.head ⋯ → l.prev a ha = l[List.idxOf a l - 1] | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_inter_of_contains_right._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
minSmoothness_add | Mathlib.Analysis.Calculus.FDeriv.Symmetric | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n m : WithTop ℕ∞}, minSmoothness 𝕜 (n + m) = minSmoothness 𝕜 n + m | null | true |
CategoryTheory.Functor.Monoidal.whiskeringLeft._proof_2 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (E : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} E]
[inst_3 : CategoryTheory.MonoidalCategory E] (F : CategoryTheory.Functor C D) {X Y : CategoryTheory.Functor D E}
(f : X ⟶ Y) ... | null | false |
Complex.UnitClosedDisc.instMonoidWithZero._proof_10 | Mathlib.Analysis.Complex.UnitDisc.Basic | autoParam (∀ (x : Complex.UnitClosedDisc), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
NonUnitalRingHom.cancel_right._simp_1 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : NonUnitalNonAssocSemiring α]
[inst_1 : NonUnitalNonAssocSemiring β] [inst_2 : NonUnitalNonAssocSemiring γ] {g₁ g₂ : β →ₙ+* γ} {f : α →ₙ+* β},
Function.Surjective ⇑f → (g₁.comp f = g₂.comp f) = (g₁ = g₂) | null | false |
AddSubgroup.leftTransversals.diff._proof_2 | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} (S : H.LeftTransversal), AddSubgroup.IsComplement ↑S ↑H | null | false |
LinearPMap.domRestrict | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
[inst : Ring R] →
[inst_1 : Ring S] →
{σ : R →+* S} →
{E : Type u_4} →
[inst_2 : AddCommGroup E] →
[inst_3 : Module R E] →
{F : Type u_5} →
[inst_4 : AddCommGroup F] → [inst_5 : Module S F] → (E →... | Restrict a partially defined linear map to a submodule of `E` contained in `f.domain`. | true |
MeasureTheory.SimpleFunc.add_lintegral | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f g : MeasureTheory.SimpleFunc α ENNReal),
(f + g).lintegral μ = f.lintegral μ + g.lintegral μ | null | true |
Std.TreeMap.getElem?_filterMap' | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {f : α → β → Option γ} {k : α}, (Std.TreeMap.filterMap f t)[k]? = t[k]?.bind fun x => f k x | Simpler variant of `getElem?_filterMap` when `LawfulEqCmp` is available. | true |
SSet.Truncated.HomotopyCategory.BinaryProduct.functor_comp_inverse | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ (X Y : SSet.Truncated 2),
(SSet.Truncated.HomotopyCategory.BinaryProduct.functor X Y).comp
(SSet.Truncated.HomotopyCategory.BinaryProduct.inverse X Y) =
CategoryTheory.Functor.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).HomotopyCategory | null | true |
Semiquot.mem_bind | Mathlib.Data.Semiquot | ∀ {α : Type u_1} {β : Type u_2} (q : Semiquot α) (f : α → Semiquot β) (b : β), b ∈ q.bind f ↔ ∃ a ∈ q, b ∈ f a | null | true |
Lake.Date.casesOn | Lake.Util.Date | {motive : Lake.Date → Sort u} →
(t : Lake.Date) → ((year month day : ℕ) → motive { year := year, month := month, day := day }) → motive t | null | false |
Rep.norm_comm_apply | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} [inst : Semiring k] {G : Type v} [inst_1 : Group G] [inst_2 : Fintype G] {A B : Rep.{u_1, u, v} k G}
(f : A ⟶ B) (x : ↑A),
B.ρ.norm ((CategoryTheory.ConcreteCategory.hom f) x) = (CategoryTheory.ConcreteCategory.hom f) (A.ρ.norm x) | null | true |
Frm.ofHom_apply | Mathlib.Order.Category.Frm | ∀ {X Y : Type u} [inst : Order.Frame X] [inst_1 : Order.Frame Y] (f : FrameHom X Y) (x : X),
(CategoryTheory.ConcreteCategory.hom (Frm.ofHom f)) x = f x | null | true |
Polynomial.abs_div_tendsto_atBot_atTop_of_degree_gt | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P Q : Polynomial 𝕜)
[OrderTopology 𝕜],
Q.degree < P.degree →
Q ≠ 0 → Filter.Tendsto (fun x => |Polynomial.eval x P / Polynomial.eval x Q|) Filter.atBot Filter.atTop | null | true |
Bicategory.Opposite.op2_associator | Mathlib.CategoryTheory.Bicategory.Opposites | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
(CategoryTheory.Bicategory.associator f g h).op2 = (CategoryTheory.Bicategory.associator h.op g.op f.op).symm | null | true |
ProbabilityTheory.paretoPDFReal.eq_1 | Mathlib.Probability.Distributions.Pareto | ∀ (t r x : ℝ), ProbabilityTheory.paretoPDFReal t r x = if t ≤ x then r * t ^ r * x ^ (-(r + 1)) else 0 | null | true |
AddSubmonoid.LocalizationMap.map_add_left | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : ↥S), g ↑y ∈ T)
{Q : Type u_4} [inst_3 : AddCommMonoid Q] {k : T.LocalizationMap Q} (z : N),
k ... | Given Localization maps `f : M →+ N, k : P →+ Q` for AddSubmonoids `S, T` respectively if an
`AddCommMonoid` homomorphism `g : M →+ P` induces a `f.map hy k : N →+ Q`, then for all `z : N`,
we have `k (g y) + f.map hy k z = k (g x)` where `x : M, y ∈ S` are such that
`z + f y = f x`. | true |
Aesop.Frontend.RuleExpr.noConfusionType | Aesop.Frontend.RuleExpr | Sort u → Aesop.Frontend.RuleExpr → Aesop.Frontend.RuleExpr → Sort u | null | false |
Lean.Meta.Sym.DSimp.Result._sizeOf_1 | Lean.Meta.Sym.DSimp.DSimpM | Lean.Meta.Sym.DSimp.Result → ℕ | null | false |
MvPolynomial.instFaithfulSMul | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u_2} {S : Type u_3} {σ : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[FaithfulSMul R S], FaithfulSMul (MvPolynomial σ R) (MvPolynomial σ S) | null | true |
LieIdeal.comap_incl_self | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
LieIdeal.comap I.incl I = ⊤ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.