name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Dynamics.OmegaLimit.0.Flow.omegaLimit_image_subset._simp_1_1 | Mathlib.Dynamics.OmegaLimit | ∀ {τ : Type u_1} [inst : AddMonoid τ] [inst_1 : TopologicalSpace τ] [inst_2 : ContinuousAdd τ] {α : Type u_2}
[inst_3 : TopologicalSpace α] (ϕ : Flow τ α) (t₁ t₂ : τ) (x : α), ϕ.toFun t₁ (ϕ.toFun t₂ x) = ϕ.toFun (t₁ + t₂) x |
Ultrafilter.semigroup._proof_1 | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] (U V W : Ultrafilter M), U * V * W = U * (V * W) |
LocallyFinite.Realizer.mk.inj | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} {β : Type u_2} {inst : TopologicalSpace α} {F : Ctop.Realizer α} {f : β → Set α}
{bas : (a : α) → { s // a ∈ F.F.f s }} {sets : (x : α) → Fintype ↑{i | (f i ∩ F.F.f ↑(bas x)).Nonempty}}
{bas_1 : (a : α) → { s // a ∈ F.F.f s }} {sets_1 : (x : α) → Fintype ↑{i | (f i ∩ F.F.f ↑(bas_1 x)).Nonempty}},
{ bas := bas, sets := sets } = { bas := bas_1, sets := sets_1 } → bas = bas_1 ∧ sets ≍ sets_1 |
CategoryTheory.ShortComplex.Hom.noConfusion | Mathlib.Algebra.Homology.ShortComplex.Basic | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{t : S₁.Hom S₂} →
{C' : Type u_1} →
{inst' : CategoryTheory.Category.{v_1, u_1} C'} →
{inst'_1 : CategoryTheory.Limits.HasZeroMorphisms C'} →
{S₁' S₂' : CategoryTheory.ShortComplex C'} →
{t' : S₁'.Hom S₂'} →
C = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
S₁ ≍ S₁' → S₂ ≍ S₂' → t ≍ t' → CategoryTheory.ShortComplex.Hom.noConfusionType P t t' |
_private.Mathlib.Analysis.Complex.BorelCaratheodory.0.Complex.eq_mul_div_one_add_of_eq_div_sub._simp_1_7 | Mathlib.Analysis.Complex.BorelCaratheodory | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
OreLocalization.left_distrib | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
(x y z : OreLocalization S R), x * (y + z) = x * y + x * z |
Nat.multichoose_zero_succ | Mathlib.Data.Nat.Choose.Basic | ∀ (k : ℕ), Nat.multichoose 0 (k + 1) = 0 |
Finite.of_subsingleton | Mathlib.Data.Fintype.EquivFin | ∀ {α : Sort u_4} [Subsingleton α], Finite α |
ULift.normedAddCommGroup._proof_1 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], AddMonoidHomClass (ULift.{u_2, u_1} E →+ E) (ULift.{u_2, u_1} E) E |
MeasurableSpace.DynkinSystem.instPartialOrder._proof_4 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} (x x_1 : MeasurableSpace.DynkinSystem α), x ≤ x_1 → x_1 ≤ x → x = x_1 |
IsLocalization.ringEquivOfRingEquiv._proof_2 | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_4} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_1) [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {T : Submonoid P}
(Q : Type u_2) [inst_5 : CommSemiring Q] [inst_6 : Algebra P Q] [inst_7 : IsLocalization T Q] (h : R ≃+* P)
(H : Submonoid.map h.toMonoidHom M = T) (H' : Submonoid.map h.symm.toMonoidHom T = M) (x : S),
(IsLocalization.map S ↑h.symm ⋯) ((IsLocalization.map Q ↑h ⋯) x) = x |
Lean.Elab.Command.ElabHeaderResult | Lean.Elab.MutualInductive | Type |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.reduceStep._sparseCasesOn_1 | Lean.Meta.Tactic.Simp.Main | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t |
singleton_sub_closedBall_zero | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x : E), {x} - Metric.closedBall 0 δ = Metric.closedBall x δ |
CochainComplex.ConnectData.restrictionLEIso | Mathlib.Algebra.Homology.Embedding.Connect | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{K : ChainComplex C ℕ} →
{L : CochainComplex C ℕ} →
(h : CochainComplex.ConnectData K L) →
HomologicalComplex.restriction h.cochainComplex (ComplexShape.embeddingUpIntLE (-1)) ≅ K |
FirstOrder.Language.Functions.apply₂.eq_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {α : Type u'} (f : L.Functions 2) (t₁ t₂ : L.Term α),
f.apply₂ t₁ t₂ = FirstOrder.Language.func f ![t₁, t₂] |
CategoryTheory.Center.Hom.rec | Mathlib.CategoryTheory.Monoidal.Center | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X Y : CategoryTheory.Center C} →
{motive : X.Hom Y → Sort u} →
((f : X.fst ⟶ Y.fst) →
(comm :
∀ (U : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f U)
(Y.snd.β U).hom =
CategoryTheory.CategoryStruct.comp (X.snd.β U).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft U f)) →
motive { f := f, comm := comm }) →
(t : X.Hom Y) → motive t |
Fin.finsetImage_val_Ioi | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (a : Fin n), Finset.image Fin.val (Finset.Ioi a) = Finset.Ioo (↑a) n |
Std.ExtHashSet.get!_union_of_not_mem_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : Inhabited α] [inst_1 : EquivBEq α]
[inst_2 : LawfulHashable α] {k : α}, k ∉ m₁ → (m₁ ∪ m₂).get! k = m₂.get! k |
List.isChain_map_of_isChain | Mathlib.Data.List.Chain | ∀ {α : Type u} {β : Type v} {R : α → α → Prop} {S : β → β → Prop} (f : α → β),
(∀ (a b : α), R a b → S (f a) (f b)) → ∀ {l : List α}, List.IsChain R l → List.IsChain S (List.map f l) |
Matrix.single_add | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : AddZeroClass α]
(i : m) (j : n) (a b : α), Matrix.single i j (a + b) = Matrix.single i j a + Matrix.single i j b |
LeanSearchClient.SearchServer.queryNum | LeanSearchClient.Syntax | LeanSearchClient.SearchServer → Lean.CoreM ℕ |
CategoryTheory.Limits.isColimitOfHasCokernelOfPreservesColimit.congr_simp | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(G : CategoryTheory.Functor C D) [inst_4 : G.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y)
[inst_5 : CategoryTheory.Limits.HasCokernel f]
[inst_6 : CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f 0) G],
CategoryTheory.Limits.isColimitOfHasCokernelOfPreservesColimit G f =
CategoryTheory.Limits.isColimitOfHasCokernelOfPreservesColimit G f |
SimpleGraph.Walk.head_darts_eq_firstDart | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w} (hnil : p.darts ≠ []), p.darts.head hnil = p.firstDart ⋯ |
IO.FS.DirEntry._sizeOf_1 | Init.System.IO | IO.FS.DirEntry → ℕ |
CategoryTheory.NatTrans.naturality_1 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (α : F ⟶ G) {X Y : C} (e : X ≅ Y),
CategoryTheory.CategoryStruct.comp (F.map e.inv) (CategoryTheory.CategoryStruct.comp (α.app X) (G.map e.hom)) =
α.app Y |
wbtw_smul_vadd_smul_vadd_of_nonpos_of_le | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] (x : P) (v : V) {r₁ r₂ : R},
r₁ ≤ 0 → r₂ ≤ r₁ → Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) |
Subsemigroup.instCompleteLattice._proof_2 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] (a : Subsemigroup M), a ≤ a |
CategoryTheory.ModObj.instTensorUnit._proof_2 | Mathlib.CategoryTheory.Monoidal.Mod_ | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (X : D),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomLeft CategoryTheory.MonObj.one X)
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso X).hom =
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso X).hom |
Lean.PrefixTreeNode.Node.inj | Lean.Data.PrefixTree | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {a : Option β}
{a_1 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp} {a_2 : Option β}
{a_3 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp},
Lean.PrefixTreeNode.Node a a_1 = Lean.PrefixTreeNode.Node a_2 a_3 → a = a_2 ∧ a_1 = a_3 |
Bool.eq_and_not_self._simp_1 | Init.Data.Bool | ∀ {a b : Bool}, (b = (a && !b)) = ((!a) = true ∧ (!b) = true) |
CategoryTheory.Comonad.adj._proof_2 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (G : CategoryTheory.Comonad C) (X : G.Coalgebra) (Y : C)
(f : G.forget.obj X ⟶ Y),
CategoryTheory.CategoryStruct.comp X.a (G.map (CategoryTheory.CategoryStruct.comp X.a (G.map f))) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp X.a (G.map f)) (G.cofree.obj Y).a |
_private.Batteries.Data.List.Count.0.List.idxToSigmaCount_sigmaCountToIdx._proof_1_8 | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs : List α} {xc : (x : α) × Fin (List.count x xs)},
0 < (List.filter (fun x => x == (xs.idxToSigmaCount (xs.sigmaCountToIdx xc)).fst) xs).length |
Option.instULiftable | Mathlib.Control.ULiftable | ULiftable Option Option |
_private.Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv.0.GenContFract.squashGCF.match_3.eq_1 | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () |
CategoryTheory.ShortComplex.SnakeInput.Hom.comp_f₀ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex.SnakeInput C} (f : S₁.Hom S₂) (g : S₂.Hom S₃),
(f.comp g).f₀ = CategoryTheory.CategoryStruct.comp f.f₀ g.f₀ |
Batteries.TransCmp.casesOn | Batteries.Classes.Deprecated | {α : Sort u_1} →
{cmp : α → α → Ordering} →
{motive : Batteries.TransCmp cmp → Sort u} →
(t : Batteries.TransCmp cmp) →
([toOrientedCmp : Batteries.OrientedCmp cmp] →
(le_trans : ∀ {x y z : α}, cmp x y ≠ Ordering.gt → cmp y z ≠ Ordering.gt → cmp x z ≠ Ordering.gt) →
motive ⋯) →
motive t |
Mathlib.Tactic.AtomM.Context.mk | Mathlib.Util.AtomM | Lean.Meta.TransparencyMode → (Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result) → Mathlib.Tactic.AtomM.Context |
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.leftRightNeutral | Lean.Compiler.LCNF.Simp.ConstantFold | {α : Type} →
[Lean.Compiler.LCNF.Simp.ConstantFold.Literal α] →
[BEq α] →
(neutral : α) →
(op : α → α → α) →
autoParam (∀ (x : α), op neutral x = x) Lean.Compiler.LCNF.Simp.ConstantFold.Folder.leftRightNeutral._auto_1 →
autoParam (∀ (x : α), op x neutral = x)
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.leftRightNeutral._auto_3 →
Lean.Compiler.LCNF.Simp.ConstantFold.Folder |
Lean.Parser.Command.assertNotExists._regBuiltin.Lean.Parser.Command.assertNotExists.docString_3 | Lean.Parser.Command | IO Unit |
_private.Lean.Elab.PreDefinition.TerminationMeasure.0.Lean.Elab.TerminationMeasure.delab.go._unary | Lean.Elab.PreDefinition.TerminationMeasure | Lean.Elab.TerminationMeasure →
(_ : ℕ) ×' Lean.TSyntaxArray `ident →
Lean.PrettyPrinter.Delaborator.DelabM (Lean.TSyntax `Lean.Parser.Termination.terminationBy) |
AddCommMonCat.noConfusion | Mathlib.Algebra.Category.MonCat.Basic | {P : Sort u_1} → {t t' : AddCommMonCat} → t = t' → AddCommMonCat.noConfusionType P t t' |
CategoryTheory.ModObj.trivialAction._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mod_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(M : C) [inst_2 : CategoryTheory.MonObj M] (X : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomLeft CategoryTheory.MonObj.one X)
(CategoryTheory.SemiCartesianMonoidalCategory.snd M X) =
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso X).hom |
Vector.eraseIdx_append._proof_4 | Init.Data.Vector.Erase | ∀ {n m k : ℕ}, k < n + m → ¬k < n → k - n < m |
Lean.Meta.Grind.propagateBoolAndUp | Lean.Meta.Tactic.Grind.Propagate | Lean.Meta.Grind.Propagator |
CategoryTheory.Bicategory.postcomp₂_naturality_inv_toNatTrans_app | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} (f : a ⟶ b) {a_1 b_1 : Bᵒᵖ} (g : a_1 ⟶ b_1)
(X : ↑(CategoryTheory.Cat.of (Opposite.unop a_1 ⟶ a))),
((CategoryTheory.Bicategory.postcomp₂ f).naturality g).inv.toNatTrans.app X =
(CategoryTheory.Bicategory.associator g.unop X f).inv |
HomologicalComplex.hom_ext | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C D : HomologicalComplex V c} (f g : C ⟶ D),
(∀ (i : ι), f.f i = g.f i) → f = g |
groupHomology.isoCycles₁ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] → (A : Rep k G) → groupHomology.cycles A 1 ≅ ModuleCat.of k ↥(groupHomology.cycles₁ A) |
Lean.Meta.Sym.SharedExprs.recOn | Lean.Meta.Sym.SymM | {motive : Lean.Meta.Sym.SharedExprs → Sort u} →
(t : Lean.Meta.Sym.SharedExprs) →
((trueExpr falseExpr natZExpr btrueExpr bfalseExpr ordEqExpr intExpr : Lean.Expr) →
motive
{ trueExpr := trueExpr, falseExpr := falseExpr, natZExpr := natZExpr, btrueExpr := btrueExpr,
bfalseExpr := bfalseExpr, ordEqExpr := ordEqExpr, intExpr := intExpr }) →
motive t |
_private.Aesop.Rule.Name.0.Aesop.RuleName.Json.mk.sizeOf_spec | Aesop.Rule.Name | ∀ (name : Lean.Name) (builder : Aesop.BuilderName) (phase : Aesop.PhaseName) (scope : Aesop.ScopeName)
(rendered : String),
sizeOf { name := name, builder := builder, phase := phase, scope := scope, rendered := rendered } =
1 + sizeOf name + sizeOf builder + sizeOf phase + sizeOf scope + sizeOf rendered |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.isCycle_swap_mul_aux₂.match_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_1} [inst : DecidableEq α]
(motive :
(x : ℤ) →
(x_1 x_2 : α) →
(x_3 : Equiv.Perm α) → (Equiv.swap x_2 (x_3 x_2) * x_3) x_1 ≠ x_1 → (x_3 ^ x) (x_3 x_2) = x_1 → Prop)
(x : ℤ) (x_1 x_2 : α) (x_3 : Equiv.Perm α) (x_4 : (Equiv.swap x_2 (x_3 x_2) * x_3) x_1 ≠ x_1)
(x_5 : (x_3 ^ x) (x_3 x_2) = x_1),
(∀ (n : ℕ) (x x_6 : α) (x_7 : Equiv.Perm α) (hb : (Equiv.swap x_6 (x_7 x_6) * x_7) x ≠ x)
(h : (x_7 ^ ↑n) (x_7 x_6) = x), motive (Int.ofNat n) x x_6 x_7 hb h) →
(∀ (n : ℕ) (b x : α) (f : Equiv.Perm α) (hb : (Equiv.swap x (f x) * f) b ≠ b) (h : (f ^ Int.negSucc n) (f x) = b),
motive (Int.negSucc n) b x f hb h) →
motive x x_1 x_2 x_3 x_4 x_5 |
CategoryTheory.Pseudofunctor.mapComp'_id_comp_hom_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} {C : Type u₂} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.Pseudofunctor B C) {b₀ b₁ : B} (f : b₀ ⟶ b₁)
{Z : F.obj b₀ ⟶ F.obj b₁}
(h : CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.id b₀)) (F.map f) ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.mapComp' (CategoryTheory.CategoryStruct.id b₀) f f ⋯).hom h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (F.map f)).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapId b₀).inv (F.map f)) h) |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.isNonParametricLitValue | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → Lean.MetaM Bool |
_private.Mathlib.Algebra.BigOperators.Finprod.0.finprod_le_finprod._proof_1_1 | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoidWithZero M] {f g : α → M}
(this : Fintype ↑(Function.mulSupport f ∪ Function.mulSupport g)),
Function.mulSupport f ⊆ ↑(Function.mulSupport f ∪ Function.mulSupport g).toFinset |
_private.Mathlib.CategoryTheory.Sites.Descent.DescentData.0.CategoryTheory.Pseudofunctor.DescentData.ofObj._proof_1 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} (Y : C) (q : Y ⟶ S) (i₁ : ι) (f₁ : Y ⟶ X i₁),
CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q →
CategoryTheory.CategoryStruct.comp (f i₁).op.toLoc f₁.op.toLoc = q.op.toLoc |
AdicCompletion.liftRingHom._proof_9 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {S : Type u_1} [inst : CommRing S] (I : Ideal S) (n : ℕ), I ^ n ≤ I ^ n • ⊤ |
WithBot.le_unbot_iff._simp_2 | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithBot α} (hx : x ≠ ⊥), (a ≤ x.unbot hx) = (↑a ≤ x) |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0._regBuiltin.Int.reduceNeg.declare_24._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.2123988823._hygCtx._hyg.18 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit |
PowerSeries.binomialSeries_coeff | Mathlib.RingTheory.PowerSeries.Binomial | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : BinomialRing R] [inst_2 : Semiring A] [inst_3 : SMul R A]
(r : R) (n : ℕ), (PowerSeries.coeff n) (PowerSeries.binomialSeries A r) = Ring.choose r n • 1 |
Fintype.rec | Mathlib.Data.Fintype.Defs | {α : Type u_4} →
{motive : Fintype α → Sort u} →
((elems : Finset α) → (complete : ∀ (x : α), x ∈ elems) → motive { elems := elems, complete := complete }) →
(t : Fintype α) → motive t |
MeasureTheory.stronglyMeasurable_condExp | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | ∀ {α : Type u_1} {E : Type u_3} {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → E}
[inst : NormedAddCommGroup E] [inst_1 : CompleteSpace E] [inst_2 : NormedSpace ℝ E],
MeasureTheory.StronglyMeasurable μ[f | m] |
Lean.Declaration._sizeOf_1 | Lean.Declaration | Lean.Declaration → ℕ |
CategoryTheory.Bundled | Mathlib.CategoryTheory.ConcreteCategory.Bundled | (Type u → Type v) → Type (max (u + 1) v) |
summable_of_summable_hasDerivAt_of_isPreconnected | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} {𝕜 : Type u_3} {F : Type u_5} [inst : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜]
[inst_2 : NormedAddCommGroup F] [CompleteSpace F] {u : α → ℝ} [inst_4 : NormedSpace 𝕜 F] {g g' : α → 𝕜 → F}
{t : Set 𝕜} {y₀ y : 𝕜},
Summable u →
IsOpen t →
IsPreconnected t →
(∀ (n : α), ∀ y ∈ t, HasDerivAt (g n) (g' n y) y) →
(∀ (n : α), ∀ y ∈ t, ‖g' n y‖ ≤ u n) → y₀ ∈ t → (Summable fun x => g x y₀) → y ∈ t → Summable fun n => g n y |
_private.Std.Data.DHashMap.Raw.0.Std.DHashMap.Raw.Const.getThenInsertIfNew?.match_1 | Std.Data.DHashMap.Raw | {α : Type u_2} →
{β : Type u_1} →
(motive : (Option β × Std.DHashMap.Internal.Raw₀ α fun x => β) → Sort u_3) →
(x : Option β × Std.DHashMap.Internal.Raw₀ α fun x => β) →
((replaced : Option β) →
(r : Std.DHashMap.Raw α fun x => β) → (property : 0 < r.buckets.size) → motive (replaced, ⟨r, property⟩)) →
motive x |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.PP.0.Lean.Meta.Grind.Arith.Linear.ppStruct?.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.PP | (motive : Lean.Expr × ℚ → Sort u_1) → (x : Lean.Expr × ℚ) → ((e : Lean.Expr) → (val : ℚ) → motive (e, val)) → motive x |
_private.Lean.Meta.Tactic.Grind.Order.Proof.0.Lean.Meta.Grind.Order.mkPropagateSelfEqTrueProofOffset | Lean.Meta.Tactic.Grind.Order.Proof | Lean.Expr → Lean.Meta.Grind.Order.Weight → Lean.Meta.Grind.Order.OrderM Lean.Expr |
PrimeSpectrum.vanishingIdeal_range_comap | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S),
PrimeSpectrum.vanishingIdeal (Set.range (PrimeSpectrum.comap f)) = (RingHom.ker f).radical |
BooleanSubalgebra.instBot._proof_2 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α], ∀ x ∈ {⊥, ⊤}, ∀ ⦃b : α⦄, b ∈ {⊥, ⊤} → x ⊓ b ∈ {⊥, ⊤} |
Lean.Server.FileWorker.EditableDocumentCore.ctorIdx | Lean.Server.FileWorker.Utils | Lean.Server.FileWorker.EditableDocumentCore → ℕ |
CategoryTheory.Functor.NatTrans.hcomp_eq_whiskerRight_comp_whiskerLeft | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {F G : CategoryTheory.Functor C D}
{H K : CategoryTheory.Functor D E} (α : G ⟶ F) (β : K ⟶ H),
α ◫ β = CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight α K) (F.whiskerLeft β) |
ModuleCat.endRingEquiv_symm_apply_hom | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] (M : ModuleCat R) (f : ↑M →ₗ[R] ↑M), ModuleCat.Hom.hom (M.endRingEquiv.symm f) = f |
Mathlib.Meta.FunProp.instReprTheoremForm | Mathlib.Tactic.FunProp.Theorems | Repr Mathlib.Meta.FunProp.TheoremForm |
Std.DHashMap.instDecidableEquivOfLawfulBEq | Std.Data.DHashMap.DecidableEquiv | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
[LawfulBEq α] →
[inst_2 : Hashable α] →
[inst_3 : (k : α) → BEq (β k)] →
[∀ (k : α), LawfulBEq (β k)] → (m₁ m₂ : Std.DHashMap α β) → Decidable (m₁.Equiv m₂) |
MeasureTheory.Measure.AbsolutelyContinuous.zero | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ : MeasureTheory.Measure α), MeasureTheory.Measure.AbsolutelyContinuous 0 μ |
CategoryTheory.Triangulated.TStructure.truncLTι_comp_truncGEπ_app | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.Triangulated.TStructure C) (n : ℤ) (X : C),
CategoryTheory.CategoryStruct.comp ((t.truncLTι n).app X) ((t.truncGEπ n).app X) = 0 |
MulHom.toFun_eq_coe | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N), f.toFun = ⇑f |
ValuativeRel.ofValuation._proof_4 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {S : Type u_2} {Γ : Type u_1} [inst : CommRing S] [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation S Γ)
(x y : S), v x ≤ v y ∨ v y ≤ v x |
Equiv.Perm.equivUnitsEnd | Mathlib.Algebra.Group.End | {α : Type u_4} → Equiv.Perm α ≃* (Function.End α)ˣ |
Real.binEntropy_strictAntiOn | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | StrictAntiOn Real.binEntropy (Set.Icc 2⁻¹ 1) |
Std.Iterators.Types.Drop.rec | Std.Data.Iterators.Combinators.Monadic.Drop | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{motive : Std.Iterators.Types.Drop α m β → Sort u} →
((remaining : ℕ) → (inner : Std.IterM m β) → motive { remaining := remaining, inner := inner }) →
(t : Std.Iterators.Types.Drop α m β) → motive t |
Int16.toInt8_ofIntTruncate | Init.Data.SInt.Lemmas | ∀ {n : ℤ}, -2 ^ 15 ≤ n → n < 2 ^ 15 → (Int16.ofIntTruncate n).toInt8 = Int8.ofInt n |
CategoryTheory.Functor.instFullProdUncurry₃ | Mathlib.CategoryTheory.Functor.CurryingThree | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_4} {E : Type u_9} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_4} C₃]
[inst_3 : CategoryTheory.Category.{v_9, u_9} E], CategoryTheory.Functor.uncurry₃.Full |
BAll.imp_left | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {r p q : α → Prop}, (∀ (x : α), p x → q x) → (∀ (x : α), q x → r x) → ∀ (x : α), p x → r x |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.isMVarSwap.go._sparseCasesOn_14 | Mathlib.Tactic.Widget.LibraryRewrite | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
(Nat.hasNotBit 2048 t.ctorIdx → motive t) → motive t |
Lean.Parser.Command.openDecl.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter |
UniformSpace.Completion.instAddCommGroup | Mathlib.Topology.Algebra.GroupCompletion | {α : Type u_3} →
[inst : UniformSpace α] → [inst_1 : AddCommGroup α] → [IsUniformAddGroup α] → AddCommGroup (UniformSpace.Completion α) |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.collectInfoBasedSemanticTokens.match_9 | Lean.Server.FileWorker.SemanticHighlighting | (motive : Lean.Elab.Info → Sort u_1) →
(info : Lean.Elab.Info) →
((ti : Lean.Elab.TermInfo) → motive (Lean.Elab.Info.ofTermInfo ti)) →
((x : Lean.Elab.Info) → motive x) → motive info |
ModelWithCorners.uniqueDiffOn_preimage_source | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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) {β : Type u_4}
[inst_4 : TopologicalSpace β] {e : OpenPartialHomeomorph H β}, UniqueDiffOn 𝕜 (↑I.symm ⁻¹' e.source ∩ Set.range ↑I) |
Nat.factorization_le_iff_dvd | Mathlib.Data.Nat.Factorization.Defs | ∀ {d n : ℕ}, d ≠ 0 → n ≠ 0 → (d.factorization ≤ n.factorization ↔ d ∣ n) |
Algebra.IsCentral.mk._flat_ctor | Mathlib.Algebra.Central.Defs | ∀ {K : Type u} [inst : CommSemiring K] {D : Type v} [inst_1 : Semiring D] [inst_2 : Algebra K D],
Subalgebra.center K D ≤ ⊥ → Algebra.IsCentral K D |
_private.Init.Grind.Ring.Basic.0.Lean.Grind.Ring.intCast_nat_sub._proof_1_2 | Init.Grind.Ring.Basic | ∀ {y : ℕ} (x : ℕ), x + 1 ≥ y → ¬x + 1 = y → ¬↑(x + 1 - y) = ↑(x - y) + 1 → False |
Set.IsPWO.insert | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} [inst : Preorder α] {s : Set α}, s.IsPWO → ∀ (a : α), (insert a s).IsPWO |
Filter.Tendsto.finset_sup'_nhds_apply | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} [inst : TopologicalSpace L] {ι : Type u_3} {α : Type u_4} {s : Finset ι} {f : ι → α → L} {l : Filter α}
{g : ι → L} [inst_1 : SemilatticeSup L] [ContinuousSup L] (hne : s.Nonempty),
(∀ i ∈ s, Filter.Tendsto (f i) l (nhds (g i))) →
Filter.Tendsto (fun a => s.sup' hne fun x => f x a) l (nhds (s.sup' hne g)) |
CategoryTheory.BicartesianSq.toIsPullback | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.BicartesianSq | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
{i : Y ⟶ Z}, CategoryTheory.BicartesianSq f g h i → CategoryTheory.IsPullback f g h i |
Real.log_zpow._simp_1 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ (x : ℝ) (n : ℤ), ↑n * Real.log x = Real.log (x ^ n) |
SkewMonoidAlgebra.single_add_erase | Mathlib.Algebra.SkewMonoidAlgebra.Single | ∀ {M : Type u_4} {α : Type u_5} [inst : AddCommMonoid M] (a : α) (f : SkewMonoidAlgebra M α),
SkewMonoidAlgebra.single a (f.coeff a) + (SkewMonoidAlgebra.erase a) f = f |
_private.Init.Data.List.Nat.InsertIdx.0.List.insertIdx_eraseIdx_of_le.match_1_1 | Init.Data.List.Nat.InsertIdx | ∀ {α : Type u_1} (motive : (x x_1 : ℕ) → (x_2 : List α) → x < x_2.length → x_1 ≤ x → Prop) (x x_1 : ℕ) (x_2 : List α)
(x_3 : x < x_2.length) (x_4 : x_1 ≤ x),
(∀ (x : ℕ) (head : α) (tail : List α) (x_5 : x < (head :: tail).length) (x_6 : 0 ≤ x),
motive x 0 (head :: tail) x_5 x_6) →
(∀ (n n_1 : ℕ) (a : α) (tail : List α) (has : n + 1 < (a :: tail).length) (hmn : n_1 + 1 ≤ n + 1),
motive n.succ n_1.succ (a :: tail) has hmn) →
motive x x_1 x_2 x_3 x_4 |
Module.Free.Module.free_shrink | Mathlib.LinearAlgebra.FreeModule.Basic | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Free R M]
[inst_4 : Small.{w, v} M], Module.Free R (Shrink.{w, v} M) |
CategoryTheory.RelCat.graphFunctor._proof_3 | Mathlib.CategoryTheory.Category.RelCat | ∀ {X Y Z : Type u_1} (f : X ⟶ Y) (g : Y ⟶ Z),
{ rel := Function.graph (CategoryTheory.CategoryStruct.comp f g) } =
CategoryTheory.CategoryStruct.comp { rel := Function.graph f } { rel := Function.graph g } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.