name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Elab.Tactic.Omega.MinNatAbs.0.Lean.Elab.Tactic.Omega.List.nonzeroMinimum_eq_zero_iff._simp_1_3 | Lean.Elab.Tactic.Omega.MinNatAbs | ∀ {α : Type u_1} {xs : List α} [inst : Min α], (xs.min? = none) = (xs = []) | null | false |
SummableLocallyUniformly | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | {α : Type u_1} →
{β : Type u_2} → {ι : Type u_3} → [AddCommMonoid α] → (ι → β → α) → [UniformSpace α] → [TopologicalSpace β] → Prop | `SummableLocallyUniformly f` means that `∑' i, f i b` converges locally
uniformly to something. | true |
instModuleKaehlerDifferentialOfSMulCommClass._proof_6 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {R' : Type u_3}
[inst_3 : CommRing R'] [inst_4 : Algebra R' S] [inst_5 : SMulCommClass R R' S] (x : Ω[S⁄R]), 0 • x = 0 | null | false |
PNat.coe_toPNat' | Mathlib.Data.PNat.Defs | ∀ (n : ℕ+), (↑n).toPNat' = n | null | true |
Mathlib.Tactic.PNatToNat.tacticPnat_positivity | Mathlib.Tactic.PNatToNat | Lean.ParserDescr | For each `x : PNat` in the context, add the hypothesis `0 < (↑x : ℕ)`. | true |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_10 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (res : Lean.Name) (acc : String) (ucount : ℕ) (hp₀ : ¬p₀ = s.endPos),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun p res => PSigma.casesOn res fun res n => p) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun p res => p) fun _x ... | null | false |
Order.isPredPrelimitRecOn._proof_3 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_2} (b : α) {motive : α → Sort u_1} [inst : PartialOrder α] [inst_1 : PredOrder α]
(hb : ¬Order.IsPredPrelimit b), motive (Order.pred (Classical.choose ⋯)) = motive b | null | false |
Lean.Parser.Tactic.Doc.tacticAlternativeExt | Lean.Parser.Tactic.Doc | Lean.PersistentEnvExtension (Lean.Name × Lean.Name) (Lean.Name × Lean.Name) (Lean.NameMap Lean.Name) | Stores a collection of *tactic alternatives*, to track which new syntax rules represent new forms of
existing tactics.
| true |
Std.DTreeMap.Internal.Const.RicSliceData.range | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {β : Type v} → [inst : Ord α] → Std.DTreeMap.Internal.Const.RicSliceData α β → Std.Ric α | null | true |
MeasurableSpace.comap_bot | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {g : β → α}, MeasurableSpace.comap g ⊥ = ⊥ | null | true |
ComplementedLattice.instOrderDual | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] [ComplementedLattice α], ComplementedLattice αᵒᵈ | null | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_mul_Ico_le_integral_of_monotone_antitone._proof_1_5 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), ↑a ≤ ↑i ∧ ↑i + 1 ≤ ↑b → ↑i ≤ ↑b - 1 | null | false |
AlgebraicGeometry.Proj.basicOpenIsoSpec._proof_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {σ : Type u_2} {A : Type u_1} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (f : A) {m : ℕ},
f ∈ 𝒜 m → 0 < m → CategoryTheory.IsIso (AlgebraicGeometry.Proj.basicOpenToSpec 𝒜 f) | null | false |
_private.Mathlib.Analysis.Analytic.IsolatedZeros.0.AnalyticOnNhd.eqOn_or_eventually_ne_of_preconnected._simp_1_1 | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Lean.Constructor.noConfusionType | Lean.Declaration | Sort u → Lean.Constructor → Lean.Constructor → Sort u | null | false |
Matrix.cramer_apply | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A : Matrix n n α)
(b : n → α) (i : n), A.cramer b i = (A.updateCol i b).det | null | true |
IsUniformAddGroup.cauchy_iff_tendsto_swapped | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {G : Type u_4} [inst : AddGroup G] [inst_1 : UniformSpace G] [IsUniformAddGroup G] (𝓕 : Filter G),
Cauchy 𝓕 ↔ 𝓕.NeBot ∧ Filter.Tendsto (fun p => p.2 - p.1) (𝓕 ×ˢ 𝓕) (nhds 0) | null | true |
Float.isNaN | Init.Data.Float.Float | Float → Bool | Checks whether a floating point number is a `NaN` (“not a number”) value.
`NaN` values result from operations that might otherwise be errors, such as dividing zero by zero.
This function returns `true` if and only if the input is propositionally equal to `Float.nan`.
This function has a logical model in terms of `Fl... | true |
Set.preimage_div_const_Iio | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b : α),
(fun x => x / a) ⁻¹' Set.Iio b = Set.Iio (b * a) | null | true |
CategoryTheory.Functor.Elements.CreatesLimitsAux.liftedConeElement._proof_2 | Mathlib.CategoryTheory.Limits.Elements | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {A : CategoryTheory.Functor C (Type u_5)} {I : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} I] (F : CategoryTheory.Functor I A.Elements)
[CategoryTheory.Limits.HasLimitsOfShape I C],
CategoryTheory.Limits.HasLimit (F.comp (CategoryTheory.Fun... | null | false |
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functor.congr_simp | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {G G_1 : C} (e_G : G = G_1) [inst_1 : CategoryTheory.Abelian C]
(hG : CategoryTheory.IsSeparator G) {X : C} [inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C]
(A₀ A₀_1 : CategoryTheory.Subobject X),
A₀ = A₀_1 →
∀ (J : Type w) [inst_3 : LinearOr... | null | true |
Lean.Lsp.instToJsonCodeActionLiteralSupportValueSet.toJson | Lean.Data.Lsp.CodeActions | Lean.Lsp.CodeActionLiteralSupportValueSet → Lean.Json | null | true |
selfAdjoint.instMulSubtypeMemAddSubgroup._proof_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonUnitalCommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), IsSelfAdjoint (↑x * ↑y) | null | false |
Lean.MonadStateCacheT.instMonadFinally._aux_1 | Lean.Util.MonadCache | {α β : Type} →
{m : Type → Type} →
[inst : BEq α] →
[inst_1 : Hashable α] →
[Monad m] →
[MonadFinally m] →
{α_1 β_1 : Type} →
Lean.MonadStateCacheT α β m α_1 →
(Option α_1 → Lean.MonadStateCacheT α β m β_1) → Lean.MonadStateCacheT α β m (α_1 × β_1) | null | false |
MeasureTheory.Measure.IsAddHaarMeasure.toIsFiniteMeasureOnCompacts | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_3} {inst : AddGroup G} {inst_1 : TopologicalSpace G} {inst_2 : MeasurableSpace G}
{μ : MeasureTheory.Measure G} [self : μ.IsAddHaarMeasure], MeasureTheory.IsFiniteMeasureOnCompacts μ | null | true |
_private.Batteries.Linter.UnnecessarySeqFocus.0.Batteries.Linter.UnnecessarySeqFocus.unnecessarySeqFocusLinter.match_3 | Batteries.Linter.UnnecessarySeqFocus | (motive : Lean.Syntax.Range × Lean.Syntax → Sort u_1) →
(x : Lean.Syntax.Range × Lean.Syntax) → ((r : Lean.Syntax.Range) → (stx : Lean.Syntax) → motive (r, stx)) → motive x | null | false |
Std.ExtDHashMap.get!_inter_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} [inst_1 : Inhabited (β k)], k ∉ m₁ → (m₁ ∩ m₂).get! k = default | null | true |
MulOpposite.isCancelMulZero_iff._simp_1 | Mathlib.Algebra.GroupWithZero.Opposite | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α], IsCancelMulZero αᵐᵒᵖ = IsCancelMulZero α | null | false |
CategoryTheory.Abelian.AbelianStruct.mk.sizeOf_spec | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{f : X ⟶ Y} [inst_2 : SizeOf C] (kernelFork : CategoryTheory.Limits.KernelFork f)
(isLimitKernelFork : CategoryTheory.Limits.IsLimit kernelFork)
(cokernelCofork : CategoryTheory.Limits.CokernelCofork f... | null | true |
Matrix.RowEquivalent.setoid._proof_1 | Mathlib.LinearAlgebra.Matrix.ElementaryRowOperations | ∀ {R : Type u_1} {m : Type u_2} {n : Type u_3} [inst : DecidableEq m] [inst_1 : CommRing R] [inst_2 : Fintype m],
Equivalence Matrix.RowEquivalent | null | false |
Matrix.IsAdjMatrix.zero_or_one._autoParam | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | Lean.Syntax | null | false |
instFieldGaloisField._proof_26 | Mathlib.FieldTheory.Finite.GaloisField | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (n : ℕ) (a b c : GaloisField p n), a * (b + c) = a * b + a * c | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.RingInverseOrder.0.CStarAlgebra.convexOn_ringInverse._proof_1_5 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.RingInverseOrder | ∀ {A : Type u_1} [inst : CStarAlgebra A], SeparatelyContinuousMul A | null | false |
Finset.Nontrivial.nsmul._f | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddCancelMonoid α] {s : Finset α},
s.Nontrivial → ∀ (x : ℕ) (f : Nat.below (motive := fun x => x ≠ 0 → (x • s).Nontrivial) x), x ≠ 0 → (x • s).Nontrivial | null | false |
CategoryTheory.Limits.Cofork.ext.congr_simp | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : X ⟶ Y}
{s t : CategoryTheory.Limits.Cofork f g} (i i_1 : s.pt ≅ t.pt) (e_i : i = i_1)
(w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π),
CategoryTheory.Limits.Cofork.ext i w = CategoryTheory.Limits.Cofork.ext i_1 ⋯ | null | true |
le_sdiff_right._simp_1 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], (x ≤ y \ x) = (x = ⊥) | null | false |
MulOpposite.instStarOrderedRing | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : StarRing R] [inst_2 : PartialOrder R] [StarOrderedRing R],
StarOrderedRing Rᵐᵒᵖ | null | true |
_private.Mathlib.Combinatorics.Configuration.0.Configuration.HasLines.card_le._simp_1_3 | Mathlib.Combinatorics.Configuration | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
Denumerable.ofEquiv._proof_1 | Mathlib.Basic.Denumerable | ∀ (α : Type u_2) {β : Type u_1} [inst : Denumerable α] (e : β ≃ α) (n : ℕ),
∃ a ∈ Encodable.decode n, Encodable.encode a = n | null | false |
HomogeneousSubsemiring.mk | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Subsemiring | {ι : Type u_1} →
{σ : Type u_2} →
{A : Type u_3} →
[inst : AddMonoid ι] →
[inst_1 : Semiring A] →
[inst_2 : SetLike σ A] →
[inst_3 : AddSubmonoidClass σ A] →
{𝒜 : ι → σ} →
[inst_4 : DecidableEq ι] →
[inst_5 : GradedRing 𝒜] →
... | null | true |
locallyFinite_Icc_of_tendsto | Mathlib.Topology.Order.AtTopBotIxx | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X] {α : Type u_2}
[inst_3 : LinearOrder α] [LocallyFiniteOrder α] [NoMaxOrder X] [NoMinOrder X] {f g : α → X},
Filter.Tendsto f Filter.atTop Filter.atTop →
Filter.Tendsto g Filter.atBot Filter.atBot → LocallyFinite fun n => Set... | A family of closed intervals bounded by diverging limits is locally finite. | true |
PhragmenLindelof.eq_zero_on_horizontal_strip | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {a b : ℝ} {f : ℂ → E},
DiffContOnCl ℂ f (Complex.im ⁻¹' Set.Ioo a b) →
(∃ c < Real.pi / (b - a),
∃ B,
f =O[Filter.comap (abs ∘ Complex.re) Filter.atTop ⊓ Filter.principal (Complex.im ⁻¹' Set.Ioo a b)] fun z =>
... | **Phragmen-Lindelöf principle** in a strip `U = {z : ℂ | a < im z < b}`.
Let `f : ℂ → E` be a function such that
* `f` is differentiable on `U` and is continuous on its closure;
* `‖f z‖` is bounded from above by `A * exp(B * exp(c * |re z|))` on `U` for some `c < π / (b - a)`;
* `f z = 0` on the boundary of `U`.
The... | true |
_private.Mathlib.Data.Fin.Tuple.NatAntidiagonal.0.List.Nat.antidiagonalTuple_pairwise_pi_lex._simp_1_12 | Mathlib.Data.Fin.Tuple.NatAntidiagonal | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | null | false |
Lean.Elab.Do.SavedState._sizeOf_1 | Lean.Elab.Do.Basic | Lean.Elab.Do.SavedState → ℕ | null | false |
CategoryTheory.Limits.Cofork.isColimitCoforkPushoutEquivIsColimitForkUnopPullback._proof_12 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : Cᵒᵖ} {f : X ⟶ Y}, f.unop = f.unop | null | false |
AddSubmonoid.addGroupMultiples._proof_5 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : AddMonoid M] {x : M} {n : ℕ},
n • x = 0 → ∀ (m : ℕ) (x_1 : ↥(AddSubmonoid.multiples x)), ↑(↑m.succ • x_1) = ↑(↑m • x_1 + x_1) | null | false |
HomologicalComplex.opcyclesMap_comp_descOpcycles | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {K L : HomologicalComplex C c} {i : ι} [inst_2 : K.HasHomology i]
[inst_3 : L.HasHomology i] {A : C} (k : L.X i ⟶ A) (j : ι) (hj : c.prev i = j)
(hk : CategoryTheo... | null | true |
invMonoidHom._proof_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α], 1⁻¹ = 1 | null | false |
List.foldrRecOn_cons | Init.Data.List.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {b : β} {x : α} {l : List α} {motive : β → Sort u_3} {op : α → β → β} (hb : motive b)
(hl : (b : β) → motive b → (a : α) → a ∈ x :: l → motive (op a b)),
List.foldrRecOn (x :: l) op hb hl = hl (List.foldr op b l) (List.foldrRecOn l op hb fun b c a m => hl b c a ⋯) x ⋯ | null | true |
Lean.Grind.OrderedRing.mul_le_mul_of_nonneg_right | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [inst_3 : Std.IsPartialOrder R]
[Lean.Grind.OrderedRing R] [Std.LawfulOrderLT R] {a b c : R}, a ≤ b → 0 ≤ c → a * c ≤ b * c | null | true |
Set.inter_diff_distrib_right | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (s t u : Set α), s \ t ∩ u = (s ∩ u) \ (t ∩ u) | **Alias** of `Set.inter_sdiff_distrib_right`. | true |
LinearEquiv.det_trans | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f g : M ≃ₗ[R] M),
LinearEquiv.det (f ≪≫ₗ g) = LinearEquiv.det g * LinearEquiv.det f | null | true |
AlgebraicGeometry.PresheafedSpace.stalkMap.congr_point | Mathlib.Geometry.RingedSpace.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C]
{X Y : AlgebraicGeometry.PresheafedSpace C} (α : X ⟶ Y) (x x' : ↑↑X) (h : x = x'),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.PresheafedSpace.Hom.stalkMap α x) (CategoryTheory.eqToHom ⋯) =
Category... | null | true |
Lean.Elab.Tactic.Try.Ctx.ctorIdx | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.Ctx → ℕ | null | false |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.isNilpotent_iff._simp_1_2 | Mathlib.Algebra.Lie.Nilpotent | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = (↑p = ↑q) | null | false |
Nat.filter_dvd_eq_properDivisors | Mathlib.NumberTheory.Divisors | ∀ {n : ℕ}, n ≠ 0 → {d ∈ Finset.range n | d ∣ n} = n.properDivisors | null | true |
CategoryTheory.Abelian.SpectralObject.isZero₂_of_isFirstQuadrant | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Y : CategoryTheory.Abelian.SpectralObject C EInt) [Y.IsFirstQuadrant] (i j : EInt) (hij : i ≤ j) (n : ℤ),
WithBotTop.coe n < i →
CategoryTheory.Limits.IsZero ((Y.H n).obj (CategoryTheory.ComposableArrows.mk₁ (Cat... | null | true |
SimpleGraph.ConnectedComponent.Represents.ncard_eq | Mathlib.Combinatorics.SimpleGraph.Connectivity.Represents | ∀ {V : Type u} {G : SimpleGraph V} {C : Set G.ConnectedComponent} {s : Set V},
SimpleGraph.ConnectedComponent.Represents s C → s.ncard = C.ncard | null | true |
map_extChartAt_nhds_of_boundaryless | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] [I.Boundaryless] (x : M),
Filter.map ... | null | true |
Lean.Elab.Command.instHashableAssertExists.hash | Lean.Elab.AssertExists | Lean.Elab.Command.AssertExists → UInt64 | null | true |
Std.Sat.AIG.RelabelNat.State.Inv2.brecOn | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {decls : Array (Std.Sat.AIG.Decl α)}
{motive : (a : ℕ) → (a_1 : Std.HashMap α ℕ) → Std.Sat.AIG.RelabelNat.State.Inv2 decls a a_1 → Prop} {a : ℕ}
{a_1 : Std.HashMap α ℕ} (t : Std.Sat.AIG.RelabelNat.State.Inv2 decls a a_1),
(∀ (a : ℕ) (a_2 : Std.HashMap α ℕ)... | null | true |
Polynomial.Separable.eq_1 | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] (f : Polynomial R), f.Separable = IsCoprime f (Polynomial.derivative f) | null | true |
Std.DTreeMap.Internal.Impl.insertManyIfNew._proof_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α β) (h : t.Balanced)
(__s : t.IteratedNewInsertionInto) (a : α) (b : β a) {P : Std.DTreeMap.Internal.Impl α β → Prop},
P t →
(∀ (t'' : Std.DTreeMap.Internal.Impl α β) (a : α) (b : β a) (h : t''.Balanced),
P t'' → P (Std.... | null | false |
Int.quotientZMultiplesEquivZMod._proof_2 | Mathlib.Data.ZMod.QuotientGroup | ∀ (a : ℤ), (AddSubgroup.zmultiples ↑a.natAbs).Normal | null | false |
instOrOpUInt32 | Init.Data.UInt.Basic | OrOp UInt32 | null | true |
TopologicalSpace.IsCompletelyMetrizableSpace.mk | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {X : Type u_3} [t : TopologicalSpace X],
(∃ m, PseudoMetricSpace.toUniformSpace.toTopologicalSpace = t ∧ CompleteSpace X) →
TopologicalSpace.IsCompletelyMetrizableSpace X | null | true |
Matroid.«_aux_Mathlib_Combinatorics_Matroid_Minor_Restrict___macroRules_Matroid_term_≤r__1» | Mathlib.Combinatorics.Matroid.Minor.Restrict | Lean.Macro | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_eq_iff_of_getLsbD_false._proof_1_10 | Init.Data.BitVec.Lemmas | ∀ (n j : ℕ), j ≤ n + 1 → ¬j = n + 1 → ¬j ≤ n → False | null | false |
PolynomialModule.coeffLinearEquiv_apply | Mathlib.Algebra.Polynomial.Module.Basic | ∀ (R : Type u_2) {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Type u_5)
[inst_3 : CommSemiring S] [inst_4 : Module S M] (a : PolynomialModule R M),
(PolynomialModule.coeffLinearEquiv R S) a = a.coeff | null | true |
SSet.Subcomplex.N._sizeOf_inst | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | {X : SSet} → (A : X.Subcomplex) → SizeOf A.N | null | false |
IsCoatomistic.recOn | Mathlib.Order.Atoms | {α : Type u_2} →
[inst : PartialOrder α] →
[inst_1 : OrderTop α] →
{motive : IsCoatomistic α → Sort u} →
(t : IsCoatomistic α) →
((isGLB_coatoms : ∀ (b : α), ∃ s, IsGLB s b ∧ ∀ a ∈ s, IsCoatom a) → motive ⋯) → motive t | null | false |
Matrix.IsHadamard.mul_conjTranspose | Mathlib.LinearAlgebra.Matrix.HadamardMatrix | ∀ {n : Type u_2} {R : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R] [inst_3 : StarRing R]
{A : Matrix n n R}, A.IsHadamard → A * A.conjTranspose = ↑(Fintype.card n) • 1 | null | true |
Int.toList_rcc_succ_succ | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, (m + 1...=n + 1).toList = List.map (fun x => x + 1) (m...=n).toList | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CFC.nnrpow_sqrt_two._simp_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ) [inst_2 : n.AtLeastTwo], (OfNat.ofNat n = 0) = False | null | false |
DistribMulActionHom.inverse.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {A : Type u_4} [inst_1 : AddMonoid A] [inst_2 : DistribMulAction M A] {B₁ : Type u_6}
[inst_3 : AddMonoid B₁] [inst_4 : DistribMulAction 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 := g, map_... | null | true |
DFinsupp.zipWith_apply | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [inst : (i : ι) → Zero (β i)]
[inst_1 : (i : ι) → Zero (β₁ i)] [inst_2 : (i : ι) → Zero (β₂ i)] (f : (i : ι) → β₁ i → β₂ i → β i)
(hf : ∀ (i : ι), f i 0 0 = 0) (g₁ : Π₀ (i : ι), β₁ i) (g₂ : Π₀ (i : ι), β₂ i) (i : ι),
(DFinsupp.zipWith f hf g₁ g... | null | true |
HasDerivAt.tendsto_slope | Mathlib.Analysis.Calculus.Deriv.Slope | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜},
HasDerivAt f f' x → Filter.Tendsto (slope f x) (nhdsWithin x {x}ᶜ) (nhds f') | **Alias** of the forward direction of `hasDerivAt_iff_tendsto_slope`. | true |
ForInStep.done.noConfusion | Init.Core | {α : Type u} → {P : Sort u_1} → {a a' : α} → ForInStep.done a = ForInStep.done a' → (a ≍ a' → P) → P | null | false |
Lean.Compiler.CSimp.State.rec | Lean.Compiler.CSimpAttr | {motive : Lean.Compiler.CSimp.State → Sort u} →
((map : Lean.SMap Lean.Name Lean.Compiler.CSimp.Entry) →
(thmNames : Lean.SSet Lean.Name) → motive { map := map, thmNames := thmNames }) →
(t : Lean.Compiler.CSimp.State) → motive t | null | false |
CategoryTheory.Limits.Cone.category._proof_3 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor J C}
{X Y Z : CategoryTheory.Limits.Cone F} (f : CategoryTheory.Limits.ConeMorphism X Y)
(g : CategoryTheory.Limits.ConeMorphism Y Z) (j : J),
CategoryTheory.... | null | false |
Std.DHashMap.isEmpty_inter_comm | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α], (m₁ ∩ m₂).isEmpty = (m₂ ∩ m₁).isEmpty | null | true |
Valuation.Integers.mem_of_integral | Mathlib.RingTheory.Valuation.Integral | ∀ {R : Type u} {Γ₀ : Type v} [inst : CommRing R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation R Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O R], v.Integers O → ∀ {x : R}, IsIntegral O x → x ∈ v.integer | null | true |
CategoryTheory.ShortComplex.isIso_iCycles | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology], S.g = 0 → CategoryTheory.IsIso S.iCycles | null | true |
meromorphicOrderAt_comp_add_const_eq_meromorphicOrderAt | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x c : 𝕜} {f : 𝕜 → E},
meromorphicOrderAt (f ∘ fun x => x + c) x = meromorphicOrderAt f (x + c) | `meromorphicOrderAt` is invariant under translation. | true |
String.Slice.Pos.nextn_add_one | Init.Data.String.Lemmas.Basic | ∀ {n : ℕ} {s : String.Slice} {p : s.Pos}, p.nextn (n + 1) = if h : p = s.endPos then p else (p.next h).nextn n | null | true |
_private.Init.Data.List.MinMaxOn.0.List.maxOn_append._simp_1_3 | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} {le : LE α} {a b : α}, (a ≤ b) = (b ≤ a) | null | false |
MultilinearMap.coe_currySumEquiv_symm | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {ι : Type uι} {ι' : Type uι'} {M₂ : Type v₂} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : Module R M₂] {N : ι ⊕ ι' → Type u_1} [inst_3 : (i : ι ⊕ ι') → AddCommMonoid (N i)]
[inst_4 : (i : ι ⊕ ι') → Module R (N i)], ⇑MultilinearMap.currySumEquiv.symm = MultilinearMap.uncurrySum | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Sorted | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {basis : Tactic.ComputeAsymptotics.Basis} → Tactic.ComputeAsymptotics.MultiseriesExpansion basis → Prop | A multiseries `ms` is `Sorted` when the exponents at each of its levels are sorted. | true |
RestrictedProduct.instCommMonoidCoeOfSubmonoidClass._proof_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_3} (R : ι → Type u_2) {S : ι → Type u_1} [inst : (i : ι) → SetLike (S i) (R i)]
[inst_1 : (i : ι) → CommMonoid (R i)] [∀ (i : ι), SubmonoidClass (S i) (R i)] (i : ι), OneMemClass (S i) (R i) | null | false |
Std.ExtTreeMap.minKeyD_erase_eq_of_not_compare_minKeyD_eq | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k fallback : α},
t.erase k ≠ ∅ → ¬cmp k (t.minKeyD fallback) = Ordering.eq → (t.erase k).minKeyD fallback = t.minKeyD fallback | null | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.Hom.ext_iff | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{u₂, u₁} C} {inst_1 : CategoryTheory.GaloisCategory C}
{F : CategoryTheory.Functor C FintypeCat} {A B : CategoryTheory.PreGaloisCategory.PointedGaloisObject F}
{x y : A.Hom B}, x = y ↔ x.val = y.val | null | true |
CategoryTheory.Pseudofunctor.Grothendieck.categoryStruct_comp_fiber | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} {X x x_1 : F.Grothendieck}
(f : X.Hom x) (g : x.Hom x_1),
(CategoryTheory.CategoryStruct.comp f g).fiber =
CategoryTheory.CategoryStruct.comp ((F.mapComp f.ba... | null | true |
WithLp.map_comp | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) {V : Type u_4} {V' : Type u_5} {V'' : Type u_6} (f : V' → V'') (g : V → V'),
WithLp.map p (f ∘ g) = WithLp.map p f ∘ WithLp.map p g | null | true |
Lean.Meta.Grind.EMatchTheoremKind.casesOn | Lean.Meta.Tactic.Grind.Extension | {motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremKind) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.... | null | false |
_private.Mathlib.RingTheory.HopkinsLevitzki.0.IsSemiprimaryRing.finite_of_isNoetherian_or_isArtinian._proof_1_1 | Mathlib.RingTheory.HopkinsLevitzki | 2 ≠ 0 | null | false |
Std.TreeMap.size_left_le_size_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
t₁.size ≤ (t₁ ∪ t₂).size | null | true |
List.Perm.filterMap | Init.Data.List.Perm | ∀ {α : Type u_1} {β : Type u_2} (f : α → Option β) {l₁ l₂ : List α},
l₁.Perm l₂ → (List.filterMap f l₁).Perm (List.filterMap f l₂) | null | true |
_private.Mathlib.LinearAlgebra.Multilinear.DFinsupp.0.MultilinearMap.dfinsuppFamily._simp_2 | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {α : Type u_1} [inst : DecidableEq α] {β : α → Type u_2} (m : Multiset α) (t : (a : α) → Multiset (β a))
(f : (a : α) → a ∈ m → β a), (f ∈ m.pi t) = ∀ (a : α) (h : a ∈ m), f a h ∈ t a | null | false |
sdiff_le_inf_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, b \ a ≤ b ⊓ ￢a | null | true |
addUnitsCenterToCenterAddUnits.eq_1 | Mathlib.GroupTheory.Submonoid.Center | ∀ (M : Type u_1) [inst : AddMonoid M],
addUnitsCenterToCenterAddUnits M =
(AddUnits.map (AddSubmonoid.center M).subtype).codRestrict (AddSubmonoid.center (AddUnits M)) ⋯ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.