name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
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 |
Finset.neg_mem_neg | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Neg α] {s : Finset α} {a : α}, a ∈ s → -a ∈ -s | null | 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).natMod ↑n • x_1) = ↑((↑m).natMod ↑n • x_1 + x_1) | null | false |
Filter.IsBoundedUnder.sup | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeSup α] {f : Filter β} {u v : β → α},
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u →
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f v → Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f fun a => u a ⊔ v a | null | true |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.SparseCasesOnKey.isPrivate | Lean.Meta.Constructions.SparseCasesOn | Lean.Meta.SparseCasesOnKey✝ → Bool | null | true |
Filter.HasBasis.inv | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : InvolutiveInv α] {f : Filter α} {ι : Sort u_7} {p : ι → Prop} {s : ι → Set α},
f.HasBasis p s → f⁻¹.HasBasis p fun i => (s i)⁻¹ | null | true |
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 |
Finset.add_univ_of_zero_mem | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {s : Finset α} [inst_2 : Fintype α],
0 ∈ s → s + Finset.univ = Finset.univ | null | true |
ContinuousOpenMap.casesOn | Mathlib.Topology.Hom.Open | {α : Type u_6} →
{β : Type u_7} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
{motive : (α →CO β) → Sort u} →
(t : α →CO β) →
((toContinuousMap : C(α, β)) →
(map_open' : IsOpenMap toContinuousMap.toFun) →
motive { toContinuous... | null | false |
mem_balancedHull_iff | Mathlib.Analysis.LocallyConvex.BalancedCoreHull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] {s : Set E} {x : E},
x ∈ balancedHull 𝕜 s ↔ ∃ r, ‖r‖ ≤ 1 ∧ x ∈ r • s | 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 |
IsValuativeTopology.hasBasis_nhds | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] [inst_2 : TopologicalSpace R] [IsValuativeTopology R]
(x : R), (nhds x).HasBasis (fun x => True) fun γ => {z | (ValuativeRel.valuation R) (z - x) < ↑γ} | null | true |
UniqueFactorizationMonoid.associated_iff_normalizedFactors_eq_normalizedFactors | Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] [inst_2 : UniqueFactorizationMonoid α]
{x y : α},
x ≠ 0 →
y ≠ 0 →
(Associated x y ↔ UniqueFactorizationMonoid.normalizedFactors x = UniqueFactorizationMonoid.normalizedFactors y) | 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 |
Matroid.cRk_map_image | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α β : Type u} {f : α → β} (M : Matroid α) (hf : Set.InjOn f M.E) (X : Set α),
autoParam (X ⊆ M.E) Matroid.cRk_map_image._auto_1 → (M.map f hf).cRk (f '' X) = M.cRk X | null | true |
Std.Internal.Parsec.ByteArray.octDigit | Std.Internal.Parsec.ByteArray | Std.Internal.Parsec.ByteArray.Parser Char | Parse an octal digit `0-7` as a `Char`.
| 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 |
Computation.recOn | Mathlib.Data.Seq.Computation | {α : Type u} →
{motive : Computation α → Sort v} →
(s : Computation α) → ((a : α) → motive (Computation.pure a)) → ((s : Computation α) → motive s.think) → motive s | Recursion principle for computations, compare with `List.recOn`. | 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 |
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.min.noConfusion | Mathlib.CategoryTheory.Filtered.Small | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{n : ℕ} →
{X : (k : ℕ) → k < n → (t : Type (max v w)) × (t → C)} →
{P : Sort u_1} →
{k k' : ℕ} →
{hk : k < n} →
{hk' : k' < n} →
{a : (X k hk).fst} →
{a_1 : (X k' hk').fst... | null | false |
CategoryTheory.MonoidalCategory.Limits.whiskerLeft_inl_comp_pushoutSymmetry_hom_assoc | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasPushouts C] {Q X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) {Z_1 : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj Q (CategoryTheory.Limits.pushout g f) ⟶ Z_1),
CategoryTheory.Cat... | null | true |
CategoryTheory.Discrete._aux_Mathlib_CategoryTheory_Discrete_Basic___macroRules_CategoryTheory_Discrete_tacticDiscrete_cases_1 | Mathlib.CategoryTheory.Discrete.Basic | Lean.Macro | A simple tactic to run `cases` on any `Discrete α` hypotheses. | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.Stained.name | Mathlib.Tactic.Linter.FlexibleLinter | Lean.Name → Mathlib.Linter.Flexible.Stained✝ | null | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion.0.Tactic.ComputeAsymptotics.Seq.dist_le_half_iff._proof_1_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | (1 + 1).AtLeastTwo | null | false |
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 |
norm_inner_eq_norm_iff | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x y : E}, x ≠ 0 → y ≠ 0 → (‖inner 𝕜 x y‖ = ‖x‖ * ‖y‖ ↔ ∃ r, r ≠ 0 ∧ y = r • x) | If the inner product of two vectors is equal to the product of their norms, then the two vectors
are multiples of each other. One form of the equality case for Cauchy-Schwarz.
Compare `inner_eq_norm_mul_iff`, which takes the stronger hypothesis `⟪x, y⟫ = ‖x‖ * ‖y‖`. | true |
CategoryTheory.Functor.LeibnizAdjunction.adj_unit_app_right | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃))
(G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)) ... | 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 |
autAdjoinRootXPowSubCEquiv.eq_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u} [inst : Field K] {n : ℕ} (hζ : (primitiveRoots n K).Nonempty) {a : K}
(H : Irreducible (Polynomial.X ^ n - Polynomial.C a)) [inst_1 : NeZero n],
autAdjoinRootXPowSubCEquiv hζ H =
{ toFun := (↑(autAdjoinRootXPowSubC n a)).toFun, invFun := AdjoinRootXPowSubCEquivToRootsOfUnity hζ H,
left_inv ... | null | true |
Char.val_ofOrdinal._proof_2 | Init.Data.Char.Ordinal | ∀ {f : Fin Char.numCodePoints}, ↑f + Char.numSurrogates < UInt32.size | 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 |
Polynomial.hasseDeriv_apply_one | Mathlib.Algebra.Polynomial.HasseDeriv | ∀ {R : Type u_1} [inst : Semiring R] (k : ℕ), 0 < k → (Polynomial.hasseDeriv k) 1 = 0 | null | true |
_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 |
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 |
Std.ExtDTreeMap.minKey?_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{km : α}, t.minKey? = some km → km ∈ t | null | true |
Finset.coe_inj | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, ↑s₁ = ↑s₂ ↔ s₁ = s₂ | null | true |
legendreSym.quadratic_reciprocity | Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity | ∀ {p q : ℕ} [inst : Fact (Nat.Prime p)] [inst_1 : Fact (Nat.Prime q)],
p ≠ 2 → q ≠ 2 → p ≠ q → legendreSym q ↑p * legendreSym p ↑q = (-1) ^ (p / 2 * (q / 2)) | **The Law of Quadratic Reciprocity**: if `p` and `q` are distinct odd primes, then
`(q / p) * (p / q) = (-1)^((p-1)(q-1)/4)`. | true |
Finset.op_vadd_finset_vadd_eq_vadd_vadd_finset | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : DecidableEq β] [inst_1 : DecidableEq γ] [inst_2 : VAdd αᵃᵒᵖ β]
[inst_3 : VAdd β γ] [inst_4 : VAdd α γ] (a : α) (s : Finset β) (t : Finset γ),
(∀ (a : α) (b : β) (c : γ), (AddOpposite.op a +ᵥ b) +ᵥ c = b +ᵥ a +ᵥ c) → (AddOpposite.op a +ᵥ s) +ᵥ t = s +ᵥ a +ᵥ t | null | true |
_private.Mathlib.Analysis.Convex.Function.0.neg_strictConvexOn_iff._simp_1_2 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, (a + -b < c) = (a < c + b) | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.span_singleton_mul_eq_span_singleton_mul._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {x y : R} {I J : Ideal R},
(Ideal.span {x} * I ≤ Ideal.span {y} * J) = ∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ | null | false |
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 |
Real.range_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | Set.range Real.arctan = Set.Ioo (-(Real.pi / 2)) (Real.pi / 2) | null | true |
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.Meta.Grind.Arith.CommRing.EqCnstrProof.brecOn.eq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ {motive_1 : Lean.Meta.Grind.Arith.CommRing.EqCnstr → Sort u}
{motive_2 : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof → Sort u} (t : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof)
(F_1 : (t : Lean.Meta.Grind.Arith.CommRing.EqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof) → ... | null | true |
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 |
AddMonoidHom.transfer_def | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} {A : Type u_2} [inst_1 : AddCommGroup A] (ϕ : ↥H →+ A)
(T : H.LeftTransversal) [inst_2 : H.FiniteIndex] (g : G),
ϕ.transfer g = AddSubgroup.leftTransversals.diff ϕ T (g +ᵥ T) | null | true |
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 |
_private.Mathlib.LinearAlgebra.AffineSpace.Pointwise.0.AffineSubspace.pointwise_vadd_top._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.Pointwise | ∀ {α : Type u_5} {β : Type u_6} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α) {x y : β},
(g +ᵥ x = y) = (x = -g +ᵥ y) | null | false |
Std.HashMap.getKey?_union | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, (m₁ ∪ m₂).getKey? k = (m₂.getKey? k).or (m₁.getKey? k) | null | true |
WithTop.continuousOn_untopD | Mathlib.Topology.Order.WithTop | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι] (d : ι),
ContinuousOn (WithTop.untopD d) {a | a ≠ ⊤} | 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 |
ENNReal.orderIsoUnitIntervalBirational | Mathlib.Data.ENNReal.Inv | ENNReal ≃o ↑(Set.Icc 0 1) | An order isomorphism between the extended nonnegative real numbers and the unit interval. | true |
Homeomorph.Set.prod._proof_1 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} (s : Set X) (t : Set Y) (x : { x // x ∈ s ×ˢ t }), (↑x).1 ∈ s | null | false |
SemiRingCat.limitSemiring._proof_18 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt), 1 * a = a | null | false |
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 |
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 |
DividedPowers.SubDPIdeal.mk.congr_simp | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {hI : DividedPowers I} (carrier carrier_1 : Ideal A)
(e_carrier : carrier = carrier_1) (isSubideal : carrier ≤ I)
(dpow_mem : ∀ (n : ℕ), n ≠ 0 → ∀ j ∈ carrier, hI.dpow n j ∈ carrier),
{ carrier := carrier, isSubideal := isSubideal, dpow_mem := dpow_mem } =
... | null | true |
SSet.PtSimplex | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | (X : SSet) → ℕ → X.obj (Opposite.op { len := 0 }) → Type u | Given a simplicial set `X`, `n : ℕ` and `x : X _⦋0⦌`, this is the type
of morphisms `Δ[n] ⟶ X` which are constant with value `x` on the boundary. | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone.0.NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates_eq_iff.match_1_6 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(a b : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)) (motive : (∃ ζ, ↑ζ • ↑a = ↑b) → Prop)
(x : ∃ ζ, ↑ζ • ↑a = ↑b),
(∀ (u : (NumberField.RingOfIntegers K)ˣ) (property : u ∈ NumberField.Units.torsion K) (h : ↑⟨u, property⟩ • ↑a = ↑b),
m... | null | false |
AlgebraicTopology.map_alternatingFaceMapComplex | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
(AlgebraicTopology.alternatingFaceMapComplex C).comp... | null | true |
iteratedDerivWithin_of_isOpen_eq_iterate | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {f : 𝕜 → F} {s : Set 𝕜},
IsOpen s → Set.EqOn (iteratedDerivWithin n f s) (deriv^[n] f) s | 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 |
Lean.PersistentHashMap.Stats._sizeOf_inst | Lean.Data.PersistentHashMap | SizeOf Lean.PersistentHashMap.Stats | null | false |
IsometryEquiv.mk.noConfusion | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} →
{β : Type v} →
{inst : PseudoEMetricSpace α} →
{inst_1 : PseudoEMetricSpace β} →
{P : Sort u_1} →
{toEquiv : α ≃ β} →
{isometry_toFun : Isometry toEquiv.toFun} →
{toEquiv' : α ≃ β} →
{isometry_toFun' : Isometry toEquiv'.toFun} →
... | null | false |
CategoryTheory.Functor.mapAddMon_map_hom | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] {X Y : CategoryTheory.AddMon C} (f : X ⟶ Y),
(... | 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 |
StateCpsT.runK_bind_pure | Init.Control.StateCps | ∀ {α σ : Type u} {m : Type u → Type v} {β γ : Type u} (a : α) (f : α → StateCpsT σ m β) (s : σ) (k : β → σ → m γ),
(pure a >>= f).runK s k = (f a).runK s k | 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 |
LieHom.toLinearMap_comp._simp_1 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [inst : CommRing R] [inst_1 : LieRing L₁]
[inst_2 : LieAlgebra R L₁] [inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] [inst_5 : LieRing L₃]
[inst_6 : LieAlgebra R L₃] (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂), ↑f ∘ₗ ↑g = ↑(f.comp g) | null | false |
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 |
Std.Do.SPred.Tactic.instIsPureImpPureForall | Std.Do.SPred.DerivedLaws | ∀ {φ ψ : Prop} (σs : List (Type u_1)), Std.Do.SPred.Tactic.IsPure spred(⌜φ⌝ → ⌜ψ⌝) (φ → ψ) | 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 |
Equiv.pointReflection_midpoint_right | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] (x y : P), (Equiv.pointReflection (midpoint R x y)) y = x | null | true |
BiheytingAlgebra.ctorIdx | Mathlib.Order.Heyting.Basic | {α : Type u_4} → BiheytingAlgebra α → ℕ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.