name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Topology.UniformSpace.ProdApproximation.0.ContinuousMap.exists_finite_sum_smul_approximation_of_mem_uniformity._simp_1_4 | Mathlib.Topology.UniformSpace.ProdApproximation | ∀ {α : Type u} [inst : HasSubset α] [Std.Refl fun x1 x2 => x1 ⊆ x2] (a : α), (a ⊆ a) = True | null | false |
Std.DTreeMap.getKey!_eq_get!_getKey? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {a : α}, t.getKey! a = (t.getKey? a).get! | null | true |
NormedGroup.toENormedMonoid._proof_4 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {F : Type u_1} [inst : NormedGroup F] (x y : F), ‖x * y‖ₑ ≤ ‖x‖ₑ + ‖y‖ₑ | null | false |
List.max!.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Inhabited α] [inst_1 : Max α] (xs : List α),
xs.max! =
match xs.max? with
| none => panicWithPosWithDecl "Batteries.Data.List.Basic" "List.max!" 20 12 "List.max! called on empty list"
| some x => x | null | true |
IsLocalization.IsInteger.eq_1 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ (R : Type u_1) [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (a : S),
IsLocalization.IsInteger R a = (a ∈ (algebraMap R S).rangeS) | null | true |
CategoryTheory.Limits.equalizerSubobject_arrow | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasEqualizer f g],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizerSubobjectIso f g).hom
(CategoryTheory.Limits.equalizer.ι f g) =
(CategoryTheory.Limits.equalizerSubobject f... | null | true |
ENNReal.coe_ne_coe | Mathlib.Data.ENNReal.Basic | ∀ {p q : NNReal}, ↑p ≠ ↑q ↔ p ≠ q | null | true |
Module.Basis.finTwoProd | Mathlib.LinearAlgebra.Basis.Fin | (R : Type u_7) → [inst : Semiring R] → Module.Basis (Fin 2) R (R × R) | The basis of `R × R` given by the two vectors `(1, 0)` and `(0, 1)`. | true |
MeasureTheory.AECover.integral_tendsto_of_countably_generated | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [l.IsCountablyGenerated] {φ : ι → Set α},
MeasureTheory.AECover μ l φ →
∀ {f : α → E},
MeasureTheory.Integrable f μ → Filter.Ten... | null | true |
MeasureTheory.eLpNormEssSup_indicator_const_le | Mathlib.MeasureTheory.Function.LpSeminorm.Indicator | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ε : Type u_7} [inst : TopologicalSpace ε]
[inst_1 : ESeminormedAddMonoid ε] (s : Set α) (c : ε), MeasureTheory.eLpNormEssSup (s.indicator fun x => c) μ ≤ ‖c‖ₑ | null | true |
_private.Mathlib.Algebra.Group.Basic.0.zsmul_zero.match_1_1 | Mathlib.Algebra.Group.Basic | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | null | false |
ScottContinuous.comp | 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 (g ∘ f) | null | true |
CategoryTheory.Lax.OplaxTrans.ctorIdx | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.LaxFunctor B C} → CategoryTheory.Lax.OplaxTrans F G → ℕ | null | false |
Lean.TransformStep.toStep | Lean.Meta.Tactic.Simp.Types | Lean.TransformStep → Lean.Meta.Simp.Step | null | true |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.SparseCasesOnKey.rec | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnKey✝ → Sort u} →
((indName : Lean.Name) →
(ctors : Array Lean.Name) →
(isPrivate : Bool) → motive { indName := indName, ctors := ctors, isPrivate := isPrivate }) →
(t : Lean.Meta.SparseCasesOnKey✝) → motive t | null | false |
_private.Mathlib.Algebra.Order.Monovary.0.monovary_iff_forall_smul_nonneg._simp_1_2 | Mathlib.Algebra.Order.Monovary | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | null | false |
Lean.Parser.many1.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter | null | true |
_private.Mathlib.Analysis.AbsoluteValue.Equivalence.0.AbsoluteValue.exists_one_lt_lt_one_pi_of_one_lt._simp_1_2 | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] [Nonempty α] {s : Set α},
(s ∈ Filter.atTop) = ∃ a, ∀ (b : α), a ≤ b → b ∈ s | null | false |
ConvexOn.monotoneOn_deriv | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ}, ConvexOn ℝ S f → (∀ x ∈ S, DifferentiableAt ℝ f x) → MonotoneOn (deriv f) S | If `f` is convex on `S` and differentiable at all points of `S`, then its derivative is monotone
on `S`. | true |
Std.DTreeMap.minKey!_insertIfNew_of_isEmpty | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {k : α} {v : β k}, t.isEmpty = true → (t.insertIfNew k v).minKey! = k | null | true |
Algebra.TensorProduct.tensorQuotientEquiv._proof_9 | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {R : Type u_2} (S : Type u_1) (T : Type u_3) (A : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : CommRing A] [inst_6 : Algebra R A]
[inst_7 : Algebra S A] [inst_8 : IsScalarTower R S A], SMulCommClass S R (TensorProduct R A T) | null | false |
FiniteField.exists_nonsquare | Mathlib.FieldTheory.Finite.Basic | ∀ {F : Type u_3} [inst : Field F] [Finite F], ringChar F ≠ 2 → ∃ a, ¬IsSquare a | In a finite field of odd characteristic, not every element is a square. | true |
CategoryTheory.StructuredArrow.map₂_obj_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B}
{R' : CategoryTheory.Fun... | null | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.toString.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (motive : (x : Substring.Raw) → Substring.Raw.ValidFor l m r x → Prop) (x : Substring.Raw)
(x_1 : Substring.Raw.ValidFor l m r x),
(∀ (a : Unit),
motive
{ str := String.ofList (l ++ m ++ r), startPos := { byteIdx := String.utf8Len l },
stopPos := { byteIdx := String.utf... | null | false |
Aesop.Goal.setMVars | Aesop.Tree.Data | Aesop.UnorderedArraySet Lean.MVarId → Aesop.Goal → Aesop.Goal | null | true |
Lean.Meta.ArgsPacker.noConfusionType | Lean.Meta.ArgsPacker.Basic | Sort u → Lean.Meta.ArgsPacker → Lean.Meta.ArgsPacker → Sort u | null | false |
Positive.addRightCancelSemigroup._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {M : Type u_1} [inst : AddRightCancelMonoid M] [inst_1 : Preorder M] [inst_2 : AddLeftStrictMono M],
IsRightCancelAdd { x // 0 < x } | null | false |
FunLike.distribMulAction._proof_1 | Mathlib.Data.FunLike.Module | ∀ {M : Type u_4} {F : Type u_3} {α : Type u_1} {β : Type u_2} [i : FunLike F α β] [inst : Monoid M]
[inst_1 : AddMonoid β] [inst_2 : DistribMulAction M β] [inst_3 : SMul M F] [IsSMulApply M F α β] (n : M) (f : F),
⇑(n • f) = n • ⇑f | null | false |
Interval.recBotCoe | Mathlib.Order.Interval.Basic | {α : Type u_1} →
[inst : LE α] → {C : Interval α → Sort u_6} → C ⊥ → ((a : NonemptyInterval α) → C ↑a) → (n : Interval α) → C n | Recursor for `Interval` using the preferred forms `⊥` and `↑a`. | true |
Fin.univ_def | Mathlib.Data.Fintype.Basic | ∀ (n : ℕ), Finset.univ = { val := ↑(List.finRange n), nodup := ⋯ } | null | true |
EuclideanGeometry.Sphere.isIntTangent_self_iff | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [Nontrivial V] {s : EuclideanGeometry.Sphere P}, s.IsIntTangent s ↔ 0 ≤ s.radius | null | true |
Lean.Meta.Grind.Goal | Lean.Meta.Tactic.Grind.Types | Type | A `grind` goal, combining shared state with a specific metavariable.
See `GoalState` for details on why the state is factored out.
**Note**: The `Goal` internal representation is just a pair `GoalState` and `MVarId`.
| true |
Lean.Meta.reduceBoolNativeUnsafe | Lean.Meta.WHNF | Lean.Name → Lean.MetaM Bool | null | true |
Std.TreeSet.Raw.compare_get?_self | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, Option.all (fun x => decide (cmp x k = Ordering.eq)) (t.get? k) = true | null | true |
Lean.Elab.Command.Scope.levelNames._default | Lean.Elab.Command.Scope | List Lean.Name | null | false |
Polynomial.div_tendsto_atBot_zero_iff_degree_lt | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P Q : Polynomial 𝕜)
[OrderTopology 𝕜],
Q ≠ 0 →
(Filter.Tendsto (fun x => Polynomial.eval x P / Polynomial.eval x Q) Filter.atBot (nhds 0) ↔ P.degree < Q.degree) | null | true |
_private.Mathlib.Topology.Compactness.CompactlyCoherentSpace.0.CompactCoherentification.continuous_dom_iff._simp_1_1 | Mathlib.Topology.Compactness.CompactlyCoherentSpace | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {f : α → β} {g : β → γ} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace γ},
Continuous g = Continuous (g ∘ f) | null | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.map_mul._simp_1_3 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
(a ∈ x.support) = (x.coeff a ≠ 0) | null | false |
CategoryTheory.Deterministic | Mathlib.CategoryTheory.CopyDiscardCategory.Deterministic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → [CategoryTheory.CopyDiscardCategory C] → {X Y : C} → (X ⟶ Y) → Prop | A morphism is deterministic if it preserves the comonoid structure.
In probabilistic contexts, these are morphisms without randomness. | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.bullet.go | Lean.DocString.Parser | List Lean.Doc.Parser.UnorderedListType → Lean.Parser.ParserFn | null | true |
MeasureTheory.le_eLpNorm_of_bddBelow | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ {α : Type u_1} {F : Type u_3} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F],
p ≠ 0 →
p ≠ ⊤ →
∀ {f : α → F} (C : NNReal) {s : Set α},
MeasurableSet s → (∀ᵐ (x : α) ∂μ, x ∈ s → C ≤ ‖f x‖₊) → C • μ s ^ (1 / p.toReal) ≤ MeasureTheory.eLpNorm f p μ | null | true |
FunLike.addCommSemigroup.eq_1 | Mathlib.Data.FunLike.Group | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : Add F] [inst_2 : AddCommSemigroup β]
[inst_3 : IsAddApply F α β], FunLike.addCommSemigroup = Function.Injective.addCommSemigroup (fun f => ⇑f) ⋯ ⋯ | null | true |
OrderIso.map_ciSup_set_of_directedOn | Mathlib.Order.ConditionallyCompletePartialOrder.Indexed | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : ConditionallyCompletePartialOrderSup α]
[inst_1 : ConditionallyCompletePartialOrderSup β] (e : α ≃o β) {s : Set γ} {f : γ → α},
DirectedOn (fun x1 x2 => x1 ≤ x2) (f '' s) → BddAbove (f '' s) → s.Nonempty → e (⨆ i, f ↑i) = ⨆ i, e (f ↑i) | null | true |
groupHomology.boundaries₂ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → (A : Rep.{u, u, u} k G) → Submodule k (G × G →₀ ↑A) | The 2-boundaries `B₂(G, A)` of `A : Rep k G`, defined as the image of the map
`(G³ →₀ A) → (G² →₀ A)` defined by
`a·(g₁, g₂, g₃) ↦ ρ_A(g₁⁻¹)(a)·(g₂, g₃) - a·(g₁g₂, g₃) + a·(g₁, g₂g₃) - a·(g₁, g₂)`. | true |
AddSubgroup.lowerCentralSeries_characteristic | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : AddGroup G] (S : AddSubgroup G) [S.Characteristic] (n : ℕ),
(S.lowerCentralSeries n).Characteristic | null | true |
Asymptotics.IsLittleOTVS.fun_add | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {f₁ f₂ : α → E} {g ... | Eta-expanded form of `Asymptotics.IsLittleOTVS.add` | true |
Subgroup.exists_pow_mem_of_index_ne_zero | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.index ≠ 0 → ∀ (a : G), ∃ n, 0 < n ∧ n ≤ H.index ∧ a ^ n ∈ H | null | true |
AddMonoidHom.independent_range_of_coprime_order | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_2} {H : ι → Type u_3} [inst_1 : (i : ι) → AddGroup (H i)]
(ϕ : (i : ι) → H i →+ G),
(Pairwise fun i j => ∀ (x : H i) (y : H j), AddCommute ((ϕ i) x) ((ϕ j) y)) →
∀ [Finite ι] [inst_3 : (i : ι) → Fintype (H i)],
(Pairwise fun i j => (Fintype.card (H i)).Copr... | null | true |
LinearOrderedAddCommGroup.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] [Nontrivial G] {g : G},
({x | g ≤ x}.WellFoundedOn fun x1 x2 => x1 < x2) ↔ Nonempty (G ≃+o ℤ) | null | true |
ContinuousLinearMap.toSpanSingletonLE._proof_2 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : TopologicalSpace M] [inst_4 : TopologicalSpace R] [inst_5 : ContinuousSMul R M] (x : M),
(fun f => f 1) (ContinuousLinearMap.toSpanSingleton R x) = x | null | false |
CategoryTheory.ShortComplex.SnakeInput.mono_v₀₁_τ₂ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.Mono S.v₀₁.τ₂ | null | true |
Nat.fact_prime_two | Mathlib.Data.Nat.Prime.Defs | Fact (Nat.Prime 2) | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs.0.AffineSubspace.mem_direction_iff_eq_vsub_left.match_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_3} {V : Type u_1} {P : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p : P} (v : V) (motive : v ∈ (fun x => p -ᵥ x) '' ↑s → Prop)
(x : v ∈ (fun x => p -ᵥ x) '' ↑s), (∀ (p₂ : P) (hp₂ : p₂ ∈ ↑s) (hv : (fun x => p -ᵥ x) p₂ = v... | null | false |
DirichletCharacter.isPrimitive_one_level_one | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R], DirichletCharacter.IsPrimitive 1 | null | true |
Std.ExtDTreeMap.le_minKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, (∀ (k' : α), t.minKey? = some k' → (cmp k k').isLE = true) ↔ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
lp.singleAddMonoidHom | Mathlib.Analysis.Normed.Lp.lpSpace | {α : Type u_3} →
{E : α → Type u_4} →
[inst : (i : α) → NormedAddCommGroup (E i)] → [DecidableEq α] → (p : ENNReal) → (i : α) → E i →+ ↥(lp E p) | `single` as an `AddMonoidHom`. | true |
UpperSet.coe_zero | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α], ↑0 = Set.Ici 0 | null | true |
isSelfAdjoint_iff_isStarNormal_and_quasispectrumRestricts | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : NonUnitalRing A] [inst_2 : StarRing A] [inst_3 : Module ℂ A]
[inst_4 : IsScalarTower ℂ A A] [inst_5 : SMulCommClass ℂ A A] [NonUnitalContinuousFunctionalCalculus ℂ A IsStarNormal]
{a : A}, IsSelfAdjoint a ↔ IsStarNormal a ∧ QuasispectrumRestricts a ⇑Complex.reC... | An element in a non-unital C⋆-algebra is selfadjoint if and only if it is normal and its
quasispectrum is contained in `ℝ`. | true |
Digraph.sdiff_adj | Mathlib.Combinatorics.Digraph.Basic | ∀ {V : Type u_2} (x y : Digraph V) (v w : V), (x \ y).Adj v w ↔ x.Adj v w ∧ ¬y.Adj v w | null | true |
ProbabilityTheory.lintegral_condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) [MeasureTheory.IsFiniteMeasure ρ] (x : ℝ),
∫⁻ (a : α), ENNReal.ofReal (↑(ProbabilityTheory.condCDF ρ a) x) ∂ρ.fst = ρ (Set.univ ×ˢ Set.Iic x) | null | true |
smul_add | Mathlib.Algebra.GroupWithZero.Action.Defs | ∀ {M : Type u_1} {A : Type u_7} [inst : AddZeroClass A] [inst_1 : DistribSMul M A] (a : M) (b₁ b₂ : A),
a • (b₁ + b₂) = a • b₁ + a • b₂ | null | true |
HomotopicalAlgebra.LeftHomotopyRel.rightHomotopy._proof_4 | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
{f g : X ⟶ Y} [inst_2 : HomotopicalAlgebra.IsCofibrant X] (h : HomotopicalAlgebra.LeftHomotopyRel f g)
(Q : HomotopicalAlgebra.PathObject Y) [inst_3 : Q.IsGood] (h_1 : ⋯.choose.LeftHomotopy f g) (h... | null | false |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage._proof_1_9 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] {a b c : ι},
b ≤ c → ∀ (w : ι), a < w → w ≤ b → w ∈ Finset.Ioc a c | null | false |
Filter.boundedFilterSubalgebra._proof_2 | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | ∀ (𝕜 : Type u_3) {α : Type u_1} {β : Type u_2} [inst : SeminormedCommRing 𝕜] [inst_1 : SeminormedRing β]
[inst_2 : Algebra 𝕜 β] [inst_3 : IsBoundedSMul 𝕜 β] (l : Filter α) (f g : α → β),
f ∈ Filter.boundedFilterSubmodule 𝕜 l →
g ∈ Filter.boundedFilterSubmodule 𝕜 l → f * g ∈ Filter.boundedFilterSubmodule �... | null | false |
PNat.caseStrongInductionOn | Mathlib.Data.PNat.Basic | {p : ℕ+ → Sort u_1} → (a : ℕ+) → p 1 → ((n : ℕ+) → ((m : ℕ+) → m ≤ n → p m) → p (n + 1)) → p a | Strong induction on `ℕ+`, with `n = 1` treated separately. | true |
Std.DTreeMap.Internal.Impl.View.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{size : ℕ} → (k : α) → β k → Std.DTreeMap.Internal.Impl.Tree α β size → Std.DTreeMap.Internal.Impl.View α β size | null | false |
Function.not_lt_argmin | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LT β] [inst_1 : WellFoundedLT β] [inst_2 : Nonempty α] (a : α),
¬f a < f (Function.argmin f) | null | true |
Ordinal.le_nfp | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ (f : Ordinal.{u_1} → Ordinal.{u_1}) (a : Ordinal.{u_1}), a ≤ Ordinal.nfp f a | null | true |
Finset.product_disjUnion | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t t' : Finset β} (ht : Disjoint t t'),
s ×ˢ t.disjUnion t' ht = (s ×ˢ t).disjUnion (s ×ˢ t') ⋯ | null | true |
_private.Init.Data.SInt.Lemmas.0.ISize.ofNat_mul._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, ISize.ofNat n = ISize.ofInt ↑n | null | false |
TrivSqZeroExt.snd_mul | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : Mul R] [inst_1 : Add M] [inst_2 : SMul R M] [inst_3 : SMul Rᵐᵒᵖ M]
(x₁ x₂ : TrivSqZeroExt R M), (x₁ * x₂).snd = x₁.fst • x₂.snd + MulOpposite.op x₂.fst • x₁.snd | null | true |
AddSubgroup.nontrivial_iff_exists_ne_zero | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), Nontrivial ↥H ↔ ∃ x ∈ H, x ≠ 0 | null | true |
ByteArray.Iterator.casesOn | Init.Data.ByteArray.Basic | {motive : ByteArray.Iterator → Sort u} →
(t : ByteArray.Iterator) → ((array : ByteArray) → (idx : ℕ) → motive { array := array, idx := idx }) → motive t | null | false |
_private.Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber.0.CircleDeg1Lift.coe_pow.match_1_1 | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
Bundle.zeroSection_snd | Mathlib.Topology.VectorBundle.Basic | ∀ {B : Type u_2} (F : Type u_3) (E : B → Type u_4) [inst : (x : B) → Zero (E x)] (x : B),
(Bundle.zeroSection F E x).snd = 0 | null | true |
BitVec.hash._unary.eq_def | Init.Data.BitVec.Basic | ∀ (_x : (n : ℕ) ×' BitVec n),
BitVec.hash._unary _x =
PSigma.casesOn _x fun n bv =>
if n ≤ 64 then (↑bv.toFin).toUInt64
else mixHash (↑bv.toFin).toUInt64 (BitVec.hash._unary ⟨n - 64, BitVec.setWidth (n - 64) (bv >>> 64)⟩) | null | false |
Std.ExtDTreeMap.Const.getKey!_insertManyIfNewUnit_list_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {l : List α} {k : α},
k ∈ t → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKey! k = t.getKey! k | null | true |
MeasureTheory.measurePreserving_prod_div_swap | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Group G] [MeasurableMul₂ G] (μ ν : MeasureTheory.Measure G)
[MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] [MeasurableInv G] [μ.IsMulRightInvariant],
MeasureTheory.MeasurePreserving (fun z => (z.2, z.1 / z.2)) (μ.prod ν) (ν.prod μ) | The map `(x, y) ↦ (y, x / y)` sends `μ × ν` to `ν × μ`. | true |
Std.DTreeMap.Internal.Unit.RoiSliceData.mk | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] → (Std.DTreeMap.Internal.Impl α fun x => Unit) → Std.Roi α → Std.DTreeMap.Internal.Unit.RoiSliceData α | null | true |
Nat.Subtype.orderIsoOfNat | Mathlib.Order.OrderIsoNat | (s : Set ℕ) → [Infinite ↑s] → ℕ ≃o ↑s | `Nat.Subtype.ofNat` as an order isomorphism between `ℕ` and an infinite subset. See also
`Nat.nth` for a version where the subset may be finite. | true |
Complex.norm_ofNat | Mathlib.Analysis.Complex.Norm | ∀ (n : ℕ) [inst : n.AtLeastTwo], ‖OfNat.ofNat n‖ = OfNat.ofNat n | null | true |
Lean.Lsp.instFromJsonSignatureHelpTriggerKind | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SignatureHelpTriggerKind | null | true |
_private.Mathlib.Algebra.MvPolynomial.Rename.0.MvPolynomial.killCompl_map._simp_1_1 | Mathlib.Algebra.MvPolynomial.Rename | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), ⇑f = ⇑↑f | null | false |
iterate_map_sub | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} {F : Type u_11} [inst : AddGroup M] [inst_1 : FunLike F M M] [AddMonoidHomClass F M M] (f : F) (n : ℕ)
(x y : M), (⇑f)^[n] (x - y) = (⇑f)^[n] x - (⇑f)^[n] y | null | true |
CompleteSublattice.mem_sSup | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {𝒮 : Set ↥L} {x : X}, x ∈ sSup 𝒮 ↔ ∃ T ∈ 𝒮, x ∈ T | null | true |
_private.Mathlib.LinearAlgebra.Basis.VectorSpace.0.nonzero_span_atom._simp_1_1 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M)
(p : Submodule R M), (R ∙ m ≤ p) = (m ∈ p) | null | false |
Multiset.coe_attach | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} (l : List α), (↑l).attach = ↑l.attach | null | true |
_private.Mathlib.Tactic.HigherOrder.0.Tactic.mkHigherOrderType._sparseCasesOn_1 | Mathlib.Tactic.HigherOrder | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Sigma.Lex.linearOrder._proof_4 | Mathlib.Data.Sigma.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → LinearOrder (α i)] (a b : (i : ι) × α i),
Sigma.Lex (fun x1 x2 => x1 < x2) (fun x x1 x2 => x1 ≤ x2) a b ∨
Sigma.Lex (fun x1 x2 => x1 < x2) (fun x x1 x2 => x1 ≤ x2) b a | null | false |
SemilinearIsometryEquivClass.mk | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {𝓕 : Type u_11} {R : outParam (Type u_12)} {R₂ : outParam (Type u_13)} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : outParam (R →+* R₂)} {σ₂₁ : outParam (R₂ →+* R)} [inst_2 : RingHomInvPair σ₁₂ σ₂₁]
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] {E : outParam (Type u_14)} {E₂ : outParam (Type u_15)}
[inst_4 : Seminorm... | null | true |
ContDiffMapSupportedIn.instSMul | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {E : Type u_2} →
{F : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
{R : Type u_5} →
[inst_4 ... | null | true |
Lean.Expr.foldRelevantConstants | Lean.LibrarySuggestions.Basic | {α : Type} → Lean.Expr → α → (Lean.Name → α → Lean.MetaM α) → Lean.MetaM α | Apply `f` to every constant occurring in `e` once, skipping instance arguments and proofs. | true |
StieltjesFunction.measure_univ | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R] [Nonempty R] {l u : ℝ},
Filter.Tendsto (↑f) ... | null | true |
NormedField.instRankOneNNRealValuation._proof_4 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {K : Type u_1} [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K], NormedField.valuation.IsNontrivial | null | false |
Lean.ParseImports.keyword | Lean.Elab.ParseImportsFast | String → Lean.ParseImports.Parser | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.letExpr._regBuiltin.Lean.Parser.Term.letExpr.formatter_7 | Lean.Parser.Term | IO Unit | null | false |
Subalgebra.involutiveStar._proof_11 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] (S : Subalgebra R A),
{
carrier :=
star
{ carrier := star S.carrier, mul_mem' := ⋯, one_mem' := ⋯, add_mem' := ⋯, zero_me... | null | false |
StieltjesFunction.instModuleNNReal._proof_5 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : NNReal), x • 0 = 0 | null | false |
Std.Http.Protocol.H1.Writer.isComplete | Std.Http.Protocol.H1.Writer | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Writer dir → Bool | Checks if the writer has completed processing a request.
| true |
BoundedOrder.noConfusionType | Mathlib.Order.BoundedOrder.Basic | Sort u_1 → {α : Type u} → [inst : LE α] → BoundedOrder α → {α' : Type u} → [inst' : LE α'] → BoundedOrder α' → Sort u_1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.