name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.NumberTheory.Height.Basic.0.Height.hasFiniteMulSupport_iSup_nonarchAbsVal._proof_1_3 | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] {ι : Type u_2} {x : ι → K} (i : { j // x j ≠ 0 }), ¬x ↑i = 0 | null | false |
Std.DTreeMap.Raw.maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β k} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | null | true |
CategoryTheory.CartesianMonoidalCategory.mk | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[toSemiCartesianMonoidalCategory : CategoryTheory.SemiCartesianMonoidalCategory C] →
((X Y : C) →
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.SemiCartesianMonoidalCategory.fst X Y)
... | null | true |
AlgHom.liftOfSurjective._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), (RingHom.ker f.toRingHom).IsTwoSided | null | false |
Nat.leRec._proof_1 | Mathlib.Data.Nat.Init | 0 ≤ 0 | null | false |
Std.HashMap.Equiv.filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β}
(f : α → β → Option γ), m₁.Equiv m₂ → (Std.HashMap.filterMap f m₁).Equiv (Std.HashMap.filterMap f m₂) | null | true |
Mathlib.Meta.NormNum.isInt_ratCast | Mathlib.Tactic.NormNum.Inv | ∀ {R : Type u_1} [inst : DivisionRing R] {q : ℚ} {n : ℤ},
Mathlib.Meta.NormNum.IsInt q n → Mathlib.Meta.NormNum.IsInt (↑q) n | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_19 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α] (h : i < (List.idxsOf x xs s).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] + 1 ≤ xs.length → (List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length | null | false |
CategoryTheory.CartesianMonoidalCategory.lift_leftUnitor_hom | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] {X Y : C}
(f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C) (g : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianMonoidalCategory.lift f g)
(CategoryTheory.MonoidalCate... | null | true |
Array.find?_isSome | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, (Array.find? p xs).isSome = true ↔ ∃ x ∈ xs, p x = true | null | true |
NonemptyInterval.pure_natCast | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : NatCast α] (n : ℕ), NonemptyInterval.pure ↑n = ↑n | null | true |
Std.LawfulEqCmp.opposite | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] [Std.LawfulEqCmp cmp], Std.LawfulEqCmp fun a b => cmp b a | null | true |
_private.Std.Sat.AIG.RelabelNat.0.Std.Sat.AIG.RelabelNat.State.ofAIGAux.go.match_1.splitter | Std.Sat.AIG.RelabelNat | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(decl : Std.Sat.AIG.Decl α) →
((a : α) → decl = Std.Sat.AIG.Decl.atom a → motive (Std.Sat.AIG.Decl.atom a)) →
(decl = Std.Sat.AIG.Decl.false → motive Std.Sat.AIG.Decl.false) →
((lhs rhs : Std.Sat.AIG.Fanin) →
decl = Std.... | null | true |
FreeAbelianGroup.ring._proof_4 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ (α : Type u_1) [inst : Monoid α] (n : ℕ) (x : FreeAbelianGroup α), npowRecAuto (n + 1) x = npowRecAuto n x * x | null | false |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.instRxcLawfulHasSize._proof_3 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ), ¬n + 1 > 0 → False | null | false |
MvPolynomial.comp_aeval_apply | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] [inst_2 : Algebra R S₁]
(f : σ → S₁) {B : Type u_2} [inst_3 : CommSemiring B] [inst_4 : Algebra R B] (φ : S₁ →ₐ[R] B) (p : MvPolynomial σ R),
φ ((MvPolynomial.aeval f) p) = (MvPolynomial.aeval fun i => φ (f i)) p | null | true |
_private.Mathlib.Algebra.Polynomial.HasseDeriv.0.Polynomial.factorial_smul_hasseDeriv._simp_1_2 | Mathlib.Algebra.Polynomial.HasseDeriv | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (n : ℕ), ↑n + 1 = ↑n.succ | null | false |
RBTree.RBColor | BatteriesRecycling.RBTree.Basic | Type | In a red-black tree, every node has a color which is either "red" or "black"
(this particular choice of colors is conventional). A nil node is considered black.
| true |
InfHom.instPartialOrder.eq_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : SemilatticeInf β],
InfHom.instPartialOrder = PartialOrder.lift DFunLike.coe ⋯ | null | true |
Std.DTreeMap.Raw.getKey!_eq_of_contains | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α], t.WF → ∀ {k : α}, t.contains k = true → t.getKey! k = k | null | true |
CompletelyPositiveMap.noConfusion | Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap | {P : Sort u} →
{A₁ : Type u_1} →
{A₂ : Type u_2} →
{inst : NonUnitalCStarAlgebra A₁} →
{inst_1 : NonUnitalCStarAlgebra A₂} →
{inst_2 : PartialOrder A₁} →
{inst_3 : PartialOrder A₂} →
{inst_4 : StarOrderedRing A₁} →
{inst_5 : StarOrderedRing A₂} →
... | null | false |
mem_openSegment_iff_div | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {x y z : E},
x ∈ openSegment 𝕜 y z ↔ ∃ a b, 0 < a ∧ 0 < b ∧ (a / (a + b)) • y + (b / (a + b)) • z = x | null | true |
_private.Mathlib.Algebra.Module.Submodule.Pointwise.0.Submodule.set_smul_eq_iSup._simp_1_2 | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (iSup f ≤ a) = ∀ (i : ι), f i ≤ a | null | false |
_private.Mathlib.Data.Finmap.0.Finmap.any._simp_1 | Mathlib.Data.Finmap | ∀ (α : Sort u), (∀ (a : α), True) = True | null | false |
CategoryTheory.SemiCartesianMonoidalCategory.comp_toUnit_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.SemiCartesianMonoidalCategory C]
{X Y : C} (f : X ⟶ Y) {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ Z),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianM... | null | true |
PerfectClosure.mk_inv | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u) [inst : Field K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (x : ℕ × K),
(PerfectClosure.mk K p x)⁻¹ = PerfectClosure.mk K p (x.1, x.2⁻¹) | null | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Traj.0.ProbabilityTheory.Kernel.condExp_traj'._simp_1_1 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) | null | false |
IsPurelyInseparable.iterateFrobenius._proof_4 | Mathlib.FieldTheory.PurelyInseparable.Exponent | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : IsPurelyInseparable.HasExponent K L] (p : ℕ) [ExpChar K p] {n : ℕ},
IsPurelyInseparable.exponent K L ≤ n →
∀ (a b : L),
IsPurelyInseparable.iterateFrobeniusAux✝ K L p n (a + b) =
IsPurelyInseparabl... | null | false |
_private.Mathlib.Order.Nucleus.0.Nucleus.giAux._proof_2 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (n : Nucleus X) (x : X) (y : ↑(Set.range ⇑n)),
n.toClosureOperator x ≤ ↑y ↔ x ≤ ↑y | null | false |
Lean.Expr.FoldConstsImpl.State.rec | Lean.Util.FoldConsts | {motive : Lean.Expr.FoldConstsImpl.State → Sort u} →
((visited : Lean.PtrSet Lean.Expr) →
(visitedConsts : Lean.NameHashSet) → motive { visited := visited, visitedConsts := visitedConsts }) →
(t : Lean.Expr.FoldConstsImpl.State) → motive t | null | false |
LieSubmodule.subset_lieSpan | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {s : Set M}, s ⊆ ↑(LieSubmodule.lieSpan R L s) | null | true |
IsContDiffImplicitAt.apply_implicitFunction | Mathlib.Analysis.Calculus.ImplicitContDiff | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E₁ : Type u_2} [inst_1 : NormedAddCommGroup E₁] [inst_2 : NormedSpace 𝕜 E₁]
[inst_3 : CompleteSpace E₁] {E₂ : Type u_3} [inst_4 : NormedAddCommGroup E₂] [inst_5 : NormedSpace 𝕜 E₂]
[inst_6 : CompleteSpace E₂] {F : Type u_4} [inst_7 : NormedAddCommGroup F] [inst_8 : NormedSpac... | **Alias** of `ContDiffAt.eventually_apply_implicitFunction`.
---
`implicitFunction` is indeed the (local) implicit function defined by `f`. | true |
CategoryTheory.Monad.ForgetCreatesLimits.liftedConeIsLimit._proof_4 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (D : CategoryTheory.Functor J T.Algebra)
(c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c)
(s : CategoryTheory.Limits.Co... | null | false |
RatFunc.toFractionRingRingEquiv._proof_8 | Mathlib.FieldTheory.RatFunc.Basic | ∀ (K : Type u_1) [inst : CommRing K] (toFractionRing toFractionRing_1 : FractionRing (Polynomial K)),
({ toFractionRing := toFractionRing } + { toFractionRing := toFractionRing_1 }).toFractionRing =
{ toFractionRing := toFractionRing }.toFractionRing + { toFractionRing := toFractionRing_1 }.toFractionRing | null | false |
Int.subNatNat_elim | Init.Data.Int.Lemmas | ∀ (m n : ℕ) (motive : ℕ → ℕ → ℤ → Prop),
(∀ (i n : ℕ), motive (n + i) n ↑i) →
(∀ (i m : ℕ), motive m (m + i + 1) (Int.negSucc i)) → motive m n (Int.subNatNat m n) | null | true |
Odd.neg | Mathlib.Algebra.Ring.Parity | ∀ {α : Type u_2} [inst : Ring α] {a : α}, Odd a → Odd (-a) | null | true |
KaehlerDifferential.fromIdeal_surjective | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Function.Surjective ⇑(KaehlerDifferential.fromIdeal R S) | null | true |
ByteArray.append_left_inj._simp_1 | Init.Data.ByteArray.Lemmas | ∀ {xs₁ xs₂ : ByteArray} (ys : ByteArray), (xs₁ ++ ys = xs₂ ++ ys) = (xs₁ = xs₂) | null | false |
_private.Mathlib.Algebra.Module.LinearMap.End.0.Module.End.iterate_bijective.match_1_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
ContinuousLinearMap.toSpanSingleton_inj | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₂ : Type u_6} [inst_1 : TopologicalSpace M₂] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R₁ M₂] [inst_4 : TopologicalSpace R₁] [inst_5 : ContinuousSMul R₁ M₂] {f f' : M₂},
ContinuousLinearMap.toSpanSingleton R₁ f = ContinuousLinearMap.toSpanSingleton R₁ f' ↔ f = f' | null | true |
List.next_eq_getElem._proof_2 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} {a : α}, a ∈ l → 0 < l.length | null | false |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.pow_inter_pow._proof_1_2 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {m : ℕ}, 2 ≤ m → 2 ≤ 2 * m | null | false |
AlgebraicGeometry.SheafedSpace.ext._proof_1 | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : AlgebraicGeometry.SheafedSpace C} (α β : X ⟶ Y),
α.hom.base = β.hom.base → (TopologicalSpace.Opens.map α.hom.base).op = (TopologicalSpace.Opens.map β.hom.base).op | null | false |
ArithmeticFunction.LSeries_mul | Mathlib.NumberTheory.LSeries.Convolution | ∀ {f g : ArithmeticFunction ℂ} {s : ℂ},
(LSeries.abscissaOfAbsConv fun n => f n) < ↑s.re →
(LSeries.abscissaOfAbsConv fun n => g n) < ↑s.re →
LSeries (fun n => (f * g) n) s = LSeries (fun n => f n) s * LSeries (fun n => g n) s | The L-series of the (convolution) product of two `ℂ`-valued arithmetic functions `f` and `g`
equals the product of their L-series in their common half-plane of absolute convergence. | true |
IsLocalDiffeomorphAt.mfderivToContinuousLinearEquiv | Mathlib.Geometry.Manifold.LocalDiffeomorph | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{F : Type u_3} →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
{H₁ : Type u_5} →
... | If `f` is a `C^n` local diffeomorphism at `x`, for `n ≠ 0`, the differential `df_x`
is a linear equivalence. | true |
exists_linearIndepOn_id_extension | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s t : Set V},
LinearIndepOn K id s → s ⊆ t → ∃ b ⊆ t, s ⊆ b ∧ t ⊆ ↑(Submodule.span K b) ∧ LinearIndepOn K id b | null | true |
OrderRingIso.instInhabited | Mathlib.Algebra.Order.Hom.Ring | (α : Type u_2) → [inst : Mul α] → [inst_1 : Add α] → [inst_2 : LE α] → Inhabited (α ≃+*o α) | null | true |
Matrix.isSymm_fromBlocks_iff | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {m : Type u_4} {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
{D : Matrix n n α}, (Matrix.fromBlocks A B C D).IsSymm ↔ A.IsSymm ∧ B.transpose = C ∧ C.transpose = B ∧ D.IsSymm | This is the `iff` version of `Matrix.isSymm.fromBlocks`. | true |
PFunctor.mk._flat_ctor | Mathlib.Data.PFunctor.Univariate.Basic | (A : Type uA) → (A → Type uB) → PFunctor.{uA, uB} | null | false |
Std.Http.Header.ContentLength.mk._flat_ctor | Std.Http.Data.Headers.Basic | ℕ → Std.Http.Header.ContentLength | null | false |
Lean.HeadIndex.sort | Lean.HeadIndex | Lean.HeadIndex | null | true |
Std.Sat.AIG.RefVec.fold.go._unary | Std.Sat.AIG.RefVecOperator.Fold | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
(len : ℕ) →
(f : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α) →
[Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f] →
(aig : Std.Sat.AIG α) ×' (_ : aig.Ref) ×' (_ : ℕ) ×' aig.RefVec len → ... | null | false |
_private.Mathlib.Topology.Constructions.SumProd.0.isClosed_sum_iff._simp_1_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ | null | false |
IsProperMap.clusterPt_of_mapClusterPt | Mathlib.Topology.Maps.Proper.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsProperMap f → ∀ ⦃ℱ : Filter X⦄ ⦃y : Y⦄, MapClusterPt y ℱ f → ∃ x, f x = y ∧ ClusterPt x ℱ | By definition, if `f` is a proper map and `ℱ` is any filter on `X`, then any cluster point of
`map f ℱ` is the image by `f` of some cluster point of `ℱ`. | true |
mdifferentiableWithinAt_comp_projIcc_iff | Mathlib.Geometry.Manifold.Instances.Icc | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {x y : ℝ}
[h : Fact (x < y)] {f : ↑(Set.Icc x y) → M} {w : ↑(Set.Icc x y)},
MDiffAt[Set.Icc x... | null | true |
QuadraticMap.polar_smul_left_of_tower | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {S : Type u_1} {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module R M] [inst_4 : Module R N] (Q : QuadraticMap R M N)
[inst_5 : CommSemiring S] [inst_6 : Algebra S R] [inst_7 : Module S M] [IsScalarTower S R M] [inst_9 : Module S N... | null | true |
StarOrderedRing.toExistsAddOfLE | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R],
ExistsAddOfLE R | null | true |
Std.HashSet.Raw.not_mem_emptyWithCapacity._simp_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {a : α} {c : ℕ}, (a ∈ Std.HashSet.Raw.emptyWithCapacity c) = False | null | false |
CategoryTheory.Functor.chosenProd.snd | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.SemiCartesianMonoidalCategory C] →
(X Y : C) → CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Y | **Alias** of `CategoryTheory.SemiCartesianMonoidalCategory.snd`. | true |
NumberField.dedekindZeta_residue_pos | Mathlib.NumberTheory.NumberField.DedekindZeta | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K], 0 < NumberField.dedekindZeta_residue K | null | true |
CategoryTheory.Limits.coneOfDiagramInitial | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
{X : J} → CategoryTheory.Limits.IsInitial X → (F : CategoryTheory.Functor J C) → CategoryTheory.Limits.Cone F | From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cone for `J`.
In `limitOfDiagramInitial` we show it is a limit cone. | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.IsLongestMatch.sliceTo._simp_1_2 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {s : String.Slice} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos} {h : q ≤ p₀},
(p₀.sliceTo q h < p) = (q < String.Slice.Pos.ofSliceTo p) | null | false |
Std.DHashMap.Const.isEmpty_of_isEmpty_insertManyIfNewUnit | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α fun x => Unit} {ρ : Type w} [inst : ForIn Id ρ α]
[EquivBEq α] [LawfulHashable α] {l : ρ},
(Std.DHashMap.Const.insertManyIfNewUnit m l).isEmpty = true → m.isEmpty = true | null | true |
EStateM.run_throw | Init.Control.Lawful.Instances | ∀ {ε σ : Type u_1} (e : ε) (s : σ), (throw e).run s = EStateM.Result.error e s | null | true |
ConvexBody.ext_iff | Mathlib.Analysis.Convex.Body | ∀ {V : Type u_1} [inst : TopologicalSpace V] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V] {K L : ConvexBody V},
K = L ↔ ↑K = ↑L | null | true |
Equiv.swapCore_self | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] (r a : α), Equiv.swapCore a a r = r | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations.0.RootPairing.GeckConstruction.lie_e_f_ne._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
CategoryTheory.Presheaf.coherentExtensiveEquivalence | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] →
[inst_2 : CategoryTheory.Preregular C] →
[inst_3 : CategoryTheory.FinitaryExtensive C] →
[∀ (X : C), CategoryTheory.Projective X] →
Cat... | The categories of coherent sheaves and extensive sheaves on `C` are equivalent if `C` is
preregular, finitary extensive, and every object is projective.
| true |
DomMulAct.instInvOneClassOfMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : InvOneClass Mᵐᵒᵖ], DomMulAct.instInvOneClassOfMulOpposite = inst | null | true |
ValuativeRel.instSemiringWithPreorder._aux_8 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} → [Semiring R] → ℕ → ValuativeRel.WithPreorder R → ValuativeRel.WithPreorder R | null | false |
Lean.Elab.Tactic.instInhabitedState | Lean.Elab.Term.TermElabM | Inhabited Lean.Elab.Tactic.State | null | true |
CategoryTheory.InjectiveResolution.descIdHomotopy._proof_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] (X : C)
(I : CategoryTheory.InjectiveResolution X),
CategoryTheory.CategoryStruct.comp I.ι
(CategoryTheory.InjectiveResolution.desc (CategoryTheory.CategoryStruct.id X) I I) =
CategoryTheory.CategoryStruct.c... | null | false |
_private.Mathlib.Data.Finset.Card.0.Finset.card_insert_le._proof_1_1 | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), (insert a s).card ≤ s.card + 1 | null | false |
Affine.Simplex.centroidWeightsWithCircumcenter.eq_2 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {n : ℕ} (fs : Finset (Fin (n + 1))),
Affine.Simplex.centroidWeightsWithCircumcenter fs Affine.Simplex.PointsWithCircumcenterIndex.circumcenterIndex = 0 | null | true |
OpenAddSubgroup.comap | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} →
[inst : AddGroup G] →
[inst_1 : TopologicalSpace G] →
{N : Type u_2} →
[inst_2 : AddGroup N] →
[inst_3 : TopologicalSpace N] → (f : G →+ N) → Continuous ⇑f → OpenAddSubgroup N → OpenAddSubgroup G | The preimage of an `OpenAddSubgroup` along a continuous `AddMonoid` homomorphism
is an `OpenAddSubgroup`. | true |
Finsupp.comapDistribMulAction._proof_1 | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {M : Type u_2} {G : Type u_3} [inst : Monoid G] [inst_1 : MulAction G α] [inst_2 : AddCommMonoid M]
(g : G), g • 0 = 0 | null | false |
IsPreconnected.eq_or_eq_neg_of_sq_eq | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_2} {𝕜 : Type u_3} {f g : α → 𝕜} {S : Set α} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace 𝕜]
[T1Space 𝕜] [inst_3 : Field 𝕜] [ContinuousInv₀ 𝕜] [ContinuousMul 𝕜],
IsPreconnected S →
ContinuousOn f S →
ContinuousOn g S → Set.EqOn (f ^ 2) (g ^ 2) S → (∀ {x : α}, x ∈ S → g x ≠ 0)... | If `f, g` are functions `α → 𝕜`, both continuous on a preconnected set `S`, with
`f ^ 2 = g ^ 2` on `S`, and `g z ≠ 0` all `z ∈ S`, then either `f = g` or `f = -g` on
`S`. | true |
CategoryTheory.SimplicialObject.Augmented.whiskering._proof_3 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {X Y : CategoryTheory.Functor C D} (η : X ⟶ Y)
⦃X_1 Y_1 : CategoryTheory.SimplicialObject.Augmented C⦄ (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.SimplicialObject... | null | false |
Lean.Grind.instLEUSizeUintNumBits | Init.GrindInstances.ToInt | Lean.Grind.ToInt.LE USize (Lean.Grind.IntInterval.uint System.Platform.numBits) | null | true |
_private.Mathlib.Order.Category.FinBddDistLat.0.FinBddDistLat.Hom.mk.sizeOf_spec | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y : FinBddDistLat} (hom' : BoundedLatticeHom ↑X.toDistLat ↑Y.toDistLat), sizeOf { hom' := hom' } = 1 + sizeOf hom' | null | true |
AbsoluteValue._sizeOf_1 | Mathlib.Algebra.Order.AbsoluteValue.Basic | {R : Type u_5} →
{S : Type u_6} →
{inst : Semiring R} →
{inst_1 : Semiring S} → {inst_2 : PartialOrder S} → [SizeOf R] → [SizeOf S] → AbsoluteValue R S → ℕ | null | false |
Matrix.permMatrix_mem_colStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {σ : Equiv.Perm n},
Equiv.Perm.permMatrix R σ ∈ Matrix.colStochastic R n | Any permutation matrix is column stochastic. | true |
StarAlgHom.ext_iff | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] {f g : A →⋆ₐ[R] B},
f = g ↔ ∀ (x : A), f x = g x | null | true |
String.Pos.Raw.offsetBy_sliceRawEndPos_left | Init.Data.String.Defs | ∀ {p : String.Pos.Raw} {s : String.Slice}, s.rawEndPos.offsetBy p = p + s | null | true |
QuadraticMap.instNeg._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (Q : QuadraticMap R M N),
∃ B, ∀ (x y : M), (-⇑Q) (x + y) = (-⇑Q) x + (-⇑Q) y + (B x) y | null | false |
CategoryTheory.Grothendieck.isoMk_hom_fiber | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (e₁ : X.base ≅ Y.base) (e₂ : (F.map e₁.hom).toFunctor.obj X.fiber ≅ Y.fiber),
(CategoryTheory.Grothendieck.isoMk e₁ e₂).hom.fiber = e₂.hom | null | true |
HasDerivWithinAt.lhopital_zero_nhdsWithin_convex | Mathlib.Analysis.Calculus.LHopital | ∀ {a : ℝ} {l : Filter ℝ} {f f' g g' : ℝ → ℝ} {s : Set ℝ},
Convex ℝ s →
(∀ᶠ (x : ℝ) in nhdsWithin a (s \ {a}), HasDerivWithinAt f (f' x) (s \ {a}) x) →
(∀ᶠ (x : ℝ) in nhdsWithin a (s \ {a}), HasDerivWithinAt g (g' x) (s \ {a}) x) →
(∀ᶠ (x : ℝ) in nhdsWithin a (s \ {a}), g' x ≠ 0) →
Filter.T... | L'Hôpital's rule for approaching a real from within a convex set, `HasDerivWithinAt` version.
This does not require anything about the situation at `a` | true |
MeasureTheory.Measure.Regular.exists_isCompact_not_null | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace α] [μ.Regular],
(∃ K, IsCompact K ∧ μ K ≠ 0) ↔ μ ≠ 0 | null | true |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.eq_pell_lem.match_1_3 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (motive : ℕ → ℤ√↑(Pell.d✝ a1) → Prop) (x : ℕ) (x_1 : ℤ√↑(Pell.d✝ a1)),
(∀ (x : ℤ√↑(Pell.d✝ a1)), motive 0 x) → (∀ (n : ℕ) (b : ℤ√↑(Pell.d✝ a1)), motive n.succ b) → motive x x_1 | null | false |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.sum_Ioc_mul_eq_sum_sum._simp_1_2 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_fst | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Limits.IsTerminal Y)
(c : CategoryTheory.Limits.BinaryFan X Y), Nonempty (CategoryTheory.Limits.IsLimit c) ↔ CategoryTheory.IsIso c.fst | null | true |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.simpHaveTelescope.match_7 | Lean.Meta.HaveTelescope | (motive : Array Bool × Array Bool → Sort u_1) →
(x : Array Bool × Array Bool) → ((fixed used : Array Bool) → motive (fixed, used)) → motive x | null | false |
isUpperSet_setOf._simp_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : Preorder α] {p : α → Prop}, IsUpperSet {a | p a} = Monotone p | null | false |
Std.Async.ContextAsync.instMonadExceptError | Std.Async.ContextAsync | MonadExcept IO.Error Std.Async.ContextAsync | null | true |
CategoryTheory.instAdditiveObjFunctorAdditiveFunctor | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ (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] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] (F : C ⥤+ D), F.obj.Additive | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt32.lt_of_le_of_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.StronglyRegular.0.SimpleGraph.IsSRGWith.param_eq._simp_1_8 | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {α : Sort u} (a b : α), (¬a = b) = (a ≠ b) | null | false |
LinearMap.range_dualMap_eq_dualAnnihilator_ker | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_3} {V₁ : Type u_4} {V₂ : Type u_5} [inst : Field K] [inst_1 : AddCommGroup V₁] [inst_2 : Module K V₁]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] (f : V₁ →ₗ[K] V₂), f.dualMap.range = f.ker.dualAnnihilator | null | true |
Aesop.CasesTarget.patterns | Aesop.RuleTac.Basic | Array Aesop.CasesPattern → Aesop.CasesTarget | null | true |
CategoryTheory.Under.postEquiv_functor | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : T) (F : T ≌ D), (CategoryTheory.Under.postEquiv X F).functor = CategoryTheory.Under.post F.functor | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.