name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.IR.ExpandResetReuse.reuseToSet._unsafe_rec | Lean.Compiler.IR.ExpandResetReuse | Lean.IR.ExpandResetReuse.Context → Lean.IR.VarId → Lean.IR.VarId → Lean.IR.FnBody → Lean.IR.FnBody |
PUnit.mulSemiringAction._proof_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : Semiring R] (r : R), r • 1 = 1 |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_11 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor C (Type u_3)) {X : C}
(x : F.obj X) {X_1 Y : CategoryTheory.Over (F.elementsMk X x)} (f : X_1 ⟶ Y),
↑(CategoryTheory.CategoryStruct.comp f.left Y.hom) = ↑X_1.hom |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.quoteSyntax._sparseCasesOn_3 | Lean.Elab.Quotation | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
AlgebraicGeometry.Scheme.Modules.restrictFunctorId_inv_app_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {M : X.Modules} {U : X.Opens},
AlgebraicGeometry.Scheme.Modules.Hom.app (AlgebraicGeometry.Scheme.Modules.restrictFunctorId.inv.app M) U =
M.presheaf.map (CategoryTheory.eqToHom ⋯).op |
Function.graph | Mathlib.Data.Rel | {α : Type u_1} → {β : Type u_2} → (α → β) → SetRel α β |
CategoryTheory.Limits.IsLimit.pushout_zero_ext | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Connected | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsConnected J] {C : Type u}
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_4 : CategoryTheory.Limits.HasPushouts C] [inst_5 : CategoryTheory.Limits.HasLimitsOfShape J C]
[CategoryTheory.HasExactLimitsOfShape J C] {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cone F}
(hc : CategoryTheory.Limits.IsLimit c) {X Y : C} {g : Y ⟶ c.pt} {f : c.pt ⟶ X},
(∀ (j : J),
CategoryTheory.CategoryStruct.comp g
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.pushout.inr (c.π.app j) f)) =
0) →
CategoryTheory.CategoryStruct.comp g f = 0 |
CategoryTheory.Monad.MonadicityInternal.instHasColimitWalkingParallelPairParallelPairMapAppCounitObjOfHasCoequalizerAA | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G)
[∀ (A : adj.toMonad.Algebra), CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] (B : D),
CategoryTheory.Limits.HasColimit
(CategoryTheory.Limits.parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B)))) |
Quiver.homOfEq_trans | Mathlib.Combinatorics.Quiver.Basic | ∀ {V : Type u_1} [inst : Quiver V] {X Y X' Y' : V} (f : X ⟶ Y) (hX : X = X') (hY : Y = Y') {X'' Y'' : V}
(hX' : X' = X'') (hY' : Y' = Y''), Quiver.homOfEq (Quiver.homOfEq f hX hY) hX' hY' = Quiver.homOfEq f ⋯ ⋯ |
MonCat.monoidObj.eq_1 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J MonCat) (j : J),
MonCat.monoidObj F j = inferInstanceAs (Monoid ↑(F.obj j)) |
CategoryTheory.ComposableArrows.naturality'._auto_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax |
_private.Mathlib.GroupTheory.GroupAction.Primitive.0.MulAction.IsPreprimitive.exists_mem_smul_and_notMem_smul._simp_1_3 | Mathlib.GroupTheory.GroupAction.Primitive | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
String.Slice.Pos.Splits.rec | Init.Data.String.Lemmas.Splits | {s : String.Slice} →
{p : s.Pos} →
{t₁ t₂ : String} →
{motive : p.Splits t₁ t₂ → Sort u} →
((eq_append : s.copy = t₁ ++ t₂) → (offset_eq_rawEndPos : p.offset = t₁.rawEndPos) → motive ⋯) →
(t : p.Splits t₁ t₂) → motive t |
Std.TreeSet.Raw.get!_insertMany_list_of_not_mem_of_contains_eq_false | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp] [inst_2 : Inhabited α],
t.WF → ∀ {l : List α} {k : α}, k ∉ t → l.contains k = false → (t.insertMany l).get! k = default |
String.Pos.Raw.isValidForSlice_iff_exists_append | Init.Data.String.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw},
String.Pos.Raw.IsValidForSlice s p ↔ ∃ t₁ t₂, s.copy = t₁ ++ t₂ ∧ p = t₁.rawEndPos |
LinearEquiv.det_baseChange | Mathlib.LinearAlgebra.Charpoly.BaseChange | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Free R M]
[Module.Finite R M] (A : Type u_3) [inst_5 : CommRing A] [inst_6 : Algebra R A] (f : M ≃ₗ[R] M),
LinearEquiv.det (LinearEquiv.baseChange R A M M f) = (Units.map ↑(algebraMap R A)) (LinearEquiv.det f) |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_15 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i + 1 ≤ (List.findIdxs p (head :: tail) s).length → i < (List.findIdxs p (head :: tail) s).length |
Filter.CardinalGenerateSets.below | Mathlib.Order.Filter.CardinalInter | {α : Type u} →
{c : Cardinal.{u}} →
{g : Set (Set α)} →
{motive : (a : Set α) → Filter.CardinalGenerateSets g a → Prop} →
{a : Set α} → Filter.CardinalGenerateSets g a → Prop |
MeasureTheory.L1.SimpleFunc.integralCLM'._proof_2 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ (α : Type u_1) (E : Type u_2) (𝕜 : Type u_3) [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
(μ : MeasureTheory.Measure α) [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E]
[inst_4 : NormedSpace ℝ E] [inst_5 : SMulCommClass ℝ 𝕜 E] (f : ↥(MeasureTheory.Lp.simpleFunc E 1 μ)),
‖{ toFun := MeasureTheory.L1.SimpleFunc.integral, map_add' := ⋯, map_smul' := ⋯ } f‖ ≤ 1 * ‖f‖ |
CommGroup.torsion.eq_1 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : CommGroup G], CommGroup.torsion G = { toSubmonoid := CommMonoid.torsion G, inv_mem' := ⋯ } |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_mul._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {R : Type u} [inst : Semiring R] [inst_1 : PartialOrder R] [ExistsAddOfLE R] [MulPosStrictMono R]
[AddRightStrictMono R] [AddRightReflectLT R] {a b : R}, a < 0 → b < 0 → (0 < a * b) = True |
MulEquiv.withZero._proof_2 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_2} {β : Type u_1} [inst : Group α] [inst_1 : Group β] (e : α ≃* β) (x : WithZero β),
(WithZero.map' ↑e) ((WithZero.map' ↑e.symm) x) = x |
CategoryTheory.Functor.LaxRightLinear.μᵣ_unitality._autoParam | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | Lean.Syntax |
HomologicalComplex.mapBifunctorDesc | Mathlib.Algebra.Homology.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] →
{I₁ : Type u_4} →
{I₂ : Type u_5} →
{J : Type u_6} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] →
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂] →
[inst_5 : CategoryTheory.Preadditive D] →
{K₁ : HomologicalComplex C₁ c₁} →
{K₂ : HomologicalComplex C₂ c₂} →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D)} →
[inst_6 : F.PreservesZeroMorphisms] →
[inst_7 : ∀ (X₁ : C₁), (F.obj X₁).PreservesZeroMorphisms] →
{c : ComplexShape J} →
[inst_8 : TotalComplexShape c₁ c₂ c] →
[inst_9 : K₁.HasMapBifunctor K₂ F c] →
[inst_10 : DecidableEq J] →
{A : D} →
{j : J} →
((i₁ : I₁) →
(i₂ : I₂) →
c₁.π c₂ c (i₁, i₂) = j →
((F.obj (K₁.X i₁)).obj (K₂.X i₂) ⟶ A)) →
((K₁.mapBifunctor K₂ F c).X j ⟶ A) |
Lean.Server.Test.Runner.Client.instFromJsonInteractiveTermGoal | Lean.Server.Test.Runner | Lean.FromJson Lean.Server.Test.Runner.Client.InteractiveTermGoal |
Std.Time.Day.Ordinal.instInhabitedOfYear._proof_1 | Std.Time.Date.Unit.Day | 1 ≤ 1 |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertEntry_perm_filter._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, (a :: l₁).Perm (a :: l₂) = l₁.Perm l₂ |
CategoryTheory.MonoidalCategory.DayConvolution.mk | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{F G : CategoryTheory.Functor C V} →
(convolution : CategoryTheory.Functor C V) →
(unit :
CategoryTheory.MonoidalCategory.externalProduct F G ⟶
(CategoryTheory.MonoidalCategory.tensor C).comp convolution) →
(CategoryTheory.Functor.LeftExtension.mk convolution unit).IsPointwiseLeftKanExtension →
CategoryTheory.MonoidalCategory.DayConvolution F G |
midpoint_le_right._simp_1 | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : IsStrictOrderedRing k]
[inst_3 : AddCommGroup E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] [inst_6 : Module k E]
[IsStrictOrderedModule k E] [PosSMulReflectLE k E] {a b : E}, (midpoint k a b ≤ b) = (a ≤ b) |
AlternatingMap.mkContinuousLinear_norm_le_max | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {G : Type wG} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : SeminormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : Fintype ι]
(f : F →ₗ[𝕜] E [⋀^ι]→ₗ[𝕜] G) (C : ℝ) (H : ∀ (x : F) (m : ι → E), ‖(f x) m‖ ≤ C * ‖x‖ * ∏ i, ‖m i‖),
‖AlternatingMap.mkContinuousLinear f C H‖ ≤ max C 0 |
CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit_inv | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {kf : CategoryTheory.Limits.KernelFork f}
{kf' : CategoryTheory.Limits.KernelFork f'} (hf : CategoryTheory.Limits.IsLimit kf)
(hf' : CategoryTheory.Limits.IsLimit kf') (φ : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f'),
(CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit hf hf' φ).inv = kf'.mapOfIsLimit hf φ.inv |
MvPolynomial.bind₂_monomial | Mathlib.Algebra.MvPolynomial.Monad | ∀ {σ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
(f : R →+* MvPolynomial σ S) (d : σ →₀ ℕ) (r : R),
(MvPolynomial.bind₂ f) ((MvPolynomial.monomial d) r) = f r * (MvPolynomial.monomial d) 1 |
isMin_bot | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α], IsMin ⊥ |
_private.Lean.Meta.Tactic.Intro.0.Lean.Meta.mkAuxNameImp.match_1 | Lean.Meta.Tactic.Intro | (motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) →
(Unit → motive []) → ((n : Lean.Name) → (rest : List Lean.Name) → motive (n :: rest)) → motive x |
LinearMap.IsSymmetric.diagonalization_apply_self_apply | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E} [inst_3 : FiniteDimensional 𝕜 E] (hT : T.IsSymmetric) (v : E) (μ : Module.End.Eigenvalues T),
(hT.diagonalization (T v)).ofLp μ = ↑T 1 μ • (hT.diagonalization v).ofLp μ |
HeytAlg.instConcreteCategoryHeytingHomCarrier._proof_3 | Mathlib.Order.Category.HeytAlg | ∀ {X : HeytAlg} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x |
CategoryTheory.MorphismProperty.Over.pullbackCongr_hom_app_left_fst_assoc | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] {X Y : T} {f : X ⟶ Y} [inst_2 : P.HasPullbacksAlong f] {g : X ⟶ Y}
[inst_3 : P.IsStableUnderBaseChangeAlong f] [inst_4 : Q.IsStableUnderBaseChange] (h : f = g) (A : P.Over Q Y) {Z : T}
(h_1 : A.left ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MorphismProperty.Over.pullbackCongr h).hom.app A).left
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst A.hom g) h_1) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst A.hom f) h_1 |
Std.TreeSet.mem_insert_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α}, k ∈ t.insert k |
_private.Init.Data.Array.Erase.0.Array.mem_eraseIdx_iff_getElem._simp_1_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} {x : α} {l : List α} {k : ℕ}, (x ∈ l.eraseIdx k) = ∃ i, ∃ (h : i < l.length), i ≠ k ∧ l[i] = x |
MeasureTheory.Measure.IsHaarMeasure.mk._flat_ctor | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_3} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : MeasurableSpace G]
{μ : MeasureTheory.Measure G},
(∀ ⦃K : Set G⦄, IsCompact K → μ K < ⊤) →
(∀ (g : G), MeasureTheory.Measure.map (fun x => g * x) μ = μ) →
(∀ (U : Set G), IsOpen U → U.Nonempty → μ U ≠ 0) → μ.IsHaarMeasure |
_private.Mathlib.Algebra.Algebra.Unitization.0.Unitization.isSelfAdjoint_inr._simp_1_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x = (star x = x) |
Nat.Partrec.Code.eval_eq_rfindOpt | Mathlib.Computability.PartrecCode | ∀ (c : Nat.Partrec.Code) (n : ℕ), c.eval n = Nat.rfindOpt fun k => Nat.Partrec.Code.evaln k c n |
_private.Mathlib.RingTheory.Jacobson.Ring.0.IsLocalization.isMaximal_iff_isMaximal_disjoint._simp_1_2 | Mathlib.RingTheory.Jacobson.Ring | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
HahnSeries.toIterate._proof_2 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
(x : HahnSeries (Lex (Γ × Γ')) R),
(Function.support fun g => { coeff := fun g' => x.coeff (g, g'), isPWO_support' := ⋯ }).IsPWO |
Rep.unitIso._proof_5 | Mathlib.RepresentationTheory.Rep | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Monoid G] (V : Rep k G),
Function.LeftInverse Rep.unitIsoAddEquiv.invFun Rep.unitIsoAddEquiv.toFun |
Matrix.normedAddCommGroup | Mathlib.Analysis.Matrix.Normed | {m : Type u_3} →
{n : Type u_4} →
{α : Type u_5} → [Fintype m] → [Fintype n] → [NormedAddCommGroup α] → NormedAddCommGroup (Matrix m n α) |
Finset.Ico_subset_Ici_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] [inst_2 : LocallyFiniteOrder α],
Finset.Ico a b ⊆ Finset.Ici a |
_private.Mathlib.NumberTheory.ModularForms.Delta.0.ModularForm.eta_comp_eqOn_const_mul_csqrt_eta | Mathlib.NumberTheory.ModularForms.Delta | ∃ c,
c ≠ 0 ∧
Set.EqOn (ModularForm.eta ∘ fun z => -1 / z) (c • (Complex.sqrt * ModularForm.eta)) UpperHalfPlane.upperHalfPlaneSet |
FiniteMulArchimedeanClass.closedBallSubgroup | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} →
[inst : CommGroup M] →
[inst_1 : LinearOrder M] → [inst_2 : IsOrderedMonoid M] → FiniteMulArchimedeanClass M → Subgroup M |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.ErrorContext.mk.sizeOf_spec | Mathlib.Tactic.Linter.TextBased | ∀ (error : Mathlib.Linter.TextBased.StyleError✝) (lineNumber : ℕ) (path : System.FilePath),
sizeOf { error := error, lineNumber := lineNumber, path := path } = 1 + sizeOf error + sizeOf lineNumber + sizeOf path |
_private.Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra.0.Module.FaithfullyFlat.faithfulSMul._simp_1 | Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b |
Std.BundledIterM.casesOn | Std.Data.Iterators.Lemmas.Equivalence.Basic | {m : Type w → Type w'} →
{β : Type w} →
{motive : Std.BundledIterM m β → Sort u} →
(t : Std.BundledIterM m β) →
((α : Type w) →
(inst : Std.Iterator α m β) →
(iterator : Std.IterM m β) → motive { α := α, inst := inst, iterator := iterator }) →
motive t |
CategoryTheory.EnrichedOrdinaryCategory.casesOn | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | {V : Type u'} →
[inst : CategoryTheory.Category.{v', u'} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.EnrichedOrdinaryCategory V C → Sort u_1} →
(t : CategoryTheory.EnrichedOrdinaryCategory V C) →
([toEnrichedCategory : CategoryTheory.EnrichedCategory V C] →
(homEquiv : {X Y : C} → (X ⟶ Y) ≃ (CategoryTheory.MonoidalCategoryStruct.tensorUnit V ⟶ X ⟶[V] Y)) →
(homEquiv_id : ∀ (X : C), homEquiv (CategoryTheory.CategoryStruct.id X) = CategoryTheory.eId V X) →
(homEquiv_comp :
∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
homEquiv (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor
(CategoryTheory.MonoidalCategoryStruct.tensorUnit V)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (homEquiv f) (homEquiv g))
(CategoryTheory.eComp V X Y Z))) →
motive
{ toEnrichedCategory := toEnrichedCategory, homEquiv := homEquiv, homEquiv_id := homEquiv_id,
homEquiv_comp := homEquiv_comp }) →
motive t |
Ideal.ramificationIdx_eq_one_of_isUnramifiedAt | Mathlib.NumberTheory.RamificationInertia.Unramified | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal S}
[inst_3 : p.IsPrime] [IsNoetherianRing S] [Algebra.IsUnramifiedAt R p],
p ≠ ⊥ → ∀ [IsDomain S] [Algebra.EssFiniteType R S], Ideal.ramificationIdx (algebraMap R S) (Ideal.under R p) p = 1 |
IsCompactOperator.restrict | Mathlib.Analysis.Normed.Operator.Compact | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_3} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] {f : M₁ →ₗ[R₁] M₁},
IsCompactOperator ⇑f →
∀ {V : Submodule R₁ M₁} (hV : ∀ v ∈ V, f v ∈ V), IsClosed ↑V → IsCompactOperator ⇑(f.restrict hV) |
_private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix._aux_Mathlib_NumberTheory_SiegelsLemma___macroRules__private_Mathlib_NumberTheory_SiegelsLemma_0_Int_Matrix_termB_1 | Mathlib.NumberTheory.SiegelsLemma | Lean.Macro |
Rat.num_divInt_den | Init.Data.Rat.Lemmas | ∀ (a : ℚ), Rat.divInt a.num ↑a.den = a |
PosNum.cast_one | Mathlib.Data.Num.Lemmas | ∀ {α : Type u_1} [inst : One α] [inst_1 : Add α], ↑1 = 1 |
hnot_top | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α], ￢⊤ = ⊥ |
CommSemiRingCat.forget_preservesLimits | Mathlib.Algebra.Category.Ring.Limits | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommSemiRingCat) |
finprod_mem_eq_prod | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M) {s : Set α} (hf : (s ∩ Function.mulSupport f).Finite),
∏ᶠ (i : α) (_ : i ∈ s), f i = ∏ i ∈ hf.toFinset, f i |
Nat.eq_zero_of_lcm_eq_zero | Init.Data.Nat.Lcm | ∀ {m n : ℕ}, m.lcm n = 0 → m = 0 ∨ n = 0 |
Module.Basis.coe_toOrthonormalBasis | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (v : Module.Basis ι 𝕜 E) (hv : Orthonormal 𝕜 ⇑v),
⇑(v.toOrthonormalBasis hv) = ⇑v |
CategoryTheory.Functor.leftExtensionEquivalenceOfIso₁_unitIso_hom_app_right_app | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
{L L' : CategoryTheory.Functor C D} (iso₁ : L ≅ L') (F : CategoryTheory.Functor C H)
(X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit F) ((CategoryTheory.Functor.whiskeringLeft C D H).obj L))
(X_1 : D),
((CategoryTheory.Functor.leftExtensionEquivalenceOfIso₁ iso₁ F).unitIso.hom.app X).right.app X_1 =
CategoryTheory.CategoryStruct.id (X.right.obj X_1) |
Height.fun_logHeight_one | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2},
(Height.logHeight fun x => 1) = 0 |
_private.Mathlib.Geometry.Manifold.IntegralCurve.UniformTime.0.exists_isMIntegralCurve_of_isMIntegralCurveOn._simp_1_1 | Mathlib.Geometry.Manifold.IntegralCurve.UniformTime | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioo a b) = (a < x ∧ x < b) |
HomologicalComplex.restriction.congr_simp | Mathlib.Algebra.Homology.Embedding.TruncLEHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K K_1 : HomologicalComplex C c'),
K = K_1 → ∀ (e e_1 : c.Embedding c') (e_e : e = e_1) [inst_2 : e.IsRelIff], K.restriction e = K_1.restriction e_1 |
Aesop.CasesTarget.ctorElimType | Aesop.RuleTac.Basic | {motive : Aesop.CasesTarget → Sort u} → ℕ → Sort (max 1 u) |
UInt32.reduceLE._regBuiltin.UInt32.reduceLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2998934274._hygCtx._hyg.169 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
IsSMulRegular.mul | Mathlib.Algebra.Regular.SMul | ∀ {R : Type u_1} {M : Type u_3} {a b : R} [inst : SMul R M] [inst_1 : Mul R] [IsScalarTower R R M],
IsSMulRegular M a → IsSMulRegular M b → IsSMulRegular M (a * b) |
Lean.Meta.Sym.Simp.simpForall' | Lean.Meta.Sym.Simp.Forall | Lean.Meta.Sym.Simp.Simproc → Lean.Meta.Sym.Simp.Simproc → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result |
IsIsometricSMul.mk._flat_ctor | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X],
(∀ (c : M), Isometry fun x => c • x) → IsIsometricSMul M X |
ProbabilityTheory.HasGaussianLaw.charFunDual_map_eq | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E] (L : StrongDual ℝ E),
ProbabilityTheory.HasGaussianLaw X P →
MeasureTheory.charFunDual (MeasureTheory.Measure.map X P) L =
Complex.exp (↑(∫ (x : Ω), (⇑L ∘ X) x ∂P) * Complex.I - ↑(ProbabilityTheory.variance (⇑L ∘ X) P) / 2) |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestMatchAt_iff_splits._simp_1_1 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {t : String} {s : String.Slice} {pos₁ pos₂ : s.Pos},
(∃ (h : pos₁ ≤ pos₂), (s.slice pos₁ pos₂ h).copy = t) = ∃ t₁ t₂, pos₁.Splits t₁ (t ++ t₂) ∧ pos₂.Splits (t₁ ++ t) t₂ |
MultilinearMap.mkContinuous_norm_le | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] (f : MultilinearMap 𝕜 E G)
{C : ℝ}, 0 ≤ C → ∀ (H : ∀ (m : (i : ι) → E i), ‖f m‖ ≤ C * ∏ i, ‖m i‖), ‖f.mkContinuous C H‖ ≤ C |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalReplace.match_1 | Lean.Elab.Tactic.BuiltinTactic | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) →
((ldecl : Lean.LocalDecl) → motive (some ldecl)) → ((x : Option Lean.LocalDecl) → motive x) → motive x |
CategoryTheory.ComposableArrows.sc'._auto_1 | Mathlib.Algebra.Homology.ExactSequence | Lean.Syntax |
QuadraticModuleCat.instMonoidalCategory | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | {R : Type u} → [inst : CommRing R] → [Invertible 2] → CategoryTheory.MonoidalCategory (QuadraticModuleCat R) |
Subgroup.mem_goursatSnd | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] {I : Subgroup (G × H)} {h : H},
h ∈ I.goursatSnd ↔ (1, h) ∈ I |
groupCohomology.H1IsoOfIsTrivial.congr_simp | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G) [inst_2 : A.IsTrivial],
groupCohomology.H1IsoOfIsTrivial A = groupCohomology.H1IsoOfIsTrivial A |
Std.DHashMap.Raw.getKeyD_insertIfNew | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a fallback : α} {v : β k},
(m.insertIfNew k v).getKeyD a fallback = if (k == a) = true ∧ k ∉ m then k else m.getKeyD a fallback |
AddMonoidAlgebra.singleZeroAlgHom.eq_1 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddMonoid M],
AddMonoidAlgebra.singleZeroAlgHom = { toRingHom := AddMonoidAlgebra.singleZeroRingHom, commutes' := ⋯ } |
CategoryTheory.HasDetector.recOn | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.HasDetector C → Sort u} →
(t : CategoryTheory.HasDetector C) → ((hasDetector : ∃ G, CategoryTheory.IsDetector G) → motive ⋯) → motive t |
Ideal.hasBasis_nhds_zero_adic | Mathlib.Topology.Algebra.Nonarchimedean.AdicTopology | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), (nhds 0).HasBasis (fun _n => True) fun n => ↑(I ^ n) |
Std.DTreeMap.Raw.Const.unitOfList_equiv_foldl | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {l : List α},
(Std.DTreeMap.Raw.Const.unitOfList l cmp).Equiv (List.foldl (fun acc a => acc.insertIfNew a ()) ∅ l) |
Unitization.inrNonUnitalAlgHom_toFun | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A] (a : A),
(Unitization.inrNonUnitalAlgHom R A) a = ↑a |
AbsoluteValue.map_units_intCast | Mathlib.Data.Int.AbsoluteValue | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : CommRing S] [inst_2 : LinearOrder S] [IsStrictOrderedRing S]
[Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ), abv ↑↑x = 1 |
CategoryTheory.CommGrp.forget₂Grp_obj_X | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommGrp C),
((CategoryTheory.CommGrp.forget₂Grp C).obj A).X = A.X |
ContDiffBump.noConfusionType | Mathlib.Analysis.Calculus.BumpFunction.Basic | Sort u → {E : Type u_1} → {c : E} → ContDiffBump c → {E' : Type u_1} → {c' : E'} → ContDiffBump c' → Sort u |
List.foldrM_map | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {α : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : β₁ → β₂} {g : β₂ → α → m α} {l : List β₁} {init : α},
List.foldrM g init (List.map f l) = List.foldrM (fun x y => g (f x) y) init l |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose_map_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u₄} {Y : Type u₅}
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] [inst_4 : CategoryTheory.Category.{v₅, u₅} Y]
{U V : CategoryTheory.Functor X Y} (α : U ⟶ V) (x : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G Y)
(X_1 : X),
(((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F G).map α).app x).fst.app X_1 =
x.fst.map (α.app X_1) |
AddConstMap.«term_→+c[_,_]_» | Mathlib.Algebra.AddConstMap.Basic | Lean.TrailingParserDescr |
_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Code.exists_code._simp_1_17 | Mathlib.Computability.TuringMachine.Config | ∀ {α : Type u_1} {a b : α}, (b ∈ Part.some a) = (b = a) |
_private.Init.Data.List.Nat.Modify.0.List.eraseIdx_modify_of_lt._proof_1_1 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i j : ℕ) (l : List α), j < i → ∀ (k : ℕ), i - 1 = k → k < j → ¬i = k → False |
MeasureTheory.IsSigmaSubadditiveSetFun | Mathlib.MeasureTheory.Measure.PreVariation | {X : Type u_1} → [MeasurableSpace X] → (Set X → ENNReal) → Prop |
Lean.Elab.Tactic.evalSplit._regBuiltin.Lean.Elab.Tactic.evalSplit_1 | Lean.Elab.Tactic.Split | IO Unit |
PowerSeries.WithPiTopology.multipliable_one_add_of_tendsto_order_atTop_nhds_top | Mathlib.RingTheory.PowerSeries.PiTopology | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommSemiring R] {ι : Type u_2} [inst_2 : LinearOrder ι]
[LocallyFiniteOrderBot ι] {f : ι → PowerSeries R},
Filter.Tendsto (fun i => (f i).order) Filter.atTop (nhds ⊤) → Multipliable fun x => 1 + f x |
Valuation.Integers.not_denselyOrdered_of_isPrincipalIdealRing | Mathlib.RingTheory.Valuation.Integers | ∀ {F : Type u} {Γ₀ : Type v} [inst : Field F] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation F Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O F] [IsPrincipalIdealRing O],
v.Integers O → ¬DenselyOrdered ↑(Set.range ⇑v) |
LinearMap.extendScalarsOfIsLocalizationEquiv_apply | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_3} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_4) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_5} {N : Type u_6} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[inst_9 : Module R N] [inst_10 : Module A N] [inst_11 : IsScalarTower R A N] (f : M →ₗ[R] N),
(LinearMap.extendScalarsOfIsLocalizationEquiv S A) f = LinearMap.extendScalarsOfIsLocalization S A f |
Lean.Meta.Grind.Arith.CommRing.NonCommSemiringM.Context.semiringId | Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM | Lean.Meta.Grind.Arith.CommRing.NonCommSemiringM.Context → ℕ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.