name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Unitary.mulRight_apply | Mathlib.Analysis.CStarAlgebra.Unitary.Maps | ∀ (R : Type u_1) {A : Type u_2} [inst : NormedRing A] [inst_1 : StarRing A] [inst_2 : CStarRing A] [inst_3 : Ring R]
[inst_4 : Module R A] [inst_5 : IsScalarTower R A A] (u : ↥(unitary A)) (x : A), (Unitary.mulRight R u) x = x * ↑u |
AffineSubspace.instNontrivial | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], Nontrivial (AffineSubspace k P) |
IsStarNormal.recOn | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} →
[inst : Mul R] →
[inst_1 : Star R] →
{x : R} →
{motive : IsStarNormal x → Sort u} →
(t : IsStarNormal x) → ((star_comm_self : Commute (star x) x) → motive ⋯) → motive t |
AugmentedSimplexCategory.inl'_eval | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (x y : SimplexCategory) (i : Fin (x.len + 1)),
(SimplexCategory.Hom.toOrderHom (AugmentedSimplexCategory.inl' x y)) i = Fin.cast ⋯ (Fin.castAdd (y.len + 1) i) |
Quiver.reverse | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_4} → [inst : Quiver V] → [Quiver.HasReverse V] → {a b : V} → (a ⟶ b) → (b ⟶ a) |
Std.Time.PlainDateTime.toPlainTime | Std.Time.DateTime | Std.Time.PlainDateTime → Std.Time.PlainTime |
Parser.Attr.mfld_simps_proc | Mathlib.Tactic.Attr.Register | Lean.ParserDescr |
CategoryTheory.RetractArrow.right_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : C} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g), h.right.i = h.i.right |
ENat.floor_le._simp_1 | Mathlib.Algebra.Order.Floor.Extended | ∀ {r : ENNReal} {n : ℕ∞}, n ≠ ⊤ → (⌊r⌋ₑ ≤ n) = (r < ↑n + 1) |
Nat.isCompl_even_odd | Mathlib.Algebra.Order.Ring.Nat | IsCompl {n | Even n} {n | Odd n} |
_private.Mathlib.CategoryTheory.Sites.Hypercover.Zero.0.CategoryTheory.Precoverage.RespectsIso.of_forall_exists_iso.match_1_7 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {S : C} {R T : CategoryTheory.Presieve S}
(YR : ⦃Z : C⦄ → (g : Z ⟶ S) → R g → C) (eR : ⦃Z : C⦄ → (g : Z ⟶ S) → (a : R g) → YR g a ≅ Z),
let F :=
{ I₀ := ↑R.uncurry ⊕ ↑T.uncurry, X := fun i => Sum.elim (fun j => YR (↑j).snd ⋯) (fun j => (↑j).fst) i,
f := fun i =>
match i with
| Sum.inl i => CategoryTheory.CategoryStruct.comp (eR (↑i).snd ⋯).hom (↑i).snd
| Sum.inr i => (↑i).snd };
∀ (motive : F.I₀ → Prop) (i : F.I₀),
(∀ (i : ↑R.uncurry), motive (Sum.inl i)) → (∀ (i : ↑T.uncurry), motive (Sum.inr i)) → motive i |
Subspace.orderIsoFiniteCodimDim._proof_5 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : { W // FiniteDimensional K ↥W }ᵒᵈ),
Module.Finite K ↥(Submodule.dualAnnihilator ↑⟨Submodule.dualCoannihilator ↑(OrderDual.ofDual W), ⋯⟩) |
Metric.eventually_notMem_thickening_of_infEDist_pos | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {E : Set α} {x : α},
x ∉ closure E → ∀ᶠ (δ : ℝ) in nhds 0, x ∉ Metric.thickening δ E |
_private.Mathlib.MeasureTheory.Integral.DivergenceTheorem.0.MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_DivergenceTheorem___macroRules__private_Mathlib_MeasureTheory_Integral_DivergenceTheorem_0_MeasureTheory_term__¹_1» | Mathlib.MeasureTheory.Integral.DivergenceTheorem | Lean.Macro |
PosNum.shiftl | Mathlib.Data.Num.Bitwise | PosNum → ℕ → PosNum |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.hasBasis_nhds_zero.match_1_5 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_2} {R : Type u_1} [inst : Ring R] (motive : TwoSidedIdeal R × (σ →₀ ℕ) → Prop)
(h : TwoSidedIdeal R × (σ →₀ ℕ)), (∀ (I : TwoSidedIdeal R) (d : σ →₀ ℕ), motive (I, d)) → motive h |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.one_sub_eta_logDeriv_eq | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ (z : ℂ) (n : ℕ),
logDeriv (fun x => 1 - ModularForm.eta_q n x) z =
2 * ↑Real.pi * Complex.I * (↑n + 1) * -ModularForm.eta_q n z / (1 - ModularForm.eta_q n z) |
CategoryTheory.Over.map_map_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U V : CategoryTheory.Over X}
{g : U ⟶ V}, ((CategoryTheory.Over.map f).map g).left = g.left |
_private.Lean.Meta.Tactic.CasesOnStuckLHS.0.Lean.Meta.casesOnStuckLHS?.match_1 | Lean.Meta.Tactic.CasesOnStuckLHS | (motive : DoResultPR (Array Lean.MVarId) (Option (Array Lean.MVarId)) PUnit.{1} → Sort u_1) →
(r : DoResultPR (Array Lean.MVarId) (Option (Array Lean.MVarId)) PUnit.{1}) →
((a : Array Lean.MVarId) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Option (Array Lean.MVarId)) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r |
_private.Mathlib.Algebra.Group.Prod.0.Prod.instCancelMonoid._simp_3 | Mathlib.Algebra.Group.Prod | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b |
Std.DTreeMap.Const.getD_ofList_of_contains_eq_false | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.ofList l cmp) k fallback = fallback |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred.0.Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred.mkGetLsbD.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred | (motive : Option Lean.Expr → Sort u_1) →
(__discr : Option Lean.Expr) →
((subProof : Lean.Expr) → motive (some subProof)) → ((x : Option Lean.Expr) → motive x) → motive __discr |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect.0.Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.withBVLogicalCache.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | (motive : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical) → Sort u_1) →
(x : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical)) →
((hit : Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical) → motive (some hit)) →
(Unit → motive none) → motive x |
Mathlib.Tactic.AtomM.Recurse.Config.zetaDelta | Mathlib.Util.AtomM.Recurse | Mathlib.Tactic.AtomM.Recurse.Config → Bool |
Std.DTreeMap.Internal.Impl.insertMin!._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → (k : α) → β k → Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.minKey?_modifyKey_beq._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {o : Option α} {a : α}, (o = some a) = ∃ (h : o.isSome = true), o.get h = a |
Std.Net.SocketAddressV6.mk.noConfusion | Std.Net.Addr | {P : Sort u} →
{addr : Std.Net.IPv6Addr} →
{port : UInt16} →
{addr' : Std.Net.IPv6Addr} →
{port' : UInt16} →
{ addr := addr, port := port } = { addr := addr', port := port' } → (addr = addr' → port = port' → P) → P |
CategoryTheory.Abelian.SpectralObject.zero₂ | Mathlib.Algebra.Homology.SpectralObject.Basic | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n₀ : ℤ),
CategoryTheory.CategoryStruct.comp ((X.H n₀).map (CategoryTheory.ComposableArrows.twoδ₂Toδ₁ f g fg h))
((X.H n₀).map (CategoryTheory.ComposableArrows.twoδ₁Toδ₀ f g fg h)) =
0 |
_private.Mathlib.NumberTheory.ModularForms.NormTrace.0.ModularForm.eq_const_of_weight_zero₀._simp_1_6 | Mathlib.NumberTheory.ModularForms.NormTrace | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
IO.Process.SpawnArgs.inheritEnv._default | Init.System.IO | Bool |
PartialEquiv.trans' | Mathlib.Logic.Equiv.PartialEquiv | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} → (e : PartialEquiv α β) → (e' : PartialEquiv β γ) → e.target = e'.source → PartialEquiv α γ |
Std.Internal.IO.Process.ResourceUsageStats.messagesSent | Std.Internal.Async.Process | Std.Internal.IO.Process.ResourceUsageStats → UInt64 |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.multipliableLocallyUniformlyOn_eta._simp_1_1 | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] (a : E), (0 ≤ ‖a‖) = True |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanShape | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{X : C} → F.PreOneHypercoverDenseData X → CategoryTheory.Limits.MulticospanShape |
FiberBundleCore.rec | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_5} →
{B : Type u_6} →
[inst : TopologicalSpace B] →
{F : Type u_7} →
[inst_1 : TopologicalSpace F] →
{motive : FiberBundleCore ι B F → Sort u} →
((baseSet : ι → Set B) →
(isOpen_baseSet : ∀ (i : ι), IsOpen (baseSet i)) →
(indexAt : B → ι) →
(mem_baseSet_at : ∀ (x : B), x ∈ baseSet (indexAt x)) →
(coordChange : ι → ι → B → F → F) →
(coordChange_self : ∀ (i : ι), ∀ x ∈ baseSet i, ∀ (v : F), coordChange i i x v = v) →
(continuousOn_coordChange :
∀ (i j : ι),
ContinuousOn (fun p => coordChange i j p.1 p.2) ((baseSet i ∩ baseSet j) ×ˢ Set.univ)) →
(coordChange_comp :
∀ (i j k : ι),
∀ x ∈ baseSet i ∩ baseSet j ∩ baseSet k,
∀ (v : F), coordChange j k x (coordChange i j x v) = coordChange i k x v) →
motive
{ baseSet := baseSet, isOpen_baseSet := isOpen_baseSet, indexAt := indexAt,
mem_baseSet_at := mem_baseSet_at, coordChange := coordChange,
coordChange_self := coordChange_self,
continuousOn_coordChange := continuousOn_coordChange,
coordChange_comp := coordChange_comp }) →
(t : FiberBundleCore ι B F) → motive t |
Asymptotics.IsEquivalent.mono | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {l : Filter α} {f g : α → β} {l' : Filter α},
Asymptotics.IsEquivalent l' f g → l ≤ l' → Asymptotics.IsEquivalent l f g |
Sylow.noConfusionType | Mathlib.GroupTheory.Sylow | Sort u →
{p : ℕ} →
{G : Type u_1} →
[inst : Group G] → Sylow p G → {p' : ℕ} → {G' : Type u_1} → [inst' : Group G'] → Sylow p' G' → Sort u |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.MutualClosure.mkClosureForAux._unsafe_rec | Lean.Elab.MutualDef | Array Lean.FVarId → StateRefT' IO.RealWorld Lean.Elab.Term.MutualClosure.ClosureState Lean.Elab.TermElabM Unit |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.elabInsertCastAux | Mathlib.Tactic.Translate.TagUnfoldBoundary | Lean.Name →
Mathlib.Tactic.Translate.CastKind✝ →
Lean.Term → Mathlib.Tactic.Translate.TranslateData → Lean.Elab.Command.CommandElabM (Lean.Name × Lean.Name) |
CategoryTheory.Triangulated.TStructure.isIso_truncLE_map_iff | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} 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) {X Y : C} (f : X ⟶ Y) (a b : ℤ),
a + 1 = b →
(CategoryTheory.IsIso ((t.truncLE a).map f) ↔
∃ Z g h,
∃ (_ :
CategoryTheory.Pretriangulated.Triangle.mk (CategoryTheory.CategoryStruct.comp ((t.truncLEι a).app X) f) g h ∈
CategoryTheory.Pretriangulated.distinguishedTriangles),
t.IsGE Z b) |
Quotient.outRelEmbedding_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {x : Setoid α} {r : α → α → Prop} (H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂)
(a : Quotient x), (Quotient.outRelEmbedding H) a = a.out |
ContinuousLinearMap.coprod_apply | Mathlib.Topology.Algebra.Module.LinearMapPiProd | ∀ {R : Type u_1} {M : Type u_3} {M₁ : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : TopologicalSpace M]
[inst_2 : TopologicalSpace M₁] [inst_3 : TopologicalSpace M₂] [inst_4 : AddCommMonoid M] [inst_5 : Module R M]
[inst_6 : ContinuousAdd M] [inst_7 : AddCommMonoid M₁] [inst_8 : Module R M₁] [inst_9 : AddCommMonoid M₂]
[inst_10 : Module R M₂] (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) (a : M₁ × M₂), (f₁.coprod f₂) a = f₁ a.1 + f₂ a.2 |
Std.HashMap.getKey!_union_of_not_mem_left | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [inst : Inhabited α] [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₁ → (m₁ ∪ m₂).getKey! k = m₂.getKey! k |
CategoryTheory.NatTrans.shift_app | Mathlib.CategoryTheory.Shift.CommShift | ∀ {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] {F₁ F₂ : CategoryTheory.Functor C D} (τ : F₁ ⟶ F₂) {A : Type u_5}
[inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A]
[inst_5 : F₁.CommShift A] [inst_6 : F₂.CommShift A] [CategoryTheory.NatTrans.CommShift τ A] (a : A) (X : C),
(CategoryTheory.shiftFunctor D a).map (τ.app X) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.commShiftIso F₁ a).inv.app X)
(CategoryTheory.CategoryStruct.comp (τ.app ((CategoryTheory.shiftFunctor C a).obj X))
((CategoryTheory.Functor.commShiftIso F₂ a).hom.app X)) |
_private.Mathlib.Logic.Denumerable.0.nonempty_denumerable_iff.match_1_1 | Mathlib.Logic.Denumerable | ∀ {α : Type u_1} (motive : Nonempty (Denumerable α) → Prop) (x : Nonempty (Denumerable α)),
(∀ (val : Denumerable α), motive ⋯) → motive x |
List.TProd.elim'.congr_simp | Mathlib.Data.Prod.TProd | ∀ {ι : Type u} {α : ι → Type v} {l : List ι} {inst : DecidableEq ι} [inst_1 : DecidableEq ι] (h : ∀ (i : ι), i ∈ l)
(v v_1 : List.TProd α l), v = v_1 → ∀ (i : ι), List.TProd.elim' h v i = List.TProd.elim' h v_1 i |
CategoryTheory.MonoidalCategory.tensorHom_def'_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X₁ Y₁ X₂ Y₂ : C}
(f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y₁ Y₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X₁ g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Y₂) h) |
Subarray.array.eq_1 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} (xs : Subarray α), xs.array = xs.internalRepresentation.array |
stalkSkyscraperSheafAdjunction._proof_1 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasTerminal C]
[inst_3 : CategoryTheory.Limits.HasColimits C] (𝓐 𝓑 : TopCat.Sheaf C X) (f : 𝓐 ⟶ 𝓑),
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (TopCat.Sheaf C X)).map f)
{ hom := (StalkSkyscraperPresheafAdjunctionAuxs.unit p₀).app 𝓑.obj }).hom =
(CategoryTheory.CategoryStruct.comp { hom := (StalkSkyscraperPresheafAdjunctionAuxs.unit p₀).app 𝓐.obj }
((((TopCat.Sheaf.forget C X).comp (TopCat.Presheaf.stalkFunctor C p₀)).comp (skyscraperSheafFunctor p₀)).map
f)).hom |
Std.DTreeMap.minKey?_eq_some_iff_getKey?_eq_self_and_forall | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {km : α},
t.minKey? = some km ↔ t.getKey? km = some km ∧ ∀ k ∈ t, (cmp km k).isLE = true |
Nat.ceil_add_le | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
(a b : R), ⌈a + b⌉₊ ≤ ⌈a⌉₊ + ⌈b⌉₊ |
_private.Mathlib.CategoryTheory.Monoidal.Category.0.CategoryTheory.MonoidalCategory.whisker_exchange._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanIndex | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{A : Type u'} →
[inst_2 : CategoryTheory.Category.{v', u'} A] →
{X : C} →
(data : F.PreOneHypercoverDenseData X) →
CategoryTheory.Functor C₀ᵒᵖ A → CategoryTheory.Limits.MulticospanIndex data.multicospanShape A |
unitary.coe_star | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : ↥(unitary R)}, ↑(star U) = star ↑U |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterM.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {β : Type u_1} {n : Type u_1 → Type u_2} {f : β → n (ULift.{u_1, 0} Bool)} [inst : MonadAttach n] (out : β)
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) (hf : MonadAttach.CanReturn (f out) { down := true })
(h_1 : (hf : MonadAttach.CanReturn (f out) { down := false }) → motive ⟨{ down := false }, hf⟩)
(h_2 : (hf : MonadAttach.CanReturn (f out) { down := true }) → motive ⟨{ down := true }, hf⟩),
(match ⟨{ down := true }, hf⟩ with
| ⟨{ down := false }, hf⟩ => h_1 hf
| ⟨{ down := true }, hf⟩ => h_2 hf) =
h_2 hf |
FormalMultilinearSeries.compChangeOfVariables_blocksFun | Mathlib.Analysis.Analytic.Composition | ∀ (m M N : ℕ) {i : (n : ℕ) × (Fin n → ℕ)} (hi : i ∈ FormalMultilinearSeries.compPartialSumSource m M N) (j : Fin i.fst),
(FormalMultilinearSeries.compChangeOfVariables m M N i hi).snd.blocksFun ⟨↑j, ⋯⟩ = i.snd j |
Set.infinite_of_finite_compl | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} [Infinite α] {s : Set α}, sᶜ.Finite → s.Infinite |
WeierstrassCurve.Δ._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | (7 + 1).AtLeastTwo |
Real.deriv_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.InverseDeriv | deriv Real.arccos = fun x => -(1 / √(1 - x ^ 2)) |
Algebra.TensorProduct.instNonUnitalRing | Mathlib.RingTheory.TensorProduct.Basic | {R : Type uR} →
{A : Type uA} →
{B : Type uB} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalRing A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] →
[inst_5 : NonUnitalSemiring B] →
[inst_6 : Module R B] →
[SMulCommClass R B B] → [IsScalarTower R B B] → NonUnitalRing (TensorProduct R A B) |
QuadraticModuleCat.Hom.mk.injEq | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u} [inst : CommRing R] {V W : QuadraticModuleCat R} (toIsometry' toIsometry'_1 : V.form →qᵢ W.form),
({ toIsometry' := toIsometry' } = { toIsometry' := toIsometry'_1 }) = (toIsometry' = toIsometry'_1) |
Std.ExtDHashMap.mem_inter_iff._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (k ∈ m₁ ∩ m₂) = (k ∈ m₁ ∧ k ∈ m₂) |
CategoryTheory.Pi.closedUnit._proof_2 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] [inst_2 : (i : I) → CategoryTheory.MonoidalClosed (C i)]
(X : (i : I) → C i) ⦃X_1 Y : (i : I) → C i⦄ (f : X_1 ⟶ Y),
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id ((i : I) → C i)).map f) fun i =>
(CategoryTheory.ihom.coev (X i)).app (Y i)) =
CategoryTheory.CategoryStruct.comp (fun i => (CategoryTheory.ihom.coev (X i)).app (X_1 i))
(((CategoryTheory.MonoidalCategory.tensorLeft X).comp (CategoryTheory.Pi.ihom X)).map f) |
Plausible.Gen.Gen.outOfFuel | Plausible.Gen | Plausible.GenError |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.equiv_iff_toList_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel |
CategoryTheory.Limits.filtered_colim_preservesFiniteLimits_of_types | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {K : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} K] [inst_1 : Small.{v, u₂} K] [CategoryTheory.IsFiltered K],
CategoryTheory.Limits.PreservesFiniteLimits CategoryTheory.Limits.colim |
_private.Mathlib.Analysis.Convex.PathConnected.0.Path.range_segment._simp_1_1 | Mathlib.Analysis.Convex.PathConnected | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [inst_3 : ContinuousAdd E]
[inst_4 : ContinuousSMul ℝ E] (a b : E) (t : ↑unitInterval), (AffineMap.lineMap a b) ↑t = (Path.segment a b) t |
LinearMap.coe_restrictScalars | Mathlib.Algebra.Module.LinearMap.Defs | ∀ (R : Type u_1) {S : Type u_5} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module S M] [inst_7 : Module S M₂] [inst_8 : LinearMap.CompatibleSMul M M₂ R S] (f : M →ₗ[S] M₂),
⇑(↑R f) = ⇑f |
Option.decidableForallMem._proof_1 | Init.Data.Option.Instances | ∀ {α : Type u_1} {p : α → Prop}, ∀ a ∈ none, p a |
HomologicalComplex.mapBifunctor₁₂.D₁.congr_simp | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_5, u_3} C₁₂] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms C₁]
[inst_6 : CategoryTheory.Limits.HasZeroMorphisms C₂] [inst_7 : CategoryTheory.Limits.HasZeroMorphisms C₃]
[inst_8 : CategoryTheory.Preadditive C₁₂] [inst_9 : CategoryTheory.Preadditive C₄]
(F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂))
(G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) [inst_10 : F₁₂.PreservesZeroMorphisms]
[inst_11 : ∀ (X₁ : C₁), (F₁₂.obj X₁).PreservesZeroMorphisms] [inst_12 : G.Additive]
[inst_13 : ∀ (X₁₂ : C₁₂), (G.obj X₁₂).PreservesZeroMorphisms] {ι₁ : Type u_7} {ι₂ : Type u_8} {ι₃ : Type u_9}
{ι₁₂ : Type u_10} {ι₄ : Type u_12} [inst_14 : DecidableEq ι₄] {c₁ : ComplexShape ι₁} {c₂ : ComplexShape ι₂}
{c₃ : ComplexShape ι₃} (K₁ : HomologicalComplex C₁ c₁) (K₂ : HomologicalComplex C₂ c₂) (K₃ : HomologicalComplex C₃ c₃)
(c₁₂ : ComplexShape ι₁₂) (c₄ : ComplexShape ι₄) [inst_15 : TotalComplexShape c₁ c₂ c₁₂]
[inst_16 : TotalComplexShape c₁₂ c₃ c₄] [inst_17 : K₁.HasMapBifunctor K₂ F₁₂ c₁₂] [inst_18 : DecidableEq ι₁₂]
[inst_19 : (K₁.mapBifunctor K₂ F₁₂ c₁₂).HasMapBifunctor K₃ G c₄]
[inst_20 : HomologicalComplex.HasGoodTrifunctor₁₂Obj F₁₂ G K₁ K₂ K₃ c₁₂ c₄] (j j' : ι₄),
HomologicalComplex.mapBifunctor₁₂.D₁ F₁₂ G K₁ K₂ K₃ c₁₂ c₄ j j' =
HomologicalComplex.mapBifunctor₁₂.D₁ F₁₂ G K₁ K₂ K₃ c₁₂ c₄ j j' |
Lean.MessageSeverity.recOn | Lean.Message | {motive : Lean.MessageSeverity → Sort u} →
(t : Lean.MessageSeverity) →
motive Lean.MessageSeverity.information →
motive Lean.MessageSeverity.warning → motive Lean.MessageSeverity.error → motive t |
AddMonoidAlgebra.grade.decomposition | Mathlib.Algebra.MonoidAlgebra.Grading | {ι : Type u_2} →
{R : Type u_3} →
[inst : DecidableEq ι] →
[AddMonoid ι] → [inst_2 : CommSemiring R] → DirectSum.Decomposition (AddMonoidAlgebra.grade R) |
Lean.Meta.Grind.Arith.Cutsat.VarInfo.maxDvdCoeff._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | ℕ |
AlgebraicTopology.DoldKan.Γ₀.splitting._proof_3 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ) (Δ : SimplexCategoryᵒᵖ),
CategoryTheory.Limits.HasColimit
(CategoryTheory.Discrete.functor (SimplicialObject.Splitting.summand (fun n => K.X n) Δ)) |
CategoryTheory.FreeBicategory.homCategory' | Mathlib.CategoryTheory.Bicategory.Coherence | {B : Type u} →
[inst : Quiver B] → (a b : B) → CategoryTheory.Category.{max u v, max u v} (CategoryTheory.FreeBicategory.Hom a b) |
UInt32.mul_def | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), a * b = { toBitVec := a.toBitVec * b.toBitVec } |
List.findIdx_map | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} (xs : List α) (f : α → β) (p : β → Bool),
List.findIdx p (List.map f xs) = List.findIdx (p ∘ f) xs |
Lean.Meta.LazyDiscrTree.InitEntry._sizeOf_1 | Lean.Meta.LazyDiscrTree | {α : Type} → [SizeOf α] → Lean.Meta.LazyDiscrTree.InitEntry α → ℕ |
Lean.MonadStateCacheT | Lean.Util.MonadCache | (α : Type) → Type → (Type → Type) → [BEq α] → [Hashable α] → Type → Type |
MulHom.coe_ofDense | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Semigroup M] [inst_1 : Semigroup N] {s : Set M} (f : M → N)
(hs : Subsemigroup.closure s = ⊤) (hmul : ∀ (x y : M), y ∈ s → f (x * y) = f x * f y), ⇑(MulHom.ofDense f hs hmul) = f |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.data_extract._proof_1_4 | Init.Data.ByteArray.Lemmas | ∀ {a : ByteArray} {b e : ℕ}, ¬b ≤ e → ¬min e a.data.size ≤ b → False |
Submonoid.mem_divPairs | Mathlib.GroupTheory.MonoidLocalization.DivPairs | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G] {f : ⊤.LocalizationMap G} {s : Submonoid G}
{x : M × M}, x ∈ Submonoid.divPairs f s ↔ f x.1 / f x.2 ∈ s |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_free_of_surjective._simp_1_7 | Mathlib.Algebra.Module.FinitePresentation | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{M' : Type u_8} [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') (v : α → M) (l : α →₀ R),
(Finsupp.linearCombination R (⇑f ∘ v)) l = f ((Finsupp.linearCombination R v) l) |
_private.Lean.Level.0.Lean.Level.normLtAux._unary._proof_3 | Lean.Level | ∀ (l₁ : Lean.Level) (k₁ : ℕ) (l₂ : Lean.Level) (k₂ : ℕ),
(invImage
(fun x =>
PSigma.casesOn x fun a a_1 => PSigma.casesOn a_1 fun a_2 a_3 => PSigma.casesOn a_3 fun a_4 a_5 => (a, a_4))
Prod.instWellFoundedRelation).1
⟨l₁, ⟨k₁, ⟨l₂, k₂ + 1⟩⟩⟩ ⟨l₁, ⟨k₁, ⟨l₂.succ, k₂⟩⟩⟩ |
MeasureTheory.FiniteMeasure.coeFn_def | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω), ⇑μ = fun s => (↑μ s).toNNReal |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.exists_presentation_of_basis_cotangent._simp_1_3 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) |
Quotient.finChoice._proof_2 | Mathlib.Data.Fintype.Quotient | ∀ {ι : Type u_1} (x x_1 : { l // ∀ (i : ι), i ∈ l }),
(Subtype.instSetoid_mathlib fun l => ∀ (i : ι), i ∈ l) x x_1 ↔
(Subtype.instSetoid_mathlib fun l => ∀ (i : ι), i ∈ l) x x_1 |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobian._simp_1_2 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m n : ℕ), (f.sylvester g m n).det = f.resultant g m n |
GrpWithZero.carrier | Mathlib.Algebra.Category.GrpWithZero | GrpWithZero → Type u_1 |
Std.Do.SPred.exists.match_1 | Std.Do.SPred.SPred | {α : Sort u_3} →
(motive : (σs : List (Type u_1)) → (α → Std.Do.SPred σs) → Sort u_2) →
(σs : List (Type u_1)) →
(P : α → Std.Do.SPred σs) →
((P : α → Std.Do.SPred []) → motive [] P) →
((σ : Type u_1) → (tail : List (Type u_1)) → (P : α → Std.Do.SPred (σ :: tail)) → motive (σ :: tail) P) →
motive σs P |
IsPrimitiveRoot.toRootsOfUnity | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | {M : Type u_1} → [inst : CommMonoid M] → {μ : M} → {n : ℕ} → [NeZero n] → IsPrimitiveRoot μ n → ↥(rootsOfUnity n M) |
Mathlib.Meta.NormNum.not_isSquare_of_isNNRat_rat_of_num | Mathlib.Tactic.NormNum.IsSquare | ∀ (a : ℚ) (n d : ℕ), ¬IsSquare n → n.Coprime d → Mathlib.Meta.NormNum.IsNNRat a n d → ¬IsSquare a |
DFinsupp.lsum_single | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} (S : Type u_4) {M : ι → Type u_5} {N : Type u_6} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : AddCommMonoid N]
[inst_4 : Module R N] [inst_5 : DecidableEq ι] [inst_6 : Semiring S] [inst_7 : Module S N]
[inst_8 : SMulCommClass R S N] (F : (i : ι) → M i →ₗ[R] N) (i : ι) (x : M i),
(((DFinsupp.lsum S) F) fun₀ | i => x) = (F i) x |
Lean.Meta.Grind.AC.MonadGetStruct.noConfusionType | Lean.Meta.Tactic.Grind.AC.Util | Sort u →
{m : Type → Type} →
Lean.Meta.Grind.AC.MonadGetStruct m → {m' : Type → Type} → Lean.Meta.Grind.AC.MonadGetStruct m' → Sort u |
_private.Init.Meta.Defs.0.Lean.Name.replacePrefix.match_1 | Init.Meta.Defs | (motive : Lean.Name → Lean.Name → Lean.Name → Sort u_1) →
(x x_1 x_2 : Lean.Name) →
((newP : Lean.Name) → motive Lean.Name.anonymous Lean.Name.anonymous newP) →
((x x_3 : Lean.Name) → motive Lean.Name.anonymous x x_3) →
((n p : Lean.Name) →
(s : String) →
(h : n = p.str s) → (queryP newP : Lean.Name) → motive (namedPattern n (p.str s) h) queryP newP) →
((n p : Lean.Name) →
(s : ℕ) →
(h : n = p.num s) → (queryP newP : Lean.Name) → motive (namedPattern n (p.num s) h) queryP newP) →
motive x x_1 x_2 |
Lean.Expr.replace | Lean.Util.ReplaceExpr | (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Expr |
Lean.instToJsonPrintImportResult.toJson | Lean.Elab.ParseImportsFast | Lean.PrintImportResult → Lean.Json |
SemiNormedGrp.of.injEq | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (carrier : Type u) [str : SeminormedAddCommGroup carrier] (carrier_1 : Type u)
(str_1 : SeminormedAddCommGroup carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) |
Finset.Ioo_subset_Ioi_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] [inst_2 : LocallyFiniteOrder α],
Finset.Ioo a b ⊆ Finset.Ioi a |
Lean.Elab.Attribute.name | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.Name |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.