name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ZMod.commRing._proof_22 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) (a : ZMod n), Nat.casesOn (motive := fun x => ZMod x → ZMod x) n Neg.neg (fun n => Neg.neg) a + a = 0 | null | false |
CategoryTheory.Pseudofunctor.DescentData.Hom.mk.inj | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C}
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {D₁ D₂ : F.DescentData f} {hom : (i : ι) → D₁.obj i ⟶ D₂.obj i}
{comm :
autoParam
(∀ ⦃Y : C⦄ (q : Y... | null | true |
CategoryTheory.BimonObj | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → [CategoryTheory.BraidedCategory C] → C → Type v₁ | A bimonoid object in a braided category `C` is an object that is simultaneously monoid and comonoid
objects, and structure morphisms of them satisfy appropriate consistency conditions.
| true |
Bundle.contMDiff_section_of_subsingleton | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_3} (E : B → Type u_5) [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_4 : (x : B) → TopologicalSpace (E x)] {EB : Type u_6} [inst_5 : NormedAddCommG... | null | true |
Stream'.Seq.nil.eq_1 | Mathlib.Data.Seq.Basic | ∀ {α : Type u}, Stream'.Seq.nil = ⟨Stream'.const none, ⋯⟩ | null | true |
Mathlib.Meta.FunProp.Mor.app | Mathlib.Tactic.FunProp.Mor | Lean.Expr → Mathlib.Meta.FunProp.Mor.Arg → Lean.Expr | Morphism application | true |
_private.Init.Data.Array.Lemmas.0.Array.shrink.loop.eq_def | Init.Data.Array.Lemmas | ∀ {α : Type u} (x : ℕ) (x_1 : Array α),
Array.shrink.loop✝ x x_1 =
match x, x_1 with
| 0, xs => xs
| n.succ, xs => Array.shrink.loop✝ n xs.pop | null | true |
CategoryTheory.Limits.Sigma.desc.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f : β → C}
[inst_1 : CategoryTheory.Limits.HasCoproduct f] {P : C} (p : (b : β) → f b ⟶ P),
CategoryTheory.Limits.Sigma.desc p =
CategoryTheory.Limits.colimit.desc (CategoryTheory.Discrete.functor f) (CategoryTheory.Limits.Cofan.mk P p) | null | true |
Std.TreeMap.getElem!_emptyc | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Inhabited β] {a : α}, ∅[a]! = default | null | true |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.getKeyD_modify_self._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
Vector.pop_append_of_size_ne_zero._proof_2 | Init.Data.Vector.Lemmas | ∀ {n m : ℕ}, m ≠ 0 → n + (m - 1) = n + m - 1 | null | false |
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.removeArgRule._proof_3 | Mathlib.Tactic.FunProp.Core | ∀ (fData : Mathlib.Meta.FunProp.FunctionData) (n : ℕ), fData.args.size = n.succ → ¬n < fData.args.size → False | null | false |
_private.Mathlib.RingTheory.Polynomial.GaussNorm.0.Polynomial.sup'_nonneg_of_ne_zero._simp_1_1 | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
(a ≤ s.sup' H f) = ∃ b ∈ s, a ≤ f b | null | false |
Std.ExtDTreeMap.getKey!_eq_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst_2 : Inhabited α] {k : α}, k ∈ t → t.getKey! k = k | null | true |
Polynomial.roots_eq_of_natDegree_le_card_of_ne_zero | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R} {S : Finset R},
(∀ x ∈ S, Polynomial.eval x p = 0) → p.natDegree ≤ S.card → p ≠ 0 → p.roots = S.val | null | true |
Membership.get_elem_helper | Init.Data.Range.Basic | ∀ {i n : ℕ} {r : Std.Legacy.Range}, i ∈ r → r.stop = n → i < n | null | true |
LowerSet.instAdd | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} → [inst : AddCommGroup α] → [inst_1 : Preorder α] → [IsOrderedAddMonoid α] → Add (LowerSet α) | null | true |
RBTree.RBSet.mem_of_mem_toList | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x : α} [Std.OrientedCmp cmp] {t : RBTree.RBSet α cmp}, x ∈ t.toList → x ∈ t | null | true |
Std.Internal.Parsec.ByteArray.skipWhileUpTo | Std.Internal.Parsec.ByteArray | (UInt8 → Bool) → ℕ → Std.Internal.Parsec.ByteArray.Parser Unit | Skips while a predicate is satisfied, up to a given limit.
Fails with `.eof` if input ends before stopping or reaching the limit.
| true |
Matroid.RankInfinite | Mathlib.Combinatorics.Matroid.Basic | {α : Type u_1} → Matroid α → Prop | An `RankInfinite` matroid is one whose bases are infinite. | true |
MonoidAlgebra.uniqueRingEquiv_apply | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} (M : Type u_4) [inst : Semiring R] [inst_1 : Monoid M] [inst_2 : Subsingleton M]
(a : MonoidAlgebra R M), (MonoidAlgebra.uniqueRingEquiv M) a = a.coeff 1 | null | true |
WittVector.mul_charP_coeff_succ | Mathlib.RingTheory.WittVector.Identities | ∀ {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] [CharP R p] (x : WittVector p R) (i : ℕ),
(x * ↑p).coeff (i + 1) = x.coeff i ^ p | null | true |
Lake.Glob.ctorIdx | Lake.Config.Glob | Lake.Glob → ℕ | null | false |
Std.DTreeMap.Internal.Impl.Const.get!_filter_of_getKey?_eq_some | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β] {f : α → β → Bool} {k k' : α} (h : t.WF),
t.getKey? k = some k' →
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.filter f t ⋯).impl k =
(Option.filter (fun x... | null | true |
Lean.Meta.Sym.Simp.instNonemptyMethodsRef | Lean.Meta.Sym.Simp.SimpM | Nonempty Lean.Meta.Sym.Simp.MethodsRef | null | true |
CategoryTheory.GrothendieckTopology.IsLocalSite.point._proof_4 | Mathlib.CategoryTheory.Sites.LocalSite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : CategoryTheory.LocallySmall.{u_3, u_1, u_2} C] [inst_2 : J.IsLocalSite] {X : C},
∀ R ∈ J X,
∀ (x : (CategoryTheory.shrinkCoyoneda.{u_3, u_1, u_2}.obj (Opposite.op (⊤_ C))).obj X),
∃ Y f,
... | null | false |
_private.Mathlib.Analysis.Calculus.TangentCone.Basic.0.tangentConeAt_mono_field._simp_1_1 | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {α : Type u} {p q : α → Prop}, ({a | p a} ⊆ {a | q a}) = ∀ (a : α), p a → q a | null | false |
Topology.isInducing_iff_nhds | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace X],
Topology.IsInducing f ↔ ∀ (x : X), nhds x = Filter.comap f (nhds (f x)) | null | true |
CStarAlgebra.noConfusionType | Mathlib.Analysis.CStarAlgebra.Classes | Sort u → {A : Type u_1} → CStarAlgebra A → {A' : Type u_1} → CStarAlgebra A' → Sort u | null | false |
Stream'.head | Mathlib.Data.Stream.Defs | {α : Type u} → Stream' α → α | Head of a stream: `Stream'.head s = Stream'.get s 0`. | true |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.coeff_X_mul_largeSchroderSeries._simp_1_4 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
Int.prime_three | Mathlib.Data.Nat.Prime.Int | Prime 3 | null | true |
_private.Batteries.Util.ProofWanted.0.instanceWantedCmd | Batteries.Util.ProofWanted | WantedCmdKind✝ | null | true |
Std.DTreeMap.Raw.isSome_minKey?_of_contains | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.contains k = true → t.minKey?.isSome = true | null | true |
instCommSemiringENat._proof_9 | Mathlib.Data.ENat.Monoid | autoParam (∀ (x : ℕ∞), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
FirstOrder.Language.isUltrahomogeneous_iff_IsExtensionPair | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M],
FirstOrder.Language.Structure.CG L M → (L.IsUltrahomogeneous M ↔ L.IsExtensionPair M M) | A countably generated structure is ultrahomogeneous if and only if any equivalence between
finitely generated substructures can be extended to any element in the domain. | true |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.Ordinal.CNF.nodupKeys | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (b o : Ordinal.{u_1}), (List.map Prod.toSigma (Ordinal.CNF b o)).NodupKeys | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | Type | Information about a failed import. | true |
Complex.HadamardThreeLines.interpStrip_eq_of_zero | Mathlib.Analysis.Complex.Hadamard | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (f : ℂ → E) (z : ℂ),
Complex.HadamardThreeLines.sSupNormIm f 0 = 0 ∨ Complex.HadamardThreeLines.sSupNormIm f 1 = 0 →
Complex.HadamardThreeLines.interpStrip f z = 0 | Rewrite for `InterpStrip` when `0 = sSupNormIm f 0` or `0 = sSupNormIm f 1`. | true |
_private.Lean.Environment.0.Lean.importModules._sparseCasesOn_1 | Lean.Environment | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
AlgebraicGeometry.tilde.modulesSpecToSheafIso._proof_3 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : ModuleCat ↑R) (U : (TopologicalSpace.Opens ↥(AlgebraicGeometry.Spec R))ᵒᵖ) (r : ↑R)
(m : ↑((AlgebraicGeometry.modulesSpecToSheaf.obj (AlgebraicGeometry.tilde M)).presheaf.obj U)),
(algebraMap (↑R) ((AlgebraicGeometry.structureSheafInType ↑R ↑R).obj.obj U)) r • m = r • m | null | false |
AddSubsemigroup.center.eq_1 | Mathlib.GroupTheory.Subsemigroup.Center | ∀ (M : Type u_1) [inst : Add M], AddSubsemigroup.center M = { carrier := Set.addCenter M, add_mem' := ⋯ } | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycle.swap_mul._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_4} (f g : Equiv.Perm α) (x : α), f (g x) = (f * g) x | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices.0.SSet.S.toNπ._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} (x : X.S),
∃ x_1, CategoryTheory.Epi x_1 ∧ (CategoryTheory.ConcreteCategory.hom (X.map x_1.op)) x.toN.simplex = x.simplex | null | false |
CategoryTheory.Limits.BinaryBicone.isColimitInlCokernelCofork._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {c : CategoryTheory.Limits.BinaryBicone X Y} (i : CategoryTheory.Limits.IsColimit c.toCocone)
(s : CategoryTheory.Limits.Cofork c.inl 0),
CategoryTheory.CategoryStruct.comp (CategoryTheory.... | null | false |
HomotopicalAlgebra.PathObject.ofFactorizationData_p₀ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {A : C}
(h :
(HomotopicalAlgebra.trivialCofibrations C).MapFactorizationData (HomotopicalAlgebra.fibrations C)
(CategoryTheory.Limits.diag A)),
(HomotopicalAlgebra.PathObject.ofFactorizationData h).p₀ =
... | null | true |
SimpleGraph.edgeFinset_subset_sym2_of_support_subset | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} {s : Set V} [inst : DecidablePred fun x => x ∈ s] [inst_1 : Fintype V] {G : SimpleGraph V}
[inst_2 : DecidableRel G.Adj], G.support ⊆ s → G.edgeFinset ⊆ s.toFinset.sym2 | null | true |
TopCat.Presheaf.stalkSpecializes_stalkPushforward_assoc | Mathlib.Topology.Sheaves.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C] {X Y : TopCat}
(f : X ⟶ Y) (F : TopCat.Presheaf C X) {x y : ↑X} (h : x ⤳ y) {Z : C} (h_1 : F.stalk x ⟶ Z),
CategoryTheory.CategoryStruct.comp (((TopCat.Presheaf.pushforward C f).obj F).stalkSpecializes ⋯)
(... | null | true |
CategoryTheory.NatTrans.equifibered_unop_iff | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equifibered | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_3} C] {F G : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ} {α : F ⟶ G},
CategoryTheory.NatTrans.Equifibered (CategoryTheory.NatTrans.unop α) ↔ CategoryTheory.NatTrans.Coequifibered α | null | true |
DividedPowers.equiv._proof_5 | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_2} {B : Type u_1} [inst : CommSemiring A] {I : Ideal A} [inst_1 : CommSemiring B] {J : Ideal B}
{e : A ≃+* B} (h : Ideal.map e I = J) (hJ : DividedPowers J),
DividedPowers.ofRingEquiv h (DividedPowers.ofRingEquiv ⋯ hJ) = hJ | null | false |
Rep.Hom.ctorIdx | Mathlib.RepresentationTheory.Rep.Basic | {k : Type u} → {G : Type v} → {inst : Semiring k} → {inst_1 : Monoid G} → {A B : Rep.{w, u, v} k G} → A.Hom B → ℕ | null | false |
Action.instIsEquivalenceFunctorSingleObjInverse | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} V] (G : Type u_2) [inst_1 : Monoid G],
Action.FunctorCategoryEquivalence.inverse.IsEquivalence | null | true |
_private.Mathlib.Combinatorics.Graph.Simple.0.Graph.instSimpleBot._proof_1 | Mathlib.Combinatorics.Graph.Simple | ∀ {α : Type u_1} {β : Type u_2}, ⊥.Simple | null | false |
Bialgebra.IsPrimitiveElem.antipode_antipode | Mathlib.RingTheory.HopfAlgebra.Primitive | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : HopfAlgebra R A] {a : A},
Bialgebra.IsPrimitiveElem R a → (HopfAlgebraStruct.antipode R) ((HopfAlgebraStruct.antipode R) a) = a | null | true |
ContinuousAlternatingMap.smulRight_apply | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {ι : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [inst_5 : TopologicalSpace R]
[inst_6 : TopologicalSpace M] [inst_7 : TopologicalSpace N] [inst_8 : ContinuousSMul R N] (f : M [⋀^ι]... | null | true |
Std.DTreeMap.Raw.toArray_keys | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp}, t.keys.toArray = t.keysArray | null | true |
IsSimpleOrder.linearOrder._proof_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [IsSimpleOrder α] (a b : α), a ≤ b ∨ b ≤ a | null | false |
HeytingHom.instPartialOrder._proof_1 | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : HeytingAlgebra α] [inst_1 : HeytingAlgebra β], Function.Injective DFunLike.coe | null | false |
ciInf_subtype_fun | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {ι : Type u_6} {s : Set ι} {f : ι → α},
BddBelow (Set.range fun i => f ↑i) → ⨅ i, f ↑i ≤ sInf ∅ → ⨅ i, f ↑i = ⨅ t ∈ s, f t | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Equiv.Perm.mem_toList_iff._simp_1_2 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} {f : α → α} {a : α} {n : ℕ} {b : α}, (b ∈ List.iterate f a n) = ∃ m < n, b = f^[m] a | null | false |
Std.DTreeMap.Internal.Impl.getKey!_inter_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [inst : Inhabited α]
[Std.TransOrd α] (h₁ : m₁.WF),
m₂.WF → ∀ {k : α}, Std.DTreeMap.Internal.Impl.contains k m₂ = false → (m₁.inter m₂ ⋯).getKey! k = default | null | true |
SSet.PtSimplex.MulStruct.δ_succ_castSucc_map | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g fg : X.PtSimplex n x} {i : Fin n}
(self : f.MulStruct g fg i), CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.succ) self.map = fg.map | null | true |
Inclusion.IVar.mk | Mathlib.Tactic.Inclusion.Core.Types | Inclusion.IExpr → Lean.Expr → Lean.Expr → Option Lean.Expr → Inclusion.IVar | null | true |
NonUnitalSubalgebra.center.instNonUnitalCommRing._aux_3 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | {R : Type u_2} →
[inst : CommSemiring R] →
{A : Type u_1} →
[inst_1 : NonUnitalNonAssocRing A] →
[inst_2 : Module R A] →
[inst_3 : IsScalarTower R A A] →
[inst_4 : SMulCommClass R A A] →
↥(NonUnitalSubalgebra.center R A) → ↥(NonUnitalSubalgebra.center R A) → ↥(Non... | null | false |
egauge_ball_le_of_one_lt_norm | Mathlib.Analysis.Convex.EGauge | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] {E : Type u_2} [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{c : 𝕜} {x : E} {r : NNReal}, 1 < ‖c‖ → r ≠ 0 ∨ ‖x‖ ≠ 0 → egauge 𝕜 (Metric.ball 0 ↑r) x ≤ ‖c‖ₑ * ‖x‖ₑ / ↑r | null | true |
AdjoinRoot.instCommRing._proof_45 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f : Polynomial R) (n : ℕ), IntCast.intCast ↑n = ↑n | null | false |
_private.Mathlib.Algebra.Star.Unitary.0.Pi.mem_unitary_iff._simp_1_3 | Mathlib.Algebra.Star.Unitary | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | null | false |
Mathlib.Tactic.TermCongr.CongrResult.noConfusionType | Mathlib.Tactic.TermCongr | Sort u → Mathlib.Tactic.TermCongr.CongrResult → Mathlib.Tactic.TermCongr.CongrResult → Sort u | null | false |
Lean.QuotKind.ctor.sizeOf_spec | Lean.Declaration | sizeOf Lean.QuotKind.ctor = 1 | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.pos_iff_ne_zero._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a < b) = (a ≤ b ∧ a ≠ b) | null | false |
CompleteAtomicBooleanAlgebra.toCompleteBooleanAlgebra | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → [self : CompleteAtomicBooleanAlgebra α] → CompleteBooleanAlgebra α | null | true |
instFunLikeAddActionHom | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
(φ : M → N) → (X : Type u_5) → [inst : VAdd M X] → (Y : Type u_6) → [inst_1 : VAdd N Y] → FunLike (X →ₑ[φ] Y) X Y | null | true |
IsChain.pairwiseDisjoint_sUnion | Mathlib.Order.Preorder.PairwiseChain | ∀ {α : Type u_1} {β : Type u_2} {c : Set (Set α)},
IsChain (fun x1 x2 => x1 ⊆ x2) c →
∀ [inst : PartialOrder β] [inst_1 : OrderBot β] (f : α → β),
(⋃₀ c).PairwiseDisjoint f ↔ ∀ s ∈ c, s.PairwiseDisjoint f | null | true |
CategoryTheory.PreZeroHypercover.empty_X | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (S : C) (a : PEmpty.{w + 1}),
(CategoryTheory.PreZeroHypercover.empty S).X a = a.elim | null | true |
_private.Mathlib.Tactic.Linter.DeprecatedSyntaxLinter.0.Mathlib.Linter.Style.getDeprecatedSyntax._sparseCasesOn_8 | Mathlib.Tactic.Linter.DeprecatedSyntaxLinter | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive_1 (Lean.Syntax.node info kind args)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
instBoundedMulOfLipschitzMul | Mathlib.Topology.Bornology.BoundedOperation | ∀ {R : Type u_1} [inst : PseudoMetricSpace R] [inst_1 : Monoid R] [LipschitzMul R], BoundedMul R | null | true |
_private.Mathlib.RingTheory.PowerSeries.Substitution.0.PowerSeries.coeff_subst_sum_C_substInvFun_mul_X_pow_sub_X._simp_1_11 | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_1} [inst : Semiring R], MvPowerSeries.constantCoeff = PowerSeries.constantCoeff | null | false |
Int8.ofNat_le_iff_le | Init.Data.SInt.Lemmas | ∀ {a b : ℕ}, a < 2 ^ 7 → b < 2 ^ 7 → (Int8.ofNat a ≤ Int8.ofNat b ↔ a ≤ b) | null | true |
_private.Mathlib.Topology.Semicontinuity.Basic.0.LowerSemicontinuousOn.disjoint_biInter_preimage_Iic_iff_exists_finset._simp_1_5 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
WeierstrassCurve.instIsEllipticOfJ1728OfFactIsUnitOfNat | Mathlib.AlgebraicGeometry.EllipticCurve.ModelsWithJ | ∀ (R : Type u_1) [inst : CommRing R] [hu : Fact (IsUnit 2)], (WeierstrassCurve.ofJ1728 R).IsElliptic | When 2 is a unit, `Y² = X³ + X` is an elliptic curve.
It is of j-invariant 1728 (see `WeierstrassCurve.ofJ1728_j`). | true |
AddRightCancelMonoid.toAddMonoid_injective | Mathlib.Algebra.Group.Ext | ∀ {M : Type u}, Function.Injective (@AddRightCancelMonoid.toAddMonoid M) | null | true |
Subsemigroup.mem_sInf | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] {S : Set (Subsemigroup M)} {x : M}, x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p | null | true |
Homeomorph.inv₀._proof_2 | Mathlib.Topology.Algebra.GroupWithZero | ∀ (G₀ : Type u_1) [inst : GroupWithZero G₀] (g : { g // g ≠ 0 }), (↑g)⁻¹ ≠ 0 | null | false |
MvPolynomial.instAddCommGroupR._proof_19 | Mathlib.FieldTheory.Finite.Polynomial | ∀ (σ K : Type u_1) [inst : Fintype K] [inst_1 : CommRing K],
autoParam (∀ (a : MvPolynomial.R σ K), 0 • a = 0) SubNegMonoid.zsmul_zero'._autoParam | null | false |
ReflBEq.casesOn | Init.Core | {α : Type u_1} →
[inst : BEq α] →
{motive : ReflBEq α → Sort u} → (t : ReflBEq α) → ((rfl : ∀ {a : α}, (a == a) = true) → motive ⋯) → motive t | null | false |
_private.Mathlib.MeasureTheory.Measure.Prokhorov.0.MeasureTheory.exists_measure_iUnion_gt_of_isCompact_closure._simp_1_6 | Mathlib.MeasureTheory.Measure.Prokhorov | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {P : β → Prop},
(∀ᶠ (b : β) in Filter.map m f, P b) = ∀ᶠ (a : α) in f, P (m a) | null | false |
Units.coe_neg_one | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α], ↑(-1) = -1 | null | true |
AddCommGrpCat.Hom.rec | Mathlib.Algebra.Category.Grp.Basic | {A B : AddCommGrpCat} →
{motive : A.Hom B → Sort u_1} → ((hom' : ↑A →+ ↑B) → motive { hom' := hom' }) → (t : A.Hom B) → motive t | null | false |
Tactic.ComputeAsymptotics.Seq.FriendlyOperation.ite | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} {op₁ op₂ : Stream'.Seq α → Stream'.Seq α},
Tactic.ComputeAsymptotics.Seq.FriendlyOperation op₁ →
Tactic.ComputeAsymptotics.Seq.FriendlyOperation op₂ →
∀ {P : Option α → Prop} [inst : DecidablePred P],
Tactic.ComputeAsymptotics.Seq.FriendlyOperation fun s => if P s.head then op₁ s el... | null | true |
AddCommGroup.zmodModule._proof_1 | Mathlib.Algebra.Module.ZMod | ∀ (n : ℕ), NeZero (n + 1) | null | false |
LocallyConstant.toContinuousMapLinearMap_apply | Mathlib.Topology.ContinuousMap.LocallyConstant | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (R : Type u_3)
[inst_2 : Semiring R] [inst_3 : AddCommMonoid Y] [inst_4 : Module R Y] [inst_5 : ContinuousAdd Y]
[inst_6 : ContinuousConstSMul R Y] (f : LocallyConstant X Y), (LocallyConstant.toContinuousMapLinearMap R) f = ↑f | null | true |
NumberField.integralBasis_apply | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(i : Module.Free.ChooseBasisIndex ℤ (NumberField.RingOfIntegers K)),
(NumberField.integralBasis K) i =
(algebraMap (NumberField.RingOfIntegers K) K) ((NumberField.RingOfIntegers.basis K) i) | null | true |
SchwartzMap.instAddCommGroup._proof_11 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (a b : SchwartzMap E F), a + b = b + a | null | false |
Height.mulHeight₁_pos | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] (x : K), 0 < Height.mulHeight₁ x | null | true |
Real.continuous_arsinh | Mathlib.Analysis.SpecialFunctions.Arsinh | Continuous Real.arsinh | null | true |
TensorialAt.mkHom._proof_5 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {M : Type u_4} [inst_1 : TopologicalSpace M] {F : Type u_3}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 F] {V : M → Type u_2}
[inst_4 : TopologicalSpace (Bundle.TotalSpace F V)] [inst_5 : (x : M) → AddCommGroup (V x)]
[inst_6 : (x : M) → Module 𝕜... | null | false |
_private.Init.Data.String.Basic.0.String.Slice.Pos.copy._proof_1 | Init.Data.String.Basic | ∀ {s : String.Slice} (pos : s.Pos), String.Pos.Raw.IsValid s.copy pos.offset | null | false |
HurwitzZeta.differentiableAt_completedCosZeta | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : UnitAddCircle) {s : ℂ}, s ≠ 0 → s ≠ 1 ∨ a ≠ 0 → DifferentiableAt ℂ (HurwitzZeta.completedCosZeta a) s | null | true |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.mulLeftMono.match_3 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (α : Type u_1) (r : α → α → Prop) (wo : IsWellOrder α r)
(motive : (x : WellOrder) → ⟦{ α := α, r := r, wo := wo }⟧ ≤ ⟦x⟧ → Prop) (x : WellOrder)
(x_1 : ⟦{ α := α, r := r, wo := wo }⟧ ≤ ⟦x⟧),
(∀ (β : Type u_1) (s : β → β → Prop) (wo_1 : IsWellOrder β s)
(x : ⟦{ α := α, r := r, wo := wo }⟧ ≤ ⟦{ α := β, r :... | null | false |
CalcParams.indent | Mathlib.Tactic.Widget.Calc | CalcParams → ℕ | indentation level of the calc block. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.