name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Ideal.exists_finset_card_eq_height_of_isNoetherianRing | Mathlib.RingTheory.Ideal.KrullsHeightTheorem | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] (p : Ideal R) [p.IsPrime],
∃ s, p ∈ (Ideal.span ↑s).minimalPrimes ∧ ↑s.card = p.height | If `p` is a prime in a Noetherian ring `R`, there exists a `p`-primary ideal `I`
spanned by `p.height` elements. | true |
_private.Mathlib.Data.Fin.Tuple.Finset.0.Fin.mem_piFinset_iff_last_init._simp_1_2 | Mathlib.Data.Fin.Tuple.Finset | ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∀ (i : Fin (n + 1)), P i) = ((∀ (i : Fin n), P i.castSucc) ∧ P (Fin.last n)) | null | false |
Mathlib.Tactic.Widget.StringDiagram.PenroseVar.indices | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.PenroseVar → List ℕ | The indices of the variable. | true |
Lean.Meta.NormCast.NormCastExtension.up | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.NormCastExtension → Lean.Meta.SimpExtension | A simp set which lifts coercions to the top level. | true |
CategoryTheory.Localization.Lifting | Mathlib.CategoryTheory.Localization.Predicate | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{E : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
CategoryTheory.Functor C D →
CategoryTheory.MorphismProperty C →
... | When `L : C ⥤ D` is a localization functor for `W : MorphismProperty C` and
`F : C ⥤ E` is a functor, we shall say that `F' : D ⥤ E` lifts `F` if the obvious diagram
is commutative up to an isomorphism. | true |
Std.Async.MaybeTask.ctorElimType | Std.Async.Basic | {α : Type} → {motive : Std.Async.MaybeTask α → Sort u} → ℕ → Sort (max 1 u) | null | false |
CategoryTheory.MorphismProperty.HasRightCalculusOfFractions.exists_rightFraction | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {W : CategoryTheory.MorphismProperty C}
[self : W.HasRightCalculusOfFractions] ⦃X Y : C⦄ (φ : W.LeftFraction X Y),
∃ ψ, CategoryTheory.CategoryStruct.comp ψ.s φ.f = CategoryTheory.CategoryStruct.comp ψ.f φ.s | null | true |
CategoryTheory.Limits.prod.inl.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
[inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y],
CategoryTheory.Limits.prod.inl X Y = CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X) 0 | null | true |
Nat.succ_injective | Mathlib.Data.Nat.Basic | Function.Injective Nat.succ | null | true |
_private.Mathlib.RingTheory.Localization.Away.Basic.0.IsLocalization.Away.map_injective_iff._simp_1_1 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {M : Type u_1} [inst : Monoid M] (x z : M), (x ∈ Submonoid.powers z) = ∃ n, z ^ n = x | null | false |
LinearMap.isBigOTVS_rev_comp | 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] {l : Filter α} {f : α → E} (g : E →ₗ[𝕜] F),
Filter.comap... | null | true |
CommMonCat.FilteredColimits.forget_preservesFilteredColimits | Mathlib.Algebra.Category.MonCat.FilteredColimits | CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget CommMonCat) | null | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processId._sparseCasesOn_1 | Lean.Elab.PatternVar | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (Lean.ConstantInfo.ctorInfo val)) →
(Nat.hasNotBit 64 t.ctorIdx → motive t) → motive t | null | false |
Complex.im_mul_ofReal | Mathlib.Basic.Complex.Basic | ∀ (z : ℂ) (r : ℝ), (z * ↑r).im = z.im * r | null | true |
ConvexOn.exists_lipschitzOnWith_of_isBounded | Mathlib.Analysis.Convex.Continuous | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x₀ : E} {r r' : ℝ},
ConvexOn ℝ (Metric.ball x₀ r) f →
r' < r → Bornology.IsBounded (f '' Metric.ball x₀ r) → ∃ K, LipschitzOnWith K f (Metric.ball x₀ r') | null | true |
_private.Mathlib.Analysis.Convex.Function.0.OrderIso.strictConvexOn_symm._simp_1_1 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u_1} [inst : LT α] {x y : α}, (x > y) = (y < x) | null | false |
CategoryTheory.Triangulated.SpectralObject.ω₂_map_hom₃ | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Addit... | null | true |
Pi.instBiheytingAlgebra._proof_1 | Mathlib.Order.Heyting.Basic | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → BiheytingAlgebra (α i)] (a b c : (i : ι) → α i),
a \ b ≤ c ↔ a ≤ b ⊔ c | null | false |
Interval.commMonoid._proof_5 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (a : Interval α), a * 1 = a | null | false |
jacobiSum_one_one | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {F : Type u_1} {R : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : CommRing R],
jacobiSum 1 1 = ↑(Fintype.card F) - 2 | If `1` is the trivial multiplicative character on a finite field `F`, then `J(1,1) = #F-2`. | true |
CategoryTheory.Equivalence.mapAddGrp_counitIso | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(e : C ≌ D) [inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal],
e.mapAddGrp.c... | null | true |
Nat.decidableForallFin._proof_1 | Init.Data.Nat.Lemmas | ∀ {n : ℕ} (P : Fin n → Prop), (∀ (k : ℕ) (h : k < n), P ⟨k, h⟩) ↔ ∀ (i : Fin n), P i | null | false |
ContinuousMap.compactConvergenceUniformSpace | Mathlib.Topology.UniformSpace.CompactConvergence | {α : Type u₁} → {β : Type u₂} → [inst : TopologicalSpace α] → [inst_1 : UniformSpace β] → UniformSpace C(α, β) | Uniform space structure on `C(α, β)`.
The uniformity comes from `α →ᵤ[{K | IsCompact K}] β` (i.e., `UniformOnFun α β {K | IsCompact K}`)
which defines topology of uniform convergence on compact sets.
We use `ContinuousMap.tendsto_iff_forall_isCompact_tendstoUniformlyOn`
to show that the induced topology agrees with th... | true |
IsStarNormal.neg | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] [inst_1 : StarAddMonoid R] {x : R} [IsStarNormal x], IsStarNormal (-x) | null | true |
Std.DTreeMap.Internal.Impl.insertMin.match_3.congr_eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} (motive : (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → Sort u_3)
(t : Std.DTreeMap.Internal.Impl α β) (hr : t.Balanced)
(h_1 : (hr : Std.DTreeMap.Internal.Impl.leaf.Balanced) → motive Std.DTreeMap.Internal.Impl.leaf hr)
(h_2 :
(sz : ℕ) →
(k' : α) →
(v' ... | null | true |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.einfsep_insert._simp_1_1 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Set α} {d : ENNReal}, (d ≤ s.einfsep) = ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ edist x y | null | false |
NNRat.cast_div_of_ne_zero | Mathlib.Data.Rat.Cast.Defs | ∀ {α : Type u_2} [inst : DivisionSemiring α] {q r : ℚ≥0}, ↑q.den ≠ 0 → ↑r.num ≠ 0 → ↑(q / r) = ↑q / ↑r | null | true |
List.minOn_append._proof_1 | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} {xs ys : List α}, xs ≠ [] → xs ++ ys ≠ [] | null | false |
norm_deriv_eq_norm_fderiv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, ‖deriv f x‖ = ‖fderiv 𝕜 f x‖ | null | true |
FreeGroup.Red.decidableRel._proof_3 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (x : α) (b : Bool) (tl : List (α × Bool)), FreeGroup.Red tl [(x, !b)] → FreeGroup.Red ((x, b) :: tl) [] | null | false |
RCLike.norm_coe_norm | Mathlib.Analysis.Normed.Module.RCLike.Basic | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] {z : E}, ‖↑‖z‖‖ = ‖z‖ | null | true |
_private.Init.Data.String.Lemmas.Intercalate.0.String.intercalate.go.eq_2 | Init.Data.String.Lemmas.Intercalate | ∀ (acc s : String), String.intercalate.go✝ acc s [] = acc | null | true |
FreeAddGroup.Red.Step.sublist | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)}, FreeAddGroup.Red.Step L₁ L₂ → L₂.Sublist L₁ | null | true |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.modify._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {β : Type u_2} (m : Std.DHashMap α fun x => β) (a : α) (f : β → β),
(↑(Std.DHashMap.Internal.Raw₀.Const.modify ⟨m.inner, ⋯⟩ a f)).WF | null | false |
MvPowerSeries.eq_inv_iff_mul_eq_one | Mathlib.RingTheory.MvPowerSeries.Inverse | ∀ {σ : Type u_1} {k : Type u_3} [inst : Field k] {φ ψ : MvPowerSeries σ k},
MvPowerSeries.constantCoeff ψ ≠ 0 → (φ = ψ⁻¹ ↔ φ * ψ = 1) | null | true |
Set.singleton_inter_of_notMem | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, a ∉ s → {a} ∩ s = ∅ | **Alias** of the reverse direction of `Set.singleton_inter_eq_empty`. | true |
Lean.Parser.Term.optIdent.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | null | true |
NumberField.mixedEmbedding.fundamentalCone.expMapBasis_nonneg | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.realSpace K)
(w : NumberField.InfinitePlace K), 0 ≤ ↑NumberField.mixedEmbedding.fundamentalCone.expMapBasis x w | null | true |
Batteries.BinomialHeap.Imp.FindMin.recOn | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{motive : Batteries.BinomialHeap.Imp.FindMin α → Sort u} →
(t : Batteries.BinomialHeap.Imp.FindMin α) →
((before : Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α) →
(val : α) →
(node : Batteries.BinomialHeap.Imp.HeapNode α) →
(next ... | null | false |
_private.Mathlib.Combinatorics.Enumerative.Partition.Glaisher.0.Nat.Partition.aux_mul_one_sub_X_pow._proof_1_2 | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | ∀ (R : Type u_1) [inst : CommRing R] {m : ℕ},
0 < m → ∀ (i : ↑(Function.mulSupport fun i => 1 - (PowerSeries.X ^ (i + 1)) ^ m)), (↑i + 1) * m - 1 + 1 = (↑i + 1) * m | null | false |
Pell.Solution₁.instCommGroup._proof_7 | Mathlib.NumberTheory.Pell | ∀ {d : ℤ} (a : Pell.Solution₁ d), a * 1 = a | null | false |
Lean.Grind.CommRing.Poly.cancelVar | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Var → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | true |
CategoryTheory.Pseudofunctor.DescentData'.instCategory._proof_2 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_5} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{sq₃ : (i₁ i₂ i₃ : ι) → CategoryT... | null | false |
ContMDiffWithinAt.change_section_trivialization | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_3} {M : Type u_4} {E : B → Type u_5}
[inst : NontriviallyNormedField 𝕜] {EB : Type u_6} [inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB]
{HB : Type u_7} [inst_3 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSp... | null | true |
MvPolynomial.monomial_zero' | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], ⇑(MvPolynomial.monomial 0) = ⇑MvPolynomial.C | null | true |
CategoryTheory.Profunctor.op | Mathlib.CategoryTheory.Profunctor.Basic | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
CategoryTheory.Profunctor.{w, v₁, v₂, u₁, u₂} C D → CategoryTheory.Profunctor.{w, v₂, v₁, u₂, u₁} Dᵒᵖ Cᵒᵖ | The opposite of a profunctor. | true |
supIrred_iff_not_isMin._simp_2 | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : LinearOrder α] {a : α}, SupIrred a = ¬IsMin a | null | false |
WittVector.succNthValUnits.congr_simp | Mathlib.RingTheory.WittVector.DiscreteValuationRing | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {k : Type u_1} [inst : CommRing k] [inst_1 : CharP k p] (n : ℕ) (a a_1 : kˣ),
a = a_1 →
∀ (A A_1 : WittVector p k),
A = A_1 →
∀ (bs bs_1 : Fin (n + 1) → k),
bs = bs_1 → WittVector.succNthValUnits n a A bs = WittVector.succNthValUnits n a_1 A_1 bs_1 | null | true |
Finset.measure_zero | Mathlib.MeasureTheory.Measure.Typeclasses.NullSingletonClass | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (s : Finset α) (μ : MeasureTheory.Measure α)
[MeasureTheory.NullSingletonClass μ], μ ↑s = 0 | null | true |
Lean.Meta.RefinedDiscrTree.Key.bvar | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ℕ → ℕ → Lean.Meta.RefinedDiscrTree.Key | A bound variable, from a lambda or forall binder.
It stores the De Bruijn index and the arity. | true |
Lean.Grind.AC.diseq_simp_rhs_ac | Init.Grind.AC | ∀ {α : Sort u_1} (ctx : Lean.Grind.AC.Context α) {inst₁ : Std.Associative ctx.op} {inst₂ : Std.Commutative ctx.op}
(c lhs₁ rhs₁ lhs₂ rhs₂ rhs₂' : Lean.Grind.AC.Seq),
Lean.Grind.AC.simp_ac_cert c lhs₁ rhs₁ rhs₂ rhs₂' = true →
Lean.Grind.AC.Seq.denote ctx lhs₁ = Lean.Grind.AC.Seq.denote ctx rhs₁ →
Lean.Grin... | null | true |
Lean.isInstanceReducibleCore | Lean.ReducibilityAttrs | Lean.Environment → Lean.Name → Bool | null | true |
MulEquiv.withOneCongr._proof_2 | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Mul β] (e : α ≃* β) (x : WithOne α),
(WithOne.mapMulHom e.symm.toMulHom) ((WithOne.mapMulHom e.toMulHom) x) = x | null | false |
ONote.zero.elim | Mathlib.SetTheory.Ordinal.Notation | {motive : ONote → Sort u} → (t : ONote) → t.ctorIdx = 0 → motive ONote.zero → motive t | null | false |
Std.ExtTreeMap.inter_eq_empty_comm | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp],
t₁ ∩ t₂ = ∅ ↔ t₂ ∩ t₁ = ∅ | null | true |
Con.lift | Mathlib.GroupTheory.Congruence.Hom | {M : Type u_1} →
{P : Type u_3} →
[inst : MulOneClass M] → [inst_1 : MulOneClass P] → (c : Con M) → (f : M →* P) → c ≤ Con.ker f → c.Quotient →* P | The homomorphism on the quotient of a monoid by a congruence relation `c` induced by a
homomorphism constant on `c`'s equivalence classes. | true |
TopologicalSpace.Closeds.noncompactSpace_iff._simp_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], NoncompactSpace (TopologicalSpace.Closeds α) = NoncompactSpace α | null | false |
Finsupp.add_closure_setOfPred_eq_single | Mathlib.Data.Finsupp.Ext | ∀ {α : Type u_1} {M : Type u_2} [inst : AddZeroClass M], AddSubmonoid.closure {f | ∃ a b, f = fun₀ | a => b} = ⊤ | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateLeft.go_get_aux._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft | ∀ {w : ℕ} (distance curr idx : ℕ), idx < curr → ¬idx < curr + 1 → False | null | false |
Int.mul_fmod_right | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).fmod a = 0 | null | true |
Lean.Parser.OrElseOnAntiquotBehavior.rec | Lean.Parser.Basic | {motive : Lean.Parser.OrElseOnAntiquotBehavior → Sort u} →
motive Lean.Parser.OrElseOnAntiquotBehavior.acceptLhs →
motive Lean.Parser.OrElseOnAntiquotBehavior.takeLongest →
motive Lean.Parser.OrElseOnAntiquotBehavior.merge → (t : Lean.Parser.OrElseOnAntiquotBehavior) → motive t | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.alterₘ.match_1.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_3} {β : α → Type u_1} (a : α) (motive : Option (β a) → Sort u_2) (b : β a) (h_1 : Unit → motive none)
(h_2 : (b : β a) → motive (some b)),
(match some b with
| none => h_1 ()
| some b => h_2 b) =
h_2 b | null | true |
Std.HashMap.getKey!_eq_getKeyD_default | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {a : α}, m.getKey! a = m.getKeyD a default | null | true |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.DetectState | Lean.Compiler.LCNF.SimpleGroundExpr | Type | null | true |
_private.Init.Data.List.Count.0.List.count_erase.match_1_1 | Init.Data.List.Count | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (_ : Unit), motive []) → (∀ (c : α) (l : List α), motive (c :: l)) → motive x | null | false |
LieModule.toEnd_eq_iff | Mathlib.Algebra.Lie.OfAssociative | ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[LieModule.IsFaithful R L M] {x y : L}, (LieModule.toEnd R L M) x = (LieModule.toEnd R L M) y ↔ x = y | null | true |
SSet.Subcomplex.PairingCore.index | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | {X : SSet} → {A : X.Subcomplex} → (self : A.PairingCore) → (s : self.ι) → Fin (self.dim s + 2) | the corresponding type (II) simplex is the `1`-codimensional
face given by this index | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_eq_default._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Int.two_dvd_mul_add_one | Mathlib.Algebra.Ring.Int.Parity | ∀ (k : ℤ), 2 ∣ k * (k + 1) | null | true |
_private.Mathlib.Topology.EMetricSpace.Basic.0.EMetric.totallyBounded_iff'.match_1_1 | Mathlib.Topology.EMetricSpace.Basic | ∀ {γ : Type u_1} [inst : PseudoEMetricSpace γ] {s : Set γ} (ε : ENNReal)
(motive : (∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, Metric.eball y ε) → Prop)
(x : ∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, Metric.eball y ε),
(∀ (t : Set γ) (left : t ⊆ s) (ft : t.Finite) (h : s ⊆ ⋃ y ∈ t, Metric.eball y ε), motive ⋯) → motive x | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.penultimate_mem_dropLast_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.support.getLast ⋯].isEmpty = true → p.support.dropLast ≠ [] | null | false |
Lean.Elab.Tactic.Omega.MetaProblem.ctorIdx | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.MetaProblem → ℕ | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.Basic.0.IsCyclic.monoidHomMulEquivRootsOfUnityOfGenerator._simp_2 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {G : Type u_1} [inst : Monoid G] {x : G} {n : ℕ}, (orderOf x ∣ n) = (x ^ n = 1) | null | false |
Order.krullDim_eq_iSup_length | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], Order.krullDim α = ↑(⨆ p, ↑p.length) | A definition of krullDim for nonempty `α` that avoids `WithBot` | true |
Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit._proof_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α fun x => Unit) (h : t.Balanced) (a : α)
(__s : Std.DTreeMap.Internal.Impl.Const.IteratedUnitInsertionInto t)
{P : (Std.DTreeMap.Internal.Impl α fun x => Unit) → Prop},
P t →
(∀ (t'' : Std.DTreeMap.Internal.Impl α fun x => Unit) (a : α) (h : t''... | null | false |
Vector.getElem_zero_flatten | Init.Data.Vector.Find | ∀ {α : Type u_1} {m n : ℕ} {xss : Vector (Vector α m) n} (h : 0 < n * m),
xss.flatten[0] = (Vector.findSome? (fun xs => xs[0]?) xss).get ⋯ | null | true |
MonoidHom.coeToMulHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N],
MonoidHom.coeToMulHom = { coe := MonoidHom.toMulHom } | null | true |
String.Pos.lt_of_lt_of_le | Init.Data.String.Basic | ∀ {s : String} {p q r : s.Pos}, p < q → q ≤ r → p < r | null | true |
Ideal.under_lt_under_of_integral_mem_sdiff | Mathlib.RingTheory.Ideal.GoingUp | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {I J : Ideal S} [inst_2 : Algebra R S]
[hI : I.IsPrime], I ≤ J → ∀ {x : S}, x ∈ ↑J \ ↑I → IsIntegral R x → Ideal.under R I < Ideal.under R J | null | true |
HomotopyCategory.instPretriangulatedIntUp | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[CategoryTheory.Limits.HasBinaryBiproducts C] →
[inst_3 : CategoryTheory.Limits.HasZeroObject C] →
CategoryTheory.Pretriangulated (HomotopyCategory C (ComplexShape.up ℤ)) | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.setInlineAttribute.match_1 | Lean.Meta.Basic | (motive : Except String Lean.Environment → Sort u_1) →
(x : Except String Lean.Environment) →
((env : Lean.Environment) → motive (Except.ok env)) → ((msg : String) → motive (Except.error msg)) → motive x | null | false |
_private.Mathlib.Analysis.InnerProductSpace.OfNorm.0.inner_._proof_1 | Mathlib.Analysis.InnerProductSpace.OfNorm | (3 + 1).AtLeastTwo | null | false |
summable_sigma_of_nonneg | Mathlib.Topology.Algebra.InfiniteSum.Real | ∀ {α : Type u_4} {β : α → Type u_3} {f : (x : α) × β x → ℝ},
(∀ (x : (x : α) × β x), 0 ≤ f x) →
(Summable f ↔ (∀ (x : α), Summable fun y => f ⟨x, y⟩) ∧ Summable fun x => ∑' (y : β x), f ⟨x, y⟩) | null | true |
Set.toFinset_empty | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_1} [inst : Fintype ↑∅], ∅.toFinset = ∅ | null | true |
Computability.instDecidableEqΓ'.decEq._proof_3 | Mathlib.Computability.Encoding | ∀ (b : Bool), ¬Computability.Γ'.blank = Computability.Γ'.bit b | null | false |
CompleteBooleanAlgebra.himp._inherited_default | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
(∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) →
(∀ (a b : α), le a b → le b a → a = b) →
(sup : α → α → α) →
(∀ (a b : α), le a (sup a b)) →
(∀ (... | null | false |
SSet.innerAnodyneExtensions_eq_llp_rlp | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Inner.Basic | SSet.innerAnodyneExtensions = SSet.innerHornInclusions.rlp.llp | null | true |
ClosedAddSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [AddGroup G] → [TopologicalSpace G] → Type u | The type of closed subgroups of an additive topological group. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{newWidth : ℕ} →
{aig : Std.Sat.AIG α} →
{w : ℕ} → aig.RefVec w → ℕ → (curr : ℕ) → curr ≤ newWidth → aig.RefVec curr → aig.RefVec newWidth | null | true |
_private.Mathlib.RingTheory.TensorProduct.Quotient.0.Algebra.TensorProduct.quotIdealMapEquivTensorQuot._simp_1 | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
Commute.tsum_left | Mathlib.Topology.Algebra.InfiniteSum.Ring | ∀ {ι : Type u_1} {α : Type u_3} {L : SummationFilter ι} [inst : NonUnitalNonAssocSemiring α]
[inst_1 : TopologicalSpace α] [IsTopologicalSemiring α] {f : ι → α} [T2Space α] [L.NeBot] (a : α),
(∀ (i : ι), Commute (f i) a) → Commute (∑'[L] (i : ι), f i) a | null | true |
Submodule.dualCoannihilator | Mathlib.LinearAlgebra.Dual.Defs | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Submodule R (Module.Dual R M) → Submodule R M | The `dualAnnihilator` of a submodule of the dual space pulled back along the evaluation map
`Module.Dual.eval`. | true |
MeasurableEmbedding.measurableSet_range | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β},
MeasurableEmbedding f → MeasurableSet (Set.range f) | null | true |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_neBot_iff_frequently._simp_1_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter β} {m : α → β}, (Filter.comap m f).NeBot = ∀ t ∈ f, ∃ a, m a ∈ t | null | false |
_private.Mathlib.CategoryTheory.Category.Pairwise.0.CategoryTheory.instFintypePairwise.match_5.eq_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ (ι : Type u_1) (motive : CategoryTheory.Pairwise ι → Sort u_2) (a a_1 : ι)
(h_1 : (a : ι) → motive (CategoryTheory.Pairwise.single a))
(h_2 : (a a_2 : ι) → motive (CategoryTheory.Pairwise.pair a a_2)),
(match CategoryTheory.Pairwise.pair a a_1 with
| CategoryTheory.Pairwise.single a => h_1 a
| CategoryT... | null | true |
Option.mem_pmem | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} (f : (a : α) → p a → β) (x : Option α) {a : α} (h : ∀ a ∈ x, p a)
(ha : a ∈ x), f a ⋯ ∈ Option.pmap f x h | null | true |
hasFPowerSeriesAt_clog_one | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | HasFPowerSeriesAt Complex.log (FormalMultilinearSeries.ofScalars ℂ fun n => -(-1) ^ n / ↑n) 1 | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.suggestionName.match_1 | Lean.Elab.DocString | (motive : Option Lean.Name → Sort u_1) →
(resolved? : Option Lean.Name) →
((resolved : Lean.Name) → motive (some resolved)) → (Unit → motive none) → motive resolved? | null | false |
Order.IsNormal.exists_map_le_lt_map_succ_of_exists_ge | Mathlib.Order.IsNormal | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [WellFoundedLT α] [inst_2 : SuccOrder α] [inst_3 : LinearOrder β]
[NoMaxOrder α] [inst_5 : OrderBot α] [WellFoundedLT β] {f : α → β} {x : β},
Order.IsNormal f → (∃ y, x ≤ f y) → f ⊥ ≤ x → ∃ a, f a ≤ x ∧ x < f (Order.succ a) | null | true |
AddSubgroup.dense_of_infDist_le | Mathlib.Analysis.Normed.Group.Lemmas | ∀ {G : Type u_2} [inst : SeminormedAddGroup G] (H : AddSubgroup G) (ε : ℝ),
0 < ε → ε < 1 → (∀ (g : G), Metric.infDist g ↑H ≤ ε * ‖g‖) → Dense ↑H | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.