name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
TensorProduct.ext' | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring R₂] {σ₁₂ : R →+* R₂} {M : Type u_7}
{N : Type u_8} {P₂ : Type u_17} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : AddCommMonoid P₂]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R₂ P₂] {g h : TensorProduct R M N →ₛₗ[σ₁₂] P₂},
(∀ (x : M) (y : N), g (x ⊗ₜ[R] y) = h (x ⊗ₜ[R] y)) → g = h |
CategoryTheory.Limits.hasFiniteProducts_of_hasFiniteLimits | Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteLimits C],
CategoryTheory.Limits.HasFiniteProducts C |
_private.Mathlib.Topology.MetricSpace.Bounded.0.IsComplete.nonempty_iInter_of_nonempty_biInter._simp_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i |
ModularForm.const_apply | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetOne] (x : ℂ) (τ : UpperHalfPlane), (ModularForm.const x) τ = x |
LieIdeal.map_sup_ker_eq_map' | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {I : LieIdeal R L},
LieIdeal.map f I ⊔ LieIdeal.map f f.ker = LieIdeal.map f I |
Set.vadd_empty | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {s : Set α}, s +ᵥ ∅ = ∅ |
ProofWidgets.CheckRequestResponse.ctorElimType | ProofWidgets.Cancellable | {motive : ProofWidgets.CheckRequestResponse → Sort u} → ℕ → Sort (max 1 u) |
CategoryTheory.MorphismProperty.HasQuotient.iff_of_eqvGen | Mathlib.CategoryTheory.MorphismProperty.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C)
{homRel : HomRel C} [inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel]
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel] [W.HasQuotient homRel] {X Y : C} {f g : X ⟶ Y},
Relation.EqvGen homRel f g → (W f ↔ W g) |
Lean.Lsp.instFromJsonDiagnosticCode.match_1 | Lean.Data.Lsp.Diagnostics | (motive : Lean.Json → Sort u_1) →
(x : Lean.Json) →
((i : ℤ) → motive (Lean.Json.num { mantissa := i, exponent := 0 })) →
((s : String) → motive (Lean.Json.str s)) → ((j : Lean.Json) → motive j) → motive x |
Std.ExtTreeSet.contains_max? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α},
t.max? = some km → t.contains km = true |
CategoryTheory.Functor.mapTriangleInvRotateIso_inv_app_hom₃ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : CategoryTheory.Preadditive D] [inst_7 : F.Additive]
(X : CategoryTheory.Pretriangulated.Triangle C),
(F.mapTriangleInvRotateIso.inv.app X).hom₃ = CategoryTheory.CategoryStruct.id (F.obj X.obj₂) |
instDecidableEqDihedralGroup.decEq._proof_1 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (a : ZMod n), DihedralGroup.r a = DihedralGroup.r a |
_private.Mathlib.Topology.MetricSpace.HausdorffDimension.0.hausdorffMeasure_of_lt_dimH._simp_1_1 | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (a < iSup f) = ∃ i, a < f i |
Int16.toInt_div_of_ne_left | Init.Data.SInt.Lemmas | ∀ (a b : Int16), a ≠ Int16.minValue → (a / b).toInt = a.toInt.tdiv b.toInt |
Std.Tactic.BVDecide.BVLogicalExpr.bitblast.go.match_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure | (motive : Std.Tactic.BVDecide.Gate → Sort u_1) →
(g : Std.Tactic.BVDecide.Gate) →
(Unit → motive Std.Tactic.BVDecide.Gate.and) →
(Unit → motive Std.Tactic.BVDecide.Gate.xor) →
(Unit → motive Std.Tactic.BVDecide.Gate.beq) → (Unit → motive Std.Tactic.BVDecide.Gate.or) → motive g |
CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.ofHasDayConvolutions._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {V : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] {D : Type u_6} [inst_4 : CategoryTheory.Category.{u_5, u_6} D]
(ι : CategoryTheory.Functor D (CategoryTheory.Functor C V))
[hasDayConvolution :
∀ (d d' : D),
(CategoryTheory.MonoidalCategory.tensor C).HasPointwiseLeftKanExtension
(CategoryTheory.MonoidalCategory.externalProduct (ι.obj d) (ι.obj d'))]
(essImageDayConvolution :
∀ (d d' : D),
ι.essImage
((CategoryTheory.MonoidalCategory.tensor C).pointwiseLeftKanExtension
(CategoryTheory.MonoidalCategory.externalProduct (ι.obj d) (ι.obj d'))))
(d d' : D) (x y : C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.DayConvolution.unit (ι.obj d) (ι.obj d')).app (x, y))
(((fun d d' => ⋯.getIso) d d').inv.app (CategoryTheory.MonoidalCategoryStruct.tensorObj x y)) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.DayConvolution.unit (ι.obj d) (ι.obj d')).app (x, y))
(⋯.getIso.inv.app (CategoryTheory.MonoidalCategoryStruct.tensorObj x y)) |
CategoryTheory.Functor.LaxLeftLinear.μₗ | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} D} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} D'} →
(F : CategoryTheory.Functor D D') →
{C : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} →
{inst_3 : CategoryTheory.MonoidalCategory C} →
{inst_4 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D} →
{inst_5 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D'} →
[self : F.LaxLeftLinear C] →
(c : C) →
(d : D) →
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj c (F.obj d) ⟶
F.obj (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj c d) |
Function.Injective.groupWithZero | Mathlib.Algebra.GroupWithZero.InjSurj | {G₀ : Type u_2} →
{G₀' : Type u_4} →
[inst : GroupWithZero G₀] →
[inst_1 : Zero G₀'] →
[inst_2 : Mul G₀'] →
[inst_3 : One G₀'] →
[inst_4 : Inv G₀'] →
[inst_5 : Div G₀'] →
[inst_6 : Pow G₀' ℕ] →
[inst_7 : Pow G₀' ℤ] →
(f : G₀' → G₀) →
Function.Injective f →
f 0 = 0 →
f 1 = 1 →
(∀ (x y : G₀'), f (x * y) = f x * f y) →
(∀ (x : G₀'), f x⁻¹ = (f x)⁻¹) →
(∀ (x y : G₀'), f (x / y) = f x / f y) →
(∀ (x : G₀') (n : ℕ), f (x ^ n) = f x ^ n) →
(∀ (x : G₀') (n : ℤ), f (x ^ n) = f x ^ n) → GroupWithZero G₀' |
ENat.floor_le_self | Mathlib.Algebra.Order.Floor.Extended | ∀ {r : ENNReal}, ↑⌊r⌋ₑ ≤ r |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.sum_ne_add_mod_eq_sub_one | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {n r c : ℕ}, (∑ w ∈ Finset.range r, if c % r ≠ (n + w) % r then 1 else 0) = r - 1 |
MLList.filterMap | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α β : Type u_1} → [Monad m] → (α → Option β) → MLList m α → MLList m β |
CFC.log_one | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : StarRing A] [inst_2 : NormedAlgebra ℝ A]
[inst_3 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint], CFC.log 1 = 0 |
_private.Init.Data.Range.Polymorphic.SInt.0.Int32.instUpwardEnumerable._proof_1 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int32), Int32.minValue.toInt ≤ i.toInt → ¬Int32.minValue.toInt ≤ i.toInt + ↑n → False |
FirstOrder.Language.HomClass.mk._flat_ctor | Mathlib.ModelTheory.Basic | ∀ {L : outParam FirstOrder.Language} {F : Type u_3} {M : outParam (Type u_4)} {N : outParam (Type u_5)}
[inst : FunLike F M N] [inst_1 : L.Structure M] [inst_2 : L.Structure N],
(∀ (φ : F) {n : ℕ} (f : L.Functions n) (x : Fin n → M),
φ (FirstOrder.Language.Structure.funMap f x) = FirstOrder.Language.Structure.funMap f (⇑φ ∘ x)) →
(∀ (φ : F) {n : ℕ} (r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r x → FirstOrder.Language.Structure.RelMap r (⇑φ ∘ x)) →
L.HomClass F M N |
TendstoLocallyUniformlyOn.tendsto_at | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
TendstoLocallyUniformlyOn F f p s → ∀ {a : α}, a ∈ s → Filter.Tendsto (fun i => F i a) p (nhds (f a)) |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk.injEq | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(toLaxFunctor : CategoryTheory.LaxFunctor B C)
(map_id :
autoParam
(∀ (X : B),
toLaxFunctor.map (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (toLaxFunctor.obj X))
CategoryTheory.StrictlyUnitaryLaxFunctor.map_id._autoParam)
(mapId_eq_eqToHom :
autoParam (∀ (X : B), toLaxFunctor.mapId X = CategoryTheory.eqToHom ⋯)
CategoryTheory.StrictlyUnitaryLaxFunctor.mapId_eq_eqToHom._autoParam)
(toLaxFunctor_1 : CategoryTheory.LaxFunctor B C)
(map_id_1 :
autoParam
(∀ (X : B),
toLaxFunctor_1.map (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (toLaxFunctor_1.obj X))
CategoryTheory.StrictlyUnitaryLaxFunctor.map_id._autoParam)
(mapId_eq_eqToHom_1 :
autoParam (∀ (X : B), toLaxFunctor_1.mapId X = CategoryTheory.eqToHom ⋯)
CategoryTheory.StrictlyUnitaryLaxFunctor.mapId_eq_eqToHom._autoParam),
({ toLaxFunctor := toLaxFunctor, map_id := map_id, mapId_eq_eqToHom := mapId_eq_eqToHom } =
{ toLaxFunctor := toLaxFunctor_1, map_id := map_id_1, mapId_eq_eqToHom := mapId_eq_eqToHom_1 }) =
(toLaxFunctor = toLaxFunctor_1) |
padicValInt | Mathlib.NumberTheory.Padics.PadicVal.Basic | ℕ → ℤ → ℕ |
Int.Linear.instBEqPoly.beq_spec | Init.Data.Int.Linear | ∀ (x x_1 : Int.Linear.Poly),
(x == x_1) =
match x, x_1 with
| Int.Linear.Poly.num a, Int.Linear.Poly.num b => a == b
| Int.Linear.Poly.add a a_1 a_2, Int.Linear.Poly.add b b_1 b_2 => a == b && (a_1 == b_1 && a_2 == b_2)
| x, x_2 => false |
_private.Lean.Elab.Tactic.Do.ProofMode.Frame.0.Lean.Elab.Tactic.Do.ProofMode.transferHypNames.label.match_5 | Lean.Elab.Tactic.Do.ProofMode.Frame | (motive : List Lean.Elab.Tactic.Do.ProofMode.Hyp → Sort u_1) →
(Ps' : List Lean.Elab.Tactic.Do.ProofMode.Hyp) →
((P : Lean.Elab.Tactic.Do.ProofMode.Hyp) → (Ps'' : List Lean.Elab.Tactic.Do.ProofMode.Hyp) → motive (P :: Ps'')) →
((x : List Lean.Elab.Tactic.Do.ProofMode.Hyp) → motive x) → motive Ps' |
Std.ExtDHashMap.getD_ofList_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} [inst : LawfulBEq α] {l : List ((a : α) × β a)} {k : α}
{fallback : β k}, (List.map Sigma.fst l).contains k = false → (Std.ExtDHashMap.ofList l).getD k fallback = fallback |
Std.ExtDTreeMap.get_getKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α}
{h : (t.getKey? a).isSome = true}, (t.getKey? a).get h = t.getKey a ⋯ |
MeasureTheory.Measure.singularPart_eq_zero | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [μ.HaveLebesgueDecomposition ν],
μ.singularPart ν = 0 ↔ μ.AbsolutelyContinuous ν |
CliffordAlgebra.ofBaseChangeAux._proof_5 | Mathlib.LinearAlgebra.CliffordAlgebra.BaseChange | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) |
_private.Mathlib.Analysis.Analytic.Order.0.AnalyticAt.analyticOrderAt_deriv_add_one._simp_1_2 | Mathlib.Analysis.Analytic.Order | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
LinearMap.coe_equivOfIsUnitDet | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module.Free R M] [inst_4 : Module.Finite R M] {f : M →ₗ[R] M} (h : IsUnit (LinearMap.det f)),
↑(LinearMap.equivOfIsUnitDet h) = f |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.GetUnivsResult.casesOn | Lean.Meta.Sym.Simp.Have | {motive : Lean.Meta.Sym.Simp.GetUnivsResult✝ → Sort u} →
(t : Lean.Meta.Sym.Simp.GetUnivsResult✝¹) →
((argUnivs fnUnivs : Array Lean.Level) → motive { argUnivs := argUnivs, fnUnivs := fnUnivs }) → motive t |
_private.Mathlib.MeasureTheory.SetSemiring.0.MeasureTheory.IsSetSemiring.exists_disjoint_finset_diff_eq._simp_1_7 | Mathlib.MeasureTheory.SetSemiring | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop} {P : (x : α) → p x → Prop},
((∃ x, ∃ (h : p x), P x h) → b) = ∀ (x : α) (h : p x), P x h → b |
Function.Surjective.comp_left | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : Sort v} {γ : Sort w} {g : β → γ}, Function.Surjective g → Function.Surjective fun x => g ∘ x |
Lean.Widget.instInhabitedStrictOrLazy | Lean.Widget.InteractiveDiagnostic | {a : Type} → [Inhabited a] → {a_1 : Type} → Inhabited (Lean.Widget.StrictOrLazy a a_1) |
List.headD.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (x a : α) (as : List α), (a :: as).headD x = a |
Set.biUnion_union | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} (s t : Set α) (u : α → Set β), ⋃ x ∈ s ∪ t, u x = (⋃ x ∈ s, u x) ∪ ⋃ x ∈ t, u x |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.mk | Lean.Meta.LetToHave | ℕ → Std.HashMap Lean.ExprStructEq Lean.Meta.LetToHave.Result✝ → Lean.Meta.LetToHave.State✝ |
MaximalSpectrum.recOn | Mathlib.RingTheory.Spectrum.Maximal.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
{motive : MaximalSpectrum R → Sort u} →
(t : MaximalSpectrum R) →
((asIdeal : Ideal R) →
(isMaximal : asIdeal.IsMaximal) → motive { asIdeal := asIdeal, isMaximal := isMaximal }) →
motive t |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl.match_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
(F : CategoryTheory.Functor C FintypeCat) →
{X Y : CategoryTheory.PreGaloisCategory.PointedGaloisObject F} →
(motive : (X ⟶ Y) → Sort u_4) →
(x : X ⟶ Y) →
((f : X.obj ⟶ Y.obj) →
(comp : (CategoryTheory.ConcreteCategory.hom (F.map f)) X.pt = Y.pt) →
motive { val := f, comp := comp }) →
motive x |
Lean.DeclNameGenerator.mk.inj | Lean.CoreM | ∀ {namePrefix : Lean.Name} {idx : ℕ} {parentIdxs : List ℕ} {namePrefix_1 : Lean.Name} {idx_1 : ℕ}
{parentIdxs_1 : List ℕ},
{ namePrefix := namePrefix, idx := idx, parentIdxs := parentIdxs } =
{ namePrefix := namePrefix_1, idx := idx_1, parentIdxs := parentIdxs_1 } →
namePrefix = namePrefix_1 ∧ idx = idx_1 ∧ parentIdxs = parentIdxs_1 |
SSet.horn₂₀.ι₀₂._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | 1 ≠ 0 |
ProperCone.toPointedCone_bot | Mathlib.Analysis.Convex.Cone.Basic | ∀ {R : Type u_2} {E : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : Module R E] [inst_6 : T1Space E], ↑⊥ = ⊥ |
Equiv.decidableEq | Mathlib.Logic.Equiv.Defs | {α : Sort u} → {β : Sort v} → α ≃ β → [DecidableEq β] → DecidableEq α |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_2 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CStarRing Aᵐᵒᵖ |
Lean.Parser.Command.namespace.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer |
RelIso.apply_eq_iff_eq | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≃r s) {x y : α}, f x = f y ↔ x = y |
MonoidAlgebra.instCoalgebra | Mathlib.RingTheory.Coalgebra.MonoidAlgebra | (R : Type u_1) →
[inst : CommSemiring R] →
(A : Type u_2) →
[inst_1 : Semiring A] → (X : Type u_3) → [inst_2 : Module R A] → [Coalgebra R A] → Coalgebra R (MonoidAlgebra A X) |
RCLike.instPosMulReflectLE | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], PosMulReflectLE K |
IsOpen.exists_eq_add_of_deriv_eq | Mathlib.Analysis.Calculus.MeanValue | ∀ {𝕜 : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] {s : Set 𝕜}
{f g : 𝕜 → G},
IsOpen s →
IsPreconnected s →
DifferentiableOn 𝕜 f s →
DifferentiableOn 𝕜 g s → Set.EqOn (deriv f) (deriv g) s → ∃ a, Set.EqOn f (fun x => g x + a) s |
_private.Batteries.Data.List.Lemmas.0.List.take_succ_drop._proof_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {n stop : ℕ}, n < l.length - stop → ¬stop + n < l.length → False |
AlgebraicGeometry.Scheme.Modules.pseudofunctor._proof_7 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {b₀ b₁ b₂ b₃ : AlgebraicGeometry.Schemeᵒᵖ} (f : b₀ ⟶ b₁) (g : b₁ ⟶ b₂) (h : b₂ ⟶ b₃),
CategoryTheory.CategoryStruct.comp
((fun {b₀ b₁ b₂} x x_1 =>
CategoryTheory.Bicategory.Adj.iso₂Mk
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.unop x.unop).symm)
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.unop x.unop)) ⋯)
(CategoryTheory.CategoryStruct.comp f g) h).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight
((fun {b₀ b₁ b₂} x x_1 =>
CategoryTheory.Bicategory.Adj.iso₂Mk
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.unop x.unop).symm)
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.unop x.unop)) ⋯)
f g).hom
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
h))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
f)
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
g)
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
h)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Scheme.Modules.pushforward f.unop).toCatHom,
adj := (AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction f.unop).toCat })
f)
((fun {b₀ b₁ b₂} x x_1 =>
CategoryTheory.Bicategory.Adj.iso₂Mk
(CategoryTheory.Cat.Hom.isoMk
(AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.unop x.unop).symm)
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.unop x.unop))
⋯)
g h).inv)
((fun {b₀ b₁ b₂} x x_1 =>
CategoryTheory.Bicategory.Adj.iso₂Mk
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.unop x.unop).symm)
(CategoryTheory.Cat.Hom.isoMk (AlgebraicGeometry.Scheme.Modules.pushforwardComp x_1.unop x.unop)) ⋯)
f (CategoryTheory.CategoryStruct.comp g h)).inv))) =
CategoryTheory.eqToHom ⋯ |
_private.Mathlib.Algebra.Category.Ring.Basic.0.RingCat.Hom.mk | Mathlib.Algebra.Category.Ring.Basic | {R S : RingCat} → (↑R →+* ↑S) → R.Hom S |
NonUnitalSubsemiring.map_equiv_eq_comap_symm | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] (f : R ≃+* S)
(K : NonUnitalSubsemiring R), NonUnitalSubsemiring.map (↑f) K = NonUnitalSubsemiring.comap f.symm K |
Polynomial.trailingDegree_eq_iff_natTrailingDegree_eq_of_pos | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ}, n ≠ 0 → (p.trailingDegree = ↑n ↔ p.natTrailingDegree = n) |
ContinuousLinearMap.IsPositive.inner_nonneg_right | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →L[𝕜] E}, T.IsPositive → ∀ (x : E), 0 ≤ inner 𝕜 x (T x) |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycle.of_pow._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α}, (f x ≠ x) = (x ∈ f.support) |
_private.Mathlib.Data.Set.Finite.Basic.0.Set.finite_of_forall_not_lt_lt._simp_1_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α} {p : (x : α) → x ∈ s → Prop}, (∀ (x : α) (h : x ∈ s), p x h) = ∀ (x : ↑s), p ↑x ⋯ |
Batteries.Tactic.Lint.SimpTheoremInfo.rec | Batteries.Tactic.Lint.Simp | {motive : Batteries.Tactic.Lint.SimpTheoremInfo → Sort u} →
((hyps : Array Lean.Expr) → (lhs rhs : Lean.Expr) → motive { hyps := hyps, lhs := lhs, rhs := rhs }) →
(t : Batteries.Tactic.Lint.SimpTheoremInfo) → motive t |
Equiv.sigmaCongrRight_trans | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_4} {β₁ : α → Type u_1} {β₂ : α → Type u_2} {β₃ : α → Type u_3} (F : (a : α) → β₁ a ≃ β₂ a)
(G : (a : α) → β₂ a ≃ β₃ a),
(Equiv.sigmaCongrRight F).trans (Equiv.sigmaCongrRight G) = Equiv.sigmaCongrRight fun a => (F a).trans (G a) |
instReprVector | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → [Repr α] → Repr (Vector α n) |
Std.TreeMap.getElem!_diff_of_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β], k ∈ t₂ → (t₁ \ t₂)[k]! = default |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan.0.MeasureTheory.SignedMeasure.of_diff_eq_zero_of_symmDiff_eq_zero_negative._simp_1_1 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) |
Lean.Grind.CommSemiring.casesOn | Init.Grind.Ring.Basic | {α : Type u} →
{motive : Lean.Grind.CommSemiring α → Sort u_1} →
(t : Lean.Grind.CommSemiring α) →
([toSemiring : Lean.Grind.Semiring α] →
(mul_comm : ∀ (a b : α), a * b = b * a) → motive { toSemiring := toSemiring, mul_comm := mul_comm }) →
motive t |
pointedToBipointedSndBipointedToPointedSndAdjunction | Mathlib.CategoryTheory.Category.Bipointed | pointedToBipointedSnd ⊣ bipointedToPointedSnd |
RatFunc.instDiv | Mathlib.FieldTheory.RatFunc.Basic | {K : Type u} → [inst : CommRing K] → [IsDomain K] → Div (RatFunc K) |
_private.Mathlib.Data.List.Basic.0.List.dropLast_append_getLast.match_1_1 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (motive : (x : List α) → x ≠ [] → Prop) (x : List α) (x_1 : x ≠ []),
(∀ (h : [] ≠ []), motive [] h) →
(∀ (head : α) (x : [head] ≠ []), motive [head] x) →
(∀ (a b : α) (l : List α) (h : a :: b :: l ≠ []), motive (a :: b :: l) h) → motive x x_1 |
HomotopicalAlgebra.cofibration_iff | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithCofibrations C],
HomotopicalAlgebra.Cofibration f ↔ HomotopicalAlgebra.cofibrations C f |
Function.mulSupport_fun_curry | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : One M] (f : ι × κ → M),
(Function.mulSupport fun i j => f (i, j)) = Prod.fst '' Function.mulSupport f |
Lean.MonadRecDepth.getRecDepth | Lean.Exception | {m : Type → Type} → [self : Lean.MonadRecDepth m] → m ℕ |
List.le_sum_of_subadditive_on_pred | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {α : Type u_5} {β : Type u_6} [inst : AddMonoid α] [inst_1 : AddCommMonoid β] [inst_2 : Preorder β]
[IsOrderedAddMonoid β] (f : α → β) (p : α → Prop),
f 0 ≤ 0 →
p 0 →
(∀ (a b : α), p a → p b → f (a + b) ≤ f a + f b) →
(∀ (a b : α), p a → p b → p (a + b)) → ∀ (l : List α), (∀ a ∈ l, p a) → f l.sum ≤ (List.map f l).sum |
Units.ofPow._proof_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : Monoid M] (u : Mˣ) (x : M) {n : ℕ}, n ≠ 0 → x ^ n = ↑u → x * x ^ (n - 1) = ↑u |
Array.exists_mem_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (p : α → Prop), ¬∃ x, ∃ (_ : x ∈ #[]), p x |
Function.Injective.unique | Mathlib.Logic.Unique | {α : Sort u_1} → {β : Sort u_2} → {f : α → β} → [Inhabited α] → [Subsingleton β] → Function.Injective f → Unique α |
InnerProductSpace.Core.inner_smul_left | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x y : F) {r : 𝕜}, inner 𝕜 (r • x) y = (starRingEnd 𝕜) r * inner 𝕜 x y |
_private.Mathlib.RingTheory.PrincipalIdealDomain.0.Ideal.nonPrincipals_eq_empty_iff._simp_1_1 | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s |
_private.Mathlib.Analysis.SpecialFunctions.Complex.LogBounds.0.Complex.norm_log_sub_logTaylor_le._simp_1_8 | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
Lean.Lsp.DeclInfo.mk | Lean.Data.Lsp.Internal | ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → Lean.Lsp.DeclInfo |
AddCommute.op | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] {x y : α}, AddCommute x y → AddCommute (AddOpposite.op x) (AddOpposite.op y) |
CategoryTheory.Limits.Cone.fromStructuredArrow._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
(F : CategoryTheory.Functor C D) {X : D} (G : CategoryTheory.Functor J (CategoryTheory.StructuredArrow X F))
⦃X_1 Y : J⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const J).obj X).map f) (G.obj Y).hom =
CategoryTheory.CategoryStruct.comp (G.obj X_1).hom
((G.comp ((CategoryTheory.StructuredArrow.proj X F).comp F)).map f) |
_private.Mathlib.Order.Disjoint.0.disjoint_assoc._proof_1_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b c : α}, Disjoint (a ⊓ b) c ↔ Disjoint a (b ⊓ c) |
AlgebraicGeometry.IsFinite.rec | Mathlib.AlgebraicGeometry.Morphisms.Finite | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsFinite f → Sort u} →
([toIsAffineHom : AlgebraicGeometry.IsAffineHom f] →
(finite_app :
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U →
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.app f U)).Finite) →
motive ⋯) →
(t : AlgebraicGeometry.IsFinite f) → motive t |
TestFunction.postcompCLM._proof_10 | Mathlib.Analysis.Distribution.TestFunction | ∀ {𝕜 : Type u_4} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {F' : Type u_3} [inst_6 : NormedAddCommGroup F']
[inst_7 : NormedSpace ℝ F'] [inst_8 : NormedSpace 𝕜 F'] {n : ℕ∞} [inst_9 : Algebra ℝ 𝕜]
[inst_10 : IsScalarTower ℝ 𝕜 F] [inst_11 : IsScalarTower ℝ 𝕜 F'] (T : F →L[𝕜] F') (K : TopologicalSpace.Compacts E)
(K_sub_Ω : ↑K ⊆ ↑Ω),
Continuous
((fun f => { toFun := ⇑T ∘ ⇑f, contDiff' := ⋯, hasCompactSupport' := ⋯, tsupport_subset' := ⋯ }) ∘
TestFunction.ofSupportedIn K_sub_Ω) |
Num.toZNum_inj | Mathlib.Data.Num.Lemmas | ∀ {m n : Num}, m.toZNum = n.toZNum ↔ m = n |
Std.DTreeMap.Internal.Impl.getEntryLT | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(t : Std.DTreeMap.Internal.Impl α β) → t.Ordered → (∃ a ∈ t, compare a k = Ordering.lt) → (a : α) × β a |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.brecOn.eq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u}
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u}
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u}
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u}
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Sort u}
{motive_6 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof → Sort u}
{motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u}
{motive_8 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Sort u}
{motive_9 : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof → Sort u}
{motive_10 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Sort u}
{motive_11 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof → Sort u}
{motive_12 : Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u}
{motive_13 : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u}
{motive_14 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u}
{motive_15 : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u}
{motive_16 : Array (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → Sort u}
{motive_17 : List (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u}
{motive_18 : List (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → Sort u}
{motive_19 : Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u}
{motive_20 : Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u}
{motive_21 : ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} (t : Lean.Meta.Grind.Arith.Cutsat.LeCnstr)
(F_1 : (t : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof) → t.below → motive_2 t)
(F_3 : (t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → t.below → motive_3 t)
(F_4 : (t : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred) → t.below → motive_4 t)
(F_5 : (t : Lean.Meta.Grind.Arith.Cutsat.CooperSplit) → t.below → motive_5 t)
(F_6 : (t : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof) → t.below → motive_6 t)
(F_7 : (t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) → t.below → motive_7 t)
(F_8 : (t : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) → t.below → motive_8 t)
(F_9 : (t : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof) → t.below → motive_9 t)
(F_10 : (t : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr) → t.below → motive_10 t)
(F_11 : (t : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof) → t.below → motive_11 t)
(F_12 : (t : Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → t.below → motive_12 t)
(F_13 :
(t : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_1 t → motive_13 t)
(F_14 :
(t : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_2 t → motive_14 t)
(F_15 :
(t : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_3 t → motive_15 t)
(F_16 :
(t : Array (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_4 t → motive_16 t)
(F_17 :
(t : List (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_5 t → motive_17 t)
(F_18 :
(t : List (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_6 t → motive_18 t)
(F_19 :
(t : Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_7 t → motive_19 t)
(F_20 :
(t : Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_8 t → motive_20 t)
(F_21 :
(t : ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_9 t → motive_21 t),
t.brecOn F_1 F_2 F_3 F_4 F_5 F_6 F_7 F_8 F_9 F_10 F_11 F_12 F_13 F_14 F_15 F_16 F_17 F_18 F_19 F_20 F_21 =
F_8 t
(Lean.Meta.Grind.Arith.Cutsat.LeCnstr.brecOn.go t F_1 F_2 F_3 F_4 F_5 F_6 F_7 F_8 F_9 F_10 F_11 F_12 F_13 F_14
F_15 F_16 F_17 F_18 F_19 F_20 F_21).2 |
Metric.diam_cthickening_le | Mathlib.Topology.MetricSpace.Thickening | ∀ {ε : ℝ} {α : Type u_2} [inst : PseudoMetricSpace α] (s : Set α),
0 ≤ ε → Metric.diam (Metric.cthickening ε s) ≤ Metric.diam s + 2 * ε |
CategoryTheory.Monoidal.instMonoidalTransportedInverseEquivalenceTransported._proof_4 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} D] (e : C ≌ D)
{X₁ Y₁ X₂ Y₂ : CategoryTheory.Monoidal.Transported e} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
e.inverse.map (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) =
CategoryTheory.CategoryStruct.comp
(e.unitIso.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj X₁) (e.inverse.obj X₂))).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (e.inverse.map f) (e.inverse.map g))
(e.unitIso.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj Y₁) (e.inverse.obj Y₂))).hom) |
Module.Grassmannian._sizeOf_inst | Mathlib.RingTheory.Grassmannian | (R : Type u) →
{inst : CommRing R} →
(M : Type v) →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} → (k : ℕ) → [SizeOf R] → [SizeOf M] → SizeOf (Module.Grassmannian R M k) |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetLimitCone_cone_π_app | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type w}
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape (Finset (CategoryTheory.Discrete α))ᵒᵖ C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete α) C) (j : CategoryTheory.Discrete α),
(CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetLimitCone F).cone.π.app j =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.limit.π (CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetObj F)
(Opposite.op {j}))
(CategoryTheory.Limits.Pi.π (fun x => F.obj ↑x) ⟨j, ⋯⟩) |
Function.IsFixedPt.image_iterate | Mathlib.Dynamics.FixedPoints.Basic | ∀ {α : Type u} {f : α → α} {s : Set α},
Function.IsFixedPt (Set.image f) s → ∀ (n : ℕ), Function.IsFixedPt (Set.image f^[n]) s |
WittVector.instCommRing._proof_9 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (z : ℤ)
(x : WittVector p (MvPolynomial R ℤ)),
WittVector.mapFun (⇑(MvPolynomial.counit R)) (z • x) = z • WittVector.mapFun (⇑(MvPolynomial.counit R)) x |
Lean.Compiler.LCNF.Simp.ConstantFold.folderExt | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.PersistentEnvExtension Lean.Compiler.LCNF.Simp.ConstantFold.FolderOleanEntry
Lean.Compiler.LCNF.Simp.ConstantFold.FolderEntry
(List Lean.Compiler.LCNF.Simp.ConstantFold.FolderEntry ×
Lean.SMap Lean.Name Lean.Compiler.LCNF.Simp.ConstantFold.Folder) |
ULift.seminormedRing._proof_17 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] (a : ULift.{u_1, u_2} α), -a + a = 0 |
Aesop.Nanos.nanos | Aesop.Nanos | Aesop.Nanos → ℕ |
Set.Ioc_add_bij | Mathlib.Algebra.Order.Interval.Set.Monoid | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [IsOrderedCancelAddMonoid M] [ExistsAddOfLE M]
(a b d : M), Set.BijOn (fun x => x + d) (Set.Ioc a b) (Set.Ioc (a + d) (b + d)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.