name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
One.gOne | Mathlib.Algebra.GradedMonoid | (ι : Type u_1) → {R : Type u_2} → [inst : Zero ι] → [One R] → GradedMonoid.GOne fun x => R |
MvPolynomial.optionEquivRight._proof_4 | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u_1) (S₁ : Type u_2) [inst : CommSemiring R],
(MvPolynomial.aevalTower (Polynomial.aeval (MvPolynomial.X none)) fun i => MvPolynomial.X (some i)).comp
(MvPolynomial.aeval fun o => o.elim (MvPolynomial.C Polynomial.X) MvPolynomial.X) =
AlgHom.id R (MvPolynomial (Option S₁) R) |
Lean.AttributeKind | Lean.Attributes | Type |
CategoryTheory.CostructuredArrow.ofCommaFstEquivalenceFunctor_obj_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor C T)
(G : CategoryTheory.Functor D T) (c : C) (X : CategoryTheory.CostructuredArrow (CategoryTheory.Comma.fst F G) c),
((CategoryTheory.CostructuredArrow.ofCommaFstEquivalenceFunctor F G c).obj X).right = X.left.right |
Set.bounded_ge_of_bounded_gt | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : Preorder α],
Set.Bounded (fun x1 x2 => x1 > x2) s → Set.Bounded (fun x1 x2 => x1 ≥ x2) s |
_private.Init.Data.String.Iterator.0.String.Pos.Raw.get?.match_1.splitter | Init.Data.String.Iterator | (motive : String → String.Pos.Raw → Sort u_1) →
(x : String) → (x_1 : String.Pos.Raw) → ((s : String) → (p : String.Pos.Raw) → motive s p) → motive x x_1 |
CategoryTheory.LocalizerMorphism.RightResolution.mk.injEq | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂} {X₁ : C₁}
(w : X₂ ⟶ Φ.functor.obj X₁) (hw : W₂ w) (X₁_1 : C₁) (w_1 : X₂ ⟶ Φ.functor.obj X₁_1) (hw_1 : W₂ w_1),
({ X₁ := X₁, w := w, hw := hw } = { X₁ := X₁_1, w := w_1, hw := hw_1 }) = (X₁ = X₁_1 ∧ w ≍ w_1) |
NumberField.abs_discr_gt_two | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K], 1 < Module.finrank ℚ K → 2 < |NumberField.discr K| |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsPath.tail._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.IsPath = p.support.Nodup |
Lean.Meta.LibrarySearch.DeclMod.mpr | Lean.Meta.Tactic.LibrarySearch | Lean.Meta.LibrarySearch.DeclMod |
Order.Icc_subset_Ioc_pred_left_of_not_isMin | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α}, ¬IsMin a → Set.Icc a b ⊆ Set.Ioc (Order.pred a) b |
PiTensorProduct.congr._proof_2 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {t : ι → Type u_4} [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i ≃ₗ[R] t i),
((PiTensorProduct.map fun i => ↑(f i).symm) ∘ₗ PiTensorProduct.map fun i => ↑(f i)) = LinearMap.id |
Lean.Parser.Term.suffices._regBuiltin.Lean.Parser.Term.fromTerm.formatter_7 | Lean.Parser.Term | IO Unit |
Affine.Simplex.instFintypePointsWithCircumcenterIndex.match_5 | Mathlib.Geometry.Euclidean.Circumcenter | (n : ℕ) →
(motive : Affine.Simplex.PointsWithCircumcenterIndex n → Sort u_1) →
(x : Affine.Simplex.PointsWithCircumcenterIndex n) →
((a : Fin (n + 1)) → motive (Affine.Simplex.PointsWithCircumcenterIndex.pointIndex a)) →
(Unit → motive Affine.Simplex.PointsWithCircumcenterIndex.circumcenterIndex) → motive x |
ProofWidgets.instRpcEncodableExprPresentationData.dec._@.ProofWidgets.Presentation.Expr.2260322628._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) ProofWidgets.ExprPresentationData |
LinearEquiv.toLinearEquiv_toContinuousLinearEquiv_symm | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F : Type w}
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜 F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologicalAddGroup F]
[inst_9 : ContinuousSMul 𝕜 F] [inst_10 : CompleteSpace 𝕜] [inst_11 : T2Space E] [inst_12 : T2Space F]
[inst_13 : FiniteDimensional 𝕜 E] (e : E ≃ₗ[𝕜] F), e.toContinuousLinearEquiv.symm.toLinearEquiv = e.symm |
_private.Mathlib.Geometry.Manifold.VectorBundle.Tangent.0.contMDiffAt_vectorSpace_iff_contDiffAt._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.Tangent | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {x : M} {n : WithTop ℕ∞},
ContMDiffAt I I' n f x = ContMDiffWithinAt I I' n f Set.univ x |
Lean.Meta.DiagSummary.mk.sizeOf_spec | Lean.Meta.Diagnostics | ∀ (data : Array Lean.MessageData) (max : ℕ), sizeOf { data := data, max := max } = 1 + sizeOf data + sizeOf max |
Stream'.WSeq.bind.eq_1 | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {β : Type v} (s : Stream'.WSeq α) (f : α → Stream'.WSeq β), s.bind f = (Stream'.WSeq.map f s).join |
_private.Mathlib.Topology.Spectral.Prespectral.0.PrespectralSpace.exists_isClosed_of_not_isPreirreducible._simp_1_8 | Mathlib.Topology.Spectral.Prespectral | ∀ {a : Prop}, (¬¬a) = a |
forall_le_imp_ne_iff_lt | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ c ≤ a, c ≠ b) ↔ a < b |
CategoryTheory.HasSplitEqualizer.rec | Mathlib.CategoryTheory.Limits.Shapes.SplitEqualizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.HasSplitEqualizer f g → Sort u_1} →
((splittable : ∃ W h, Nonempty (CategoryTheory.IsSplitEqualizer f g h)) → motive ⋯) →
(t : CategoryTheory.HasSplitEqualizer f g) → motive t |
FourierTransform.fourierInvₗ | Mathlib.Analysis.Fourier.Notation | (R : Type u_2) →
(E : Type u_3) →
{F : Type u_4} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid E] →
[inst_2 : AddCommMonoid F] →
[inst_3 : Module R E] →
[inst_4 : Module R F] →
[inst_5 : FourierTransformInv E F] → [FourierInvAdd E F] → [FourierInvSMul R E F] → E →ₗ[R] F |
IsDedekindDomain.FiniteAdeleRing.algebraMap._proof_9 | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (x y : K),
⟨fun i => ↑((WithVal.equiv (IsDedekindDomain.HeightOneSpectrum.valuation K i)).symm (x + y)), ⋯⟩ =
⟨fun i => ↑((WithVal.equiv (IsDedekindDomain.HeightOneSpectrum.valuation K i)).symm x), ⋯⟩ +
⟨fun i => ↑((WithVal.equiv (IsDedekindDomain.HeightOneSpectrum.valuation K i)).symm y), ⋯⟩ |
Std.Roo.toArray_succ_succ_eq_map | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[Std.PRange.LinearlyUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.PRange.InfinitelyUpwardEnumerable α] [inst_6 : Std.Rxo.IsAlwaysFinite α]
[inst_7 : Std.PRange.LawfulUpwardEnumerable α] {lo hi : α},
((Std.PRange.succ lo)<...Std.PRange.succ hi).toArray = Array.map Std.PRange.succ (lo<...hi).toArray |
LieSubmodule.noConfusionType | Mathlib.Algebra.Lie.Submodule | Sort u_1 →
{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] →
LieSubmodule R L M →
{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'] → LieSubmodule R' L' M' → Sort u_1 |
Lean.Elab.InlayHintLinkLocation.noConfusion | Lean.Elab.InfoTree.InlayHints | {P : Sort u} →
{t t' : Lean.Elab.InlayHintLinkLocation} → t = t' → Lean.Elab.InlayHintLinkLocation.noConfusionType P t t' |
CategoryTheory.shrinkYonedaMonObjObjEquiv | Mathlib.CategoryTheory.Monoidal.Cartesian.ShrinkYoneda | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] →
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] →
{M : CategoryTheory.Mon C} →
{Y : Cᵒᵖ} → ↑((CategoryTheory.shrinkYonedaMon.{w, v, u}.obj M).obj Y) ≃* (Opposite.unop Y ⟶ M.X) |
CategoryTheory.Limits.HasKernels.rec | Mathlib.CategoryTheory.Limits.Shapes.Kernels | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{motive : CategoryTheory.Limits.HasKernels C → Sort u_1} →
((has_limit : ∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.Limits.HasKernel f) → motive ⋯) →
(t : CategoryTheory.Limits.HasKernels C) → motive t |
AddSubmonoid.nsmulSaturated_iff_nsmul | Mathlib.GroupTheory.Subgroup.Saturated | ∀ {G : Type u_1} [inst : AddMonoid G] {H : AddSubmonoid G},
H.NSMulSaturated ↔ ∀ (n : ℕ) (g : G), n • g ∈ H → n = 0 ∨ g ∈ H |
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 |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.tryAutoCongrTheorem?.match_15 | Lean.Meta.Tactic.Simp.Types | (motive :
MProd (Subarray Lean.Expr)
(MProd (Subarray Lean.Meta.CongrArgKind) (MProd ℕ (MProd Lean.Expr (MProd (Array Lean.Expr) Lean.Expr)))) →
Sort u_1) →
(x :
MProd (Subarray Lean.Expr)
(MProd (Subarray Lean.Meta.CongrArgKind) (MProd ℕ (MProd Lean.Expr (MProd (Array Lean.Expr) Lean.Expr))))) →
((__s : Subarray Lean.Expr) →
(__s_1 : Subarray Lean.Meta.CongrArgKind) →
(j : ℕ) →
(proof : Lean.Expr) →
(subst : Array Lean.Expr) → (type : Lean.Expr) → motive ⟨__s, __s_1, j, proof, subst, type⟩) →
motive x |
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₁ |
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 ⟶ S) ⦃i₁ i₂ : ι⦄ (f₁ : Y ⟶ X i₁) (f₂ : Y ⟶ X i₂)
(hf₁ : CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q)
(hf₂ : CategoryTheory.CategoryStruct.comp f₂ (f i₂) = q),
CategoryTheory.CategoryStruct.comp ((F.map f₁.op.toLoc).toFunctor.map (hom i₁)) (D₂.hom q f₁ f₂ ⋯ ⋯) =
CategoryTheory.CategoryStruct.comp (D₁.hom q f₁ f₂ ⋯ ⋯) ((F.map f₂.op.toLoc).toFunctor.map (hom i₂)))
CategoryTheory.Pseudofunctor.DescentData.Hom.comm._autoParam}
{hom_1 : (i : ι) → D₁.obj i ⟶ D₂.obj i}
{comm_1 :
autoParam
(∀ ⦃Y : C⦄ (q : Y ⟶ S) ⦃i₁ i₂ : ι⦄ (f₁ : Y ⟶ X i₁) (f₂ : Y ⟶ X i₂)
(hf₁ : CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q)
(hf₂ : CategoryTheory.CategoryStruct.comp f₂ (f i₂) = q),
CategoryTheory.CategoryStruct.comp ((F.map f₁.op.toLoc).toFunctor.map (hom_1 i₁)) (D₂.hom q f₁ f₂ ⋯ ⋯) =
CategoryTheory.CategoryStruct.comp (D₁.hom q f₁ f₂ ⋯ ⋯) ((F.map f₂.op.toLoc).toFunctor.map (hom_1 i₂)))
CategoryTheory.Pseudofunctor.DescentData.Hom.comm._autoParam},
{ hom := hom, comm := comm } = { hom := hom_1, comm := comm_1 } → hom = hom_1 |
Stream'.Seq.nil.eq_1 | Mathlib.Data.Seq.Basic | ∀ {α : Type u}, Stream'.Seq.nil = ⟨Stream'.const none, ⋯⟩ |
Mathlib.Meta.FunProp.Mor.app | Mathlib.Tactic.FunProp.Mor | Lean.Expr → Mathlib.Meta.FunProp.Mor.Arg → Lean.Expr |
_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 |
_private.Lean.Elab.Deriving.DecEq.0.Lean.Elab.Deriving.DecEq.mkDecEqCmds | Lean.Elab.Deriving.DecEq | Lean.InductiveVal → Lean.Elab.TermElabM (Array Lean.Syntax) |
Std.TreeMap.getElem!_emptyc | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Inhabited β] {a : α}, ∅[a]! = default |
_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) |
Vector.pop_append_of_size_ne_zero._proof_2 | Init.Data.Vector.Lemmas | ∀ {n m : ℕ}, m ≠ 0 → n + (m - 1) = n + m - 1 |
_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 |
_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 |
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 |
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 |
Membership.get_elem_helper | Init.Data.Range.Basic | ∀ {i n : ℕ} {r : Std.Legacy.Range}, i ∈ r → r.stop = n → i < n |
LowerSet.instAdd | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} → [inst : AddCommGroup α] → [inst_1 : Preorder α] → [IsOrderedAddMonoid α] → Add (LowerSet α) |
Std.Internal.Parsec.ByteArray.skipWhileUpTo | Std.Internal.Parsec.ByteArray | (UInt8 → Bool) → ℕ → Std.Internal.Parsec.ByteArray.Parser Unit |
Matroid.RankInfinite | Mathlib.Combinatorics.Matroid.Basic | {α : Type u_1} → Matroid α → Prop |
MonoidAlgebra.uniqueRingEquiv_apply | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} (M : Type u_4) [inst : Semiring R] [inst_1 : Monoid M] [inst_2 : Unique M] (a : M →₀ R),
(MonoidAlgebra.uniqueRingEquiv M) a = a default |
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 |
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 => f k' x) (Std.DTreeMap.Internal.Impl.Const.get? t k)).get! |
Lean.Meta.Sym.Simp.instNonemptyMethodsRef | Lean.Meta.Sym.Simp.SimpM | Nonempty Lean.Meta.Sym.Simp.MethodsRef |
Lean.Parser.Command.open._regBuiltin.Lean.Parser.Command.openHiding.formatter_9 | Lean.Parser.Command | IO Unit |
_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 |
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)) |
instAddRightCancelMonoidLex.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : AddRightCancelMonoid α], instAddRightCancelMonoidLex = h |
CStarAlgebra.noConfusionType | Mathlib.Analysis.CStarAlgebra.Classes | Sort u → {A : Type u_1} → CStarAlgebra A → {A' : Type u_1} → CStarAlgebra A' → Sort u |
Stream'.head | Mathlib.Data.Stream.Defs | {α : Type u} → Stream' α → α |
_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) |
Int.prime_three | Mathlib.Data.Nat.Prime.Int | Prime 3 |
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 |
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) |
_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 |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | Type |
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 |
_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 |
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 |
AddSubsemigroup.center.eq_1 | Mathlib.GroupTheory.Subsemigroup.Center | ∀ (M : Type u_1) [inst : Add M], AddSubsemigroup.center M = { carrier := Set.addCenter M, add_mem' := ⋯ } |
_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 |
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.Limits.Cofork.π c.inlCokernelCofork)
(CategoryTheory.CategoryStruct.comp c.inr s.π) =
s.π |
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₀ =
CategoryTheory.CategoryStruct.comp h.p CategoryTheory.Limits.prod.fst |
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 |
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 ⋯)
(CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkPushforward C f F x) h_1) =
CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkPushforward C f F y)
(CategoryTheory.CategoryStruct.comp (F.stalkSpecializes h) h_1) |
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 α |
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 |
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 |
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 [⋀^ι]→L[R] R) (z : N)
(a : (i : ι) → (fun x => M) i), (f.smulRight z) a = f a • z |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ExceptCondsDefault.other.sizeOf_spec | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | ∀ (e : Lean.Expr), sizeOf (Lean.Elab.Tactic.Do.ExceptCondsDefault.other✝ e) = 1 + sizeOf e |
IsSimpleOrder.linearOrder._proof_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] [IsSimpleOrder α] (a b : α), a ≤ b ∨ b ≤ a |
HeytingHom.instPartialOrder._proof_1 | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : HeytingAlgebra α] [inst_1 : HeytingAlgebra β], Function.Injective fun f => ⇑f |
_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 |
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 |
Lean.Parser.Command.macro._regBuiltin.Lean.Parser.Command.macroArg.parenthesizer_23 | Lean.Parser.Syntax | IO Unit |
SSet.PtSimplex.MulStruct.δ_succ_castSucc_map | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op (SimplexCategory.mk 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 |
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 |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Traversal.0.SimpleGraph.Walk.penultimate_mem_dropLast_support._proof_1_7 | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v},
¬p.support.length - 1 + 1 ≤ p.support.dropLast.length →
p.support.length - (p.support.dropLast.length + 1) < [p.support.getLast ⋯].length |
Mathlib.Tactic.TermCongr.CongrResult.noConfusionType | Mathlib.Tactic.TermCongr | Sort u → Mathlib.Tactic.TermCongr.CongrResult → Mathlib.Tactic.TermCongr.CongrResult → Sort u |
FreeAbelianGroup.nonUnitalNonAssocRing._proof_14 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u_1} [inst : Mul α] (a b c : FreeAbelianGroup α), (a + b) * c = a * c + b * c |
Lean.QuotKind.ctor.sizeOf_spec | Lean.Declaration | sizeOf Lean.QuotKind.ctor = 1 |
_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) |
CompleteAtomicBooleanAlgebra.toCompleteBooleanAlgebra | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → [self : CompleteAtomicBooleanAlgebra α] → CompleteBooleanAlgebra α |
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 |
IsChain.pairwiseDisjoint_sUnion | Mathlib.Data.Set.Pairwise.Chain | ∀ {α : 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 |
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 |
instBoundedMulOfLipschitzMul | Mathlib.Topology.Bornology.BoundedOperation | ∀ {R : Type u_1} [inst : PseudoMetricSpace R] [inst_1 : Monoid R] [LipschitzMul R], BoundedMul R |
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) |
WeierstrassCurve.instIsEllipticOfJ1728OfFactIsUnitOfNat | Mathlib.AlgebraicGeometry.EllipticCurve.ModelsWithJ | ∀ (R : Type u_1) [inst : CommRing R] [hu : Fact (IsUnit 2)], (WeierstrassCurve.ofJ1728 R).IsElliptic |
AddRightCancelMonoid.toAddMonoid_injective | Mathlib.Algebra.Group.Ext | ∀ {M : Type u}, Function.Injective (@AddRightCancelMonoid.toAddMonoid M) |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.