name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.Time.ZonedDateTime.toPlainDateTime | Std.Time.Zoned.ZonedDateTime | Std.Time.ZonedDateTime → Std.Time.PlainDateTime |
Multiset.decidableEq._proof_2 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} (x x_1 : List α), ⟦x⟧ = ⟦x_1⟧ ↔ x ≈ x_1 |
gcd_same | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α), gcd a a = normalize a |
Lean.Elab.InlayHintTextEdit.recOn | Lean.Elab.InfoTree.InlayHints | {motive : Lean.Elab.InlayHintTextEdit → Sort u} →
(t : Lean.Elab.InlayHintTextEdit) →
((range : Lean.Syntax.Range) → (newText : String) → motive { range := range, newText := newText }) → motive t |
NormedAddGroupHom.coeAddHom_apply | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(a : NormedAddGroupHom V₁ V₂) (a_1 : V₁), NormedAddGroupHom.coeAddHom a a_1 = a a_1 |
CategoryTheory.ShortComplex.Exact.epi_f | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.Exact → S.g = 0 → CategoryTheory.Epi S.f |
bddAbove_Ioc | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, BddAbove (Set.Ioc a b) |
CochainComplex.HomComplex.leftHomologyData'_π | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m p : ℤ) (hm : n + 1 = m) (hp : m + 1 = p),
(CochainComplex.HomComplex.leftHomologyData' K L n m p hm hp).π =
AddCommGrpCat.ofHom (CochainComplex.HomComplex.CohomologyClass.mkAddMonoidHom K L m) |
HomologicalComplex.shortComplexFunctor'._proof_5 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_3} (c : ComplexShape ι) (i j k : ι) (X : HomologicalComplex C c),
{ τ₁ := (CategoryTheory.CategoryStruct.id X).f i, τ₂ := (CategoryTheory.CategoryStruct.id X).f j,
τ₃ := (CategoryTheory.CategoryStruct.id X).f k, comm₁₂ := ⋯, comm₂₃ := ⋯ } =
CategoryTheory.CategoryStruct.id { X₁ := X.X i, X₂ := X.X j, X₃ := X.X k, f := X.d i j, g := X.d j k, zero := ⋯ } |
Measurable.lmarginal | Mathlib.MeasureTheory.Integral.Marginal | ∀ {δ : Type u_1} {X : δ → Type u_3} [inst : (i : δ) → MeasurableSpace (X i)] (μ : (i : δ) → MeasureTheory.Measure (X i))
[inst_1 : DecidableEq δ] {s : Finset δ} {f : ((i : δ) → X i) → ENNReal} [∀ (i : δ), MeasureTheory.SigmaFinite (μ i)],
Measurable f → Measurable (∫⋯∫⁻_s, f ∂μ) |
MeasureTheory.Measure.toSphere_apply_aux | Mathlib.MeasureTheory.Constructions.HaarToSphere | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E]
(μ : MeasureTheory.Measure E) (s : Set ↑(Metric.sphere 0 1)) (r : ↑(Set.Ioi 0)),
μ (Subtype.val '' (⇑(homeomorphUnitSphereProd E) ⁻¹' s ×ˢ Set.Iio r)) = μ (Set.Ioo 0 ↑r • Subtype.val '' s) |
CoalgHom.End._proof_3 | Mathlib.RingTheory.Coalgebra.Hom | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] (x x_1 x_2 : A →ₗc[R] A), x * x_1 * x_2 = x * x_1 * x_2 |
InitialSeg.total | Mathlib.Order.InitialSeg | {α : Type u_1} →
{β : Type u_2} →
(r : α → α → Prop) → (s : β → β → Prop) → [IsWellOrder α r] → [IsWellOrder β s] → InitialSeg r s ⊕ InitialSeg s r |
Set.unit._proof_4 | Mathlib.RingTheory.DedekindDomain.SInteger | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (S : Set (IsDedekindDomain.HeightOneSpectrum R))
(K : Type u_1) [inst_2 : Field K] [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (x : Kˣ),
x ∈ {x | ∀ v ∉ S, (IsDedekindDomain.HeightOneSpectrum.valuation K v) ↑x = 1} ↔
x ∈ ↑(⨅ v, ⨅ (_ : v ∉ S), (IsDedekindDomain.HeightOneSpectrum.valuation K v).valuationSubring.unitGroup) |
Polynomial.instIsJacobsonRing | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} [inst : CommRing R] [IsJacobsonRing R], IsJacobsonRing (Polynomial R) |
fintypeNodupList._simp_3 | Mathlib.Data.Fintype.List | ∀ {α : Type u_1} {β : Type v} {b : β} {s : Multiset α} {f : α → Multiset β}, (b ∈ s.bind f) = ∃ a ∈ s, b ∈ f a |
LinearMap.ofIsComplProdEquiv._proof_2 | Mathlib.LinearAlgebra.Projection | ∀ {R₁ : Type u_1} [inst : CommRing R₁], RingHomInvPair (RingHom.id R₁) (RingHom.id R₁) |
IsRelPrime.neg_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → IsRelPrime x (-y) |
Mathlib.Tactic.BicategoryLike.IsoLift.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → Mathlib.Tactic.BicategoryLike.IsoLift |
Representation.invtSubmodule.instBoundedOrderSubtypeSubmoduleMemSublattice.match_1 | Mathlib.RepresentationTheory.Submodule | ∀ {k : Type u_2} {G : Type u_3} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (motive : ↥ρ.invtSubmodule → Prop) (x : ↥ρ.invtSubmodule),
(∀ (p : Submodule k V) (hp : p ∈ ρ.invtSubmodule), motive ⟨p, hp⟩) → motive x |
Equiv.Perm.IsCycle.zpowersEquivSupport.congr_simp | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {σ : Equiv.Perm α} (hσ : σ.IsCycle),
hσ.zpowersEquivSupport = hσ.zpowersEquivSupport |
Std.TreeMap.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeMap α Unit cmp} [Std.TransCmp cmp] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
k ∉ t → List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (t.insertManyIfNewUnit l).getKey? k' = some k |
ModelWithCorners.continuous_invFun | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (self : ModelWithCorners 𝕜 E H),
Continuous self.invFun |
AlgEquiv.autCongr_trans | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} {A₃ : Type uA₃} [inst : CommSemiring R] [inst_1 : Semiring A₁]
[inst_2 : Semiring A₂] [inst_3 : Semiring A₃] [inst_4 : Algebra R A₁] [inst_5 : Algebra R A₂] [inst_6 : Algebra R A₃]
(ϕ : A₁ ≃ₐ[R] A₂) (ψ : A₂ ≃ₐ[R] A₃), ϕ.autCongr.trans ψ.autCongr = (ϕ.trans ψ).autCongr |
Set.image_subset_iff | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, f '' s ⊆ t ↔ s ⊆ f ⁻¹' t |
AlgebraicGeometry.Scheme.Opens.fromSpecStalkOfMem_toSpecΓ_assoc | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens) (x : ↥X) (hxU : x ∈ U) {Z : AlgebraicGeometry.Scheme}
(h : AlgebraicGeometry.Spec (X.presheaf.obj (Opposite.op U)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (U.fromSpecStalkOfMem x hxU) (CategoryTheory.CategoryStruct.comp U.toSpecΓ h) =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map (X.presheaf.germ U x hxU)) h |
ISize | Init.Data.SInt.Basic | Type |
ContinuousMap.Homotopy.affine_apply | Mathlib.Topology.Homotopy.Affine | ∀ {X : Type u_1} {E : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : IsTopologicalAddGroup E] [inst_4 : Module ℝ E] [inst_5 : ContinuousSMul ℝ E] (f g : C(X, E))
(x : ↑unitInterval × X), (ContinuousMap.Homotopy.affine f g) x = (AffineMap.lineMap (f x.2) (g x.2)) ↑x.1 |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.constrToProp.match_3 | Lean.Meta.MkIffOfInductiveProp | (motive : Option ℕ × Lean.Expr → Sort u_1) →
(__discr : Option ℕ × Lean.Expr) → ((n : Option ℕ) → (r : Lean.Expr) → motive (n, r)) → motive __discr |
TensorProduct.Neg.aux | Mathlib.LinearAlgebra.TensorProduct.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
{M : Type u_2} →
{N : Type u_3} →
[inst_1 : AddCommGroup M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] → [inst_4 : Module R N] → TensorProduct R M N →ₗ[R] TensorProduct R M N |
CategoryTheory.eqToIso | Mathlib.CategoryTheory.EqToHom | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → X = Y → (X ≅ Y) |
Lean.Elab.instInhabitedDefView | Lean.Elab.DefView | Inhabited Lean.Elab.DefView |
SSet.prodStdSimplex.objEquiv._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex | ∀ {p q n : ℕ}
(x :
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj (SimplexCategory.mk p))
(SSet.stdSimplex.obj (SimplexCategory.mk q))).obj
(Opposite.op (SimplexCategory.mk n))),
(SSet.stdSimplex.objEquiv.symm
(SimplexCategory.Hom.mk
(OrderHom.fst.comp
(match x with
| (x, y) =>
(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv x)).prod
(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv y))))),
SSet.stdSimplex.objEquiv.symm
(SimplexCategory.Hom.mk
(OrderHom.snd.comp
(match x with
| (x, y) =>
(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv x)).prod
(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv y)))))) =
x |
ZMod.charZero | Mathlib.Data.ZMod.Basic | CharZero (ZMod 0) |
ENNReal.tendsto_inv_iff | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [ContinuousInv G] {l : Filter α}
{m : α → G} {a : G}, Filter.Tendsto (fun x => (m x)⁻¹) l (nhds a⁻¹) ↔ Filter.Tendsto m l (nhds a) |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunctionRecurrence_eq_prefixFunction._simp_1_5 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ} {hst : stackPos < pat.size},
(String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat stackPos hst ≤ k) =
∀ (k' : ℕ),
k < k' → k' ≤ stackPos → ¬String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1) |
Besicovitch.SatelliteConfig.mk.inj | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} {inst : MetricSpace α} {N : ℕ} {τ : ℝ} {c : Fin N.succ → α} {r : Fin N.succ → ℝ}
{rpos : ∀ (i : Fin N.succ), 0 < r i}
{h : Pairwise fun i j => r i ≤ dist (c i) (c j) ∧ r j ≤ τ * r i ∨ r j ≤ dist (c j) (c i) ∧ r i ≤ τ * r j}
{hlast : ∀ i < Fin.last N, r i ≤ dist (c i) (c (Fin.last N)) ∧ r (Fin.last N) ≤ τ * r i}
{inter : ∀ i < Fin.last N, dist (c i) (c (Fin.last N)) ≤ r i + r (Fin.last N)} {c_1 : Fin N.succ → α}
{r_1 : Fin N.succ → ℝ} {rpos_1 : ∀ (i : Fin N.succ), 0 < r_1 i}
{h_1 :
Pairwise fun i j =>
r_1 i ≤ dist (c_1 i) (c_1 j) ∧ r_1 j ≤ τ * r_1 i ∨ r_1 j ≤ dist (c_1 j) (c_1 i) ∧ r_1 i ≤ τ * r_1 j}
{hlast_1 : ∀ i < Fin.last N, r_1 i ≤ dist (c_1 i) (c_1 (Fin.last N)) ∧ r_1 (Fin.last N) ≤ τ * r_1 i}
{inter_1 : ∀ i < Fin.last N, dist (c_1 i) (c_1 (Fin.last N)) ≤ r_1 i + r_1 (Fin.last N)},
{ c := c, r := r, rpos := rpos, h := h, hlast := hlast, inter := inter } =
{ c := c_1, r := r_1, rpos := rpos_1, h := h_1, hlast := hlast_1, inter := inter_1 } →
c = c_1 ∧ r = r_1 |
ProbabilityTheory.Kernel.withDensity_rnDeriv_of_subset_mutuallySingularSetSlice | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [ProbabilityTheory.IsFiniteKernel κ]
[inst : ProbabilityTheory.IsFiniteKernel η] {a : α} {s : Set γ},
s ⊆ κ.mutuallySingularSetSlice η a → ((η.withDensity (κ.rnDeriv η)) a) s = 0 |
Hindman.FS.brecOn | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : AddSemigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FS a a_1 → Prop}
{a : Stream' M} {a_1 : M} (t : Hindman.FS a a_1),
(∀ (a : Stream' M) (a_2 : M) (t : Hindman.FS a a_2), Hindman.FS.below t → motive a a_2 t) → motive a a_1 t |
Lean.PersistentHashMap.Entry.ctorElimType | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type w} →
{motive : Lean.PersistentHashMap.Entry α β σ → Sort u_1} →
ℕ → Sort (max 1 u_1 (imax (u + 1) (v + 1) u_1) (imax (w + 1) u_1)) |
SimpleGraph.TripartiteFromTriangles.Graph.in₂₁_iff._simp_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)} {b : β} {c : γ},
(SimpleGraph.TripartiteFromTriangles.graph t).Adj (Sum3.in₂ c) (Sum3.in₁ b) = ∃ a, (a, b, c) ∈ t |
GradeMinOrder.recOn | Mathlib.Order.Grade | {𝕆 : Type u_5} →
{α : Type u_6} →
[inst : Preorder 𝕆] →
[inst_1 : Preorder α] →
{motive : GradeMinOrder 𝕆 α → Sort u} →
(t : GradeMinOrder 𝕆 α) →
([toGradeOrder : GradeOrder 𝕆 α] →
(isMin_grade : ∀ ⦃a : α⦄, IsMin a → IsMin (GradeOrder.grade a)) →
motive { toGradeOrder := toGradeOrder, isMin_grade := isMin_grade }) →
motive t |
Aesop.RulePatternIndex.recOn | Aesop.Index.RulePattern | {motive : Aesop.RulePatternIndex → Sort u} →
(t : Aesop.RulePatternIndex) →
((tree : Lean.Meta.DiscrTree Aesop.RulePatternIndex.Entry) →
(isEmpty : Bool) → motive { tree := tree, isEmpty := isEmpty }) →
motive t |
CategoryTheory.GrothendieckTopology.instIsGeneratedByOneHypercovers | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C),
J.IsGeneratedByOneHypercovers |
_private.Mathlib.Order.OrderIsoNat.0.RelEmbedding.wellFounded_iff_isEmpty.match_1_1 | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {r : α → α → Prop} (motive : WellFounded r → Prop) (x : WellFounded r),
(∀ (h : ∀ (a : α), Acc r a), motive ⋯) → motive x |
Polynomial.Chebyshev.S_two_mul_complex_cosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Basic | ∀ (θ : ℂ) (n : ℤ),
Polynomial.eval (2 * Complex.cosh θ) (Polynomial.Chebyshev.S ℂ n) * Complex.sinh θ = Complex.sinh ((↑n + 1) * θ) |
NumberField.InfinitePlace.embedding_of_isReal_apply | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] {w : NumberField.InfinitePlace K} (hw : w.IsReal) (x : K),
↑((NumberField.InfinitePlace.embedding_of_isReal hw) x) = w.embedding x |
Std.HashMap.contains_keysArray | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, m.keysArray.contains k = m.contains k |
ContinuousInv.measurableInv | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {γ : Type u_3} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace γ] [BorelSpace γ] [inst_3 : Inv γ]
[ContinuousInv γ], MeasurableInv γ |
Homotopy.compLeftId | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} →
{C D : HomologicalComplex V c} →
{f : D ⟶ D} →
Homotopy f (CategoryTheory.CategoryStruct.id D) →
(g : C ⟶ D) → Homotopy (CategoryTheory.CategoryStruct.comp g f) g |
CategoryTheory.Join.mapWhiskerRight_rightUnitor_hom | Mathlib.CategoryTheory.Join.Pseudofunctor | ∀ {A : Type u_1} {B : Type u_2} (C : Type u_3) [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(F : CategoryTheory.Functor A B),
CategoryTheory.Join.mapWhiskerRight F.rightUnitor.hom (CategoryTheory.Functor.id C) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Join.mapCompLeft C F (CategoryTheory.Functor.id B)).hom
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Join.mapPair F (CategoryTheory.Functor.id C)).whiskerLeft CategoryTheory.Join.mapPairId.hom)
(CategoryTheory.Join.mapPair F (CategoryTheory.Functor.id C)).rightUnitor.hom) |
Std.TreeMap.Raw._sizeOf_inst | Std.Data.TreeMap.Raw.Basic | (α : Type u) →
(β : Type v) →
(cmp : autoParam (α → α → Ordering) Std.TreeMap.Raw._auto_1) →
[SizeOf α] → [SizeOf β] → SizeOf (Std.TreeMap.Raw α β cmp) |
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : AddCommMonoid β]
[inst_3 : Preorder β] [inst_4 : IsOrderedAddMonoid β],
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid =
{
add := fun f g =>
let __src := ↑f + ↑g;
{ toAddMonoidHom := __src, monotone' := ⋯ } } |
CategoryTheory.Limits.opProdIsoCoprod_inv_inl | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A B : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct A B],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opProdIsoCoprod A B).inv.unop
CategoryTheory.Limits.coprod.inl.unop =
CategoryTheory.Limits.prod.fst |
TopologicalSpace.IsTopologicalBasis.isOpen_iff | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {s : Set α} {b : Set (Set α)},
TopologicalSpace.IsTopologicalBasis b → (IsOpen s ↔ ∀ a ∈ s, ∃ t ∈ b, a ∈ t ∧ t ⊆ s) |
AddCon.addMonoid._proof_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] (c : AddCon M), Function.Surjective Quotient.mk'' |
SimpleGraph.bot_adj | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (v w : V), ⊥.Adj v w ↔ False |
Subring.mem_pointwise_smul_iff_inv_smul_mem | Mathlib.Algebra.Ring.Subring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] {a : M}
{S : Subring R} {x : R}, x ∈ a • S ↔ a⁻¹ • x ∈ S |
CategoryTheory.Grp.hom_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_ | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (H : CategoryTheory.Grp C) [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.MonObj.one.hom.hom = CategoryTheory.MonObj.one |
Aesop.Hyp.mk | Aesop.Forward.State | Option Lean.FVarId → Aesop.Substitution → Aesop.Hyp |
TypeVec.splitFun | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u_1} (n + 1)} → {α' : TypeVec.{u_2} (n + 1)} → α.drop.Arrow α'.drop → (α.last → α'.last) → α.Arrow α' |
Lean.Elab.CommandContextInfo.mk.injEq | Lean.Elab.InfoTree.Types | ∀ (env : Lean.Environment) (cmdEnv? : Option Lean.Environment) (fileMap : Lean.FileMap) (mctx : Lean.MetavarContext)
(options : Lean.Options) (currNamespace : Lean.Name) (openDecls : List Lean.OpenDecl) (ngen : Lean.NameGenerator)
(env_1 : Lean.Environment) (cmdEnv?_1 : Option Lean.Environment) (fileMap_1 : Lean.FileMap)
(mctx_1 : Lean.MetavarContext) (options_1 : Lean.Options) (currNamespace_1 : Lean.Name)
(openDecls_1 : List Lean.OpenDecl) (ngen_1 : Lean.NameGenerator),
({ env := env, cmdEnv? := cmdEnv?, fileMap := fileMap, mctx := mctx, options := options,
currNamespace := currNamespace, openDecls := openDecls, ngen := ngen } =
{ env := env_1, cmdEnv? := cmdEnv?_1, fileMap := fileMap_1, mctx := mctx_1, options := options_1,
currNamespace := currNamespace_1, openDecls := openDecls_1, ngen := ngen_1 }) =
(env = env_1 ∧
cmdEnv? = cmdEnv?_1 ∧
fileMap = fileMap_1 ∧
mctx = mctx_1 ∧
options = options_1 ∧ currNamespace = currNamespace_1 ∧ openDecls = openDecls_1 ∧ ngen = ngen_1) |
PowerSeries.coeff_pow | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] (k n : ℕ) (φ : PowerSeries R),
(PowerSeries.coeff n) (φ ^ k) =
∑ l ∈ (Finset.range k).finsuppAntidiag n, ∏ i ∈ Finset.range k, (PowerSeries.coeff (l i)) φ |
fderivWithin_inter | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s t : Set E},
t ∈ nhds x → fderivWithin 𝕜 f (s ∩ t) x = fderivWithin 𝕜 f s x |
_private.Mathlib.Order.Category.BoolAlg.0.BoolAlg.Hom.mk.injEq | Mathlib.Order.Category.BoolAlg | ∀ {X Y : BoolAlg} (hom' hom'_1 : BoundedLatticeHom ↑X ↑Y), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) |
HahnModule.instIsTorsionFree | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {R : Type u_3} {Γ : Type u_6} {V : Type u_7} [inst : Ring R] [IsDomain R] [inst_2 : AddCommGroup V]
[inst_3 : AddCommMonoid Γ] [inst_4 : LinearOrder Γ] [inst_5 : IsOrderedCancelAddMonoid Γ] [inst_6 : Module R V]
[Module.IsTorsionFree R V], Module.IsTorsionFree (HahnSeries Γ R) (HahnModule Γ R V) |
_private.Mathlib.Geometry.Manifold.VectorBundle.Hom.0.ContMDiffWithinAt.clm_bundle_apply._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {M : Type u_5} {n : WithTop ℕ∞} {E₁ : B → Type u_6}
{E₂ : B → Type u_7} [inst : NontriviallyNormedField 𝕜] [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
[inst_5 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] [inst_6 : (x : B) → TopologicalSpace (E₁ x)]
[inst_7 : (x : B) → AddCommGroup (E₂ x)] [inst_8 : (x : B) → Module 𝕜 (E₂ x)] [inst_9 : NormedAddCommGroup F₂]
[inst_10 : NormedSpace 𝕜 F₂] [inst_11 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
[inst_12 : (x : B) → TopologicalSpace (E₂ x)] {EB : Type u_8} [inst_13 : NormedAddCommGroup EB]
[inst_14 : NormedSpace 𝕜 EB] {HB : Type u_9} [inst_15 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB}
[inst_16 : TopologicalSpace B] [inst_17 : ChartedSpace HB B] {EM : Type u_10} [inst_18 : NormedAddCommGroup EM]
[inst_19 : NormedSpace 𝕜 EM] {HM : Type u_11} [inst_20 : TopologicalSpace HM] {IM : ModelWithCorners 𝕜 EM HM}
[inst_21 : TopologicalSpace M] [inst_22 : ChartedSpace HM M] [inst_23 : FiberBundle F₁ E₁]
[inst_24 : VectorBundle 𝕜 F₁ E₁] [inst_25 : FiberBundle F₂ E₂] [inst_26 : VectorBundle 𝕜 F₂ E₂]
[inst_27 : ∀ (x : B), IsTopologicalAddGroup (E₂ x)] [inst_28 : ∀ (x : B), ContinuousSMul 𝕜 (E₂ x)]
(f : M → Bundle.TotalSpace (F₁ →L[𝕜] F₂) fun b => E₁ b →L[𝕜] E₂ b) {s : Set M} {x₀ : M},
ContMDiffWithinAt IM (IB.prod (modelWithCornersSelf 𝕜 (F₁ →L[𝕜] F₂))) n f s x₀ =
(ContMDiffWithinAt IM IB n (fun x => (f x).proj) s x₀ ∧
ContMDiffWithinAt IM (modelWithCornersSelf 𝕜 (F₁ →L[𝕜] F₂)) n
(fun x => ContinuousLinearMap.inCoordinates F₁ E₁ F₂ E₂ ⋯ ⋯ ⋯ ⋯ ⋯) s x₀) |
Std.ExtHashSet.contains_of_contains_insert' | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k a : α}, (m.insert k).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true |
AddCommGrpCat.epi_iff_range_eq_top | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : AddCommGrpCat} (f : A ⟶ B), CategoryTheory.Epi f ↔ (AddCommGrpCat.Hom.hom f).range = ⊤ |
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.archimedean_iff_nat_le.match_1_1 | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] (x : K) (motive : (∃ n, x ≤ ↑n) → Prop) (x_1 : ∃ n, x ≤ ↑n),
(∀ (n : ℕ) (h : x ≤ ↑n), motive ⋯) → motive x_1 |
Lean.Elab.Visibility.private.elim | Lean.Elab.DeclModifiers | {motive : Lean.Elab.Visibility → Sort u} →
(t : Lean.Elab.Visibility) → t.ctorIdx = 1 → motive Lean.Elab.Visibility.private → motive t |
Finset.Icc_ofDual | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (a b : αᵒᵈ),
Finset.Icc (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Icc b a) |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable.0.EisensteinSeries.div_max_sq_ge_one._simp_1_4 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True |
DoubleCoset.eq_of_not_disjoint | Mathlib.GroupTheory.DoubleCoset | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {a b : G},
¬Disjoint (DoubleCoset.doubleCoset a ↑H ↑K) (DoubleCoset.doubleCoset b ↑H ↑K) →
DoubleCoset.doubleCoset a ↑H ↑K = DoubleCoset.doubleCoset b ↑H ↑K |
Mathlib.Tactic.Bicategory.naturality_inv | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {p : a ⟶ b} {f g : b ⟶ c} {pf : a ⟶ c} {η : f ≅ g}
(η_f : CategoryTheory.CategoryStruct.comp p f ≅ pf) (η_g : CategoryTheory.CategoryStruct.comp p g ≅ pf),
CategoryTheory.Bicategory.whiskerLeftIso p η ≪≫ η_g = η_f →
CategoryTheory.Bicategory.whiskerLeftIso p η.symm ≪≫ η_f = η_g |
ISize.div_self | Init.Data.SInt.Lemmas | ∀ {a : ISize}, a / a = if a = 0 then 0 else 1 |
Affine.Simplex.altitudeFoot_mem_affineSpan_image_compl | Mathlib.Geometry.Euclidean.Altitude | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.altitudeFoot i ∈ affineSpan ℝ (s.points '' {i}ᶜ) |
One.toOfNat1.hcongr_2 | Mathlib.GroupTheory.CoprodI | ∀ (α α' : Type u_1), α = α' → ∀ (inst : One α) (inst' : One α'), inst ≍ inst' → One.toOfNat1 ≍ One.toOfNat1 |
CategoryTheory.RetractArrow.left_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.left.i = h.i.left |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Search.0.Lean.Meta.Grind.Arith.Cutsat.CooperSplit.assert.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | (motive : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u_1) →
(c₃? : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
((c₃ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive (some c₃)) →
((x : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive x) → motive c₃? |
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_1))
(s : ↑I.multicospan.sections),
(fun s =>
⟨fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
| CategoryTheory.Limits.WalkingMulticospan.right j => I.fst j (s.val (J.fst j)),
⋯⟩)
((fun s => { val := fun i => ↑s (CategoryTheory.Limits.WalkingMulticospan.left i), property := ⋯ }) s) =
s |
Std.ExtTreeSet.self_le_max?_insert | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k kmi : α},
(t.insert k).max?.get ⋯ = kmi → (cmp k kmi).isLE = true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.exists_eq_some_of_findSome?_eq_some._proof_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {x : α} {f : Fin n → Option α}, Fin.findSome? f = some x → ∃ i, f i = some x |
DirectSum.Decomposition.casesOn | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid M] →
[inst_2 : SetLike σ M] →
[inst_3 : AddSubmonoidClass σ M] →
{ℳ : ι → σ} →
{motive : DirectSum.Decomposition ℳ → Sort u} →
(t : DirectSum.Decomposition ℳ) →
((decompose' : M → DirectSum ι fun i => ↥(ℳ i)) →
(left_inv : Function.LeftInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose') →
(right_inv : Function.RightInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose') →
motive { decompose' := decompose', left_inv := left_inv, right_inv := right_inv }) →
motive t |
_private.Init.Data.String.Basic.0.String.Slice.Pos.ofSliceFrom_le_ofSliceFrom_iff._simp_1_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) |
Lean.Expr.ensureHasNoMVars | Mathlib.Lean.Expr.Basic | Lean.Expr → Lean.MetaM Unit |
Std.DTreeMap.Internal.Impl.Const.entryAtIdx?.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} (x : Std.DTreeMap.Internal.Impl α fun x => β) (x_1 : ℕ),
Std.DTreeMap.Internal.Impl.Const.entryAtIdx? x x_1 =
match x, x_1 with
| Std.DTreeMap.Internal.Impl.leaf, x => none
| Std.DTreeMap.Internal.Impl.inner size k v l r, n =>
match compare n l.size with
| Ordering.lt => Std.DTreeMap.Internal.Impl.Const.entryAtIdx? l n
| Ordering.eq => some (k, v)
| Ordering.gt => Std.DTreeMap.Internal.Impl.Const.entryAtIdx? r (n - l.size - 1) |
Mathlib.Tactic.BicategoryLike.StructuralAtom.id.elim | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.StructuralAtom → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
t.ctorIdx = 3 →
((e : Lean.Expr) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.id e f)) →
motive t |
UInt8._sizeOf_inst | Init.SizeOf | SizeOf UInt8 |
Int.reduceNeg._regBuiltin.Int.reduceNeg.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.2123988823._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffOn_iff_target._simp_1_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {s : Set M}
{n : WithTop ℕ∞} [IsManifold I n M] [IsManifold I' n M'],
ContMDiffOn I I' n f s =
(ContinuousOn f s ∧
∀ (x : M) (y : M'),
ContDiffOn 𝕜 n (↑(extChartAt I' y) ∘ f ∘ ↑(extChartAt I x).symm)
((extChartAt I x).target ∩ ↑(extChartAt I x).symm ⁻¹' (s ∩ f ⁻¹' (extChartAt I' y).source))) |
_private.Mathlib.Data.Set.Finite.Basic.0.Finset.exists.match_1_3 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {p : Finset α → Prop} (motive : (∃ s, ∃ (hs : s.Finite), p hs.toFinset) → Prop)
(x : ∃ s, ∃ (hs : s.Finite), p hs.toFinset),
(∀ (s : Set α) (hs : s.Finite) (hs' : p hs.toFinset), motive ⋯) → motive x |
UnitAddTorus.mFourierLp._proof_7 | Mathlib.Analysis.Fourier.AddCircleMulti | ∀ {d : Type u_1}, CompactSpace (d → UnitAddCircle) |
IsAbsoluteValue.abv_nonneg | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R] (abv : R → S)
[IsAbsoluteValue abv] (x : R), 0 ≤ abv x |
EReal.coe_ennreal_le_coe_ennreal_iff._simp_1 | Mathlib.Data.EReal.Basic | ∀ {x y : ENNReal}, (↑x ≤ ↑y) = (x ≤ y) |
CategoryTheory.nerveFunctor.full | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | CategoryTheory.nerveFunctor.Full |
CategoryTheory.Presieve.BindStruct.hg | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Presieve X}
{R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y} {Z : C} {h : Z ⟶ X} (self : S.BindStruct R h),
R ⋯ self.g |
Pi.comul_coe_finsupp | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M : Type u_4}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : CoalgebraStruct R M] (x : n →₀ M),
CoalgebraStruct.comul ⇑x = (TensorProduct.map Finsupp.lcoeFun Finsupp.lcoeFun) (CoalgebraStruct.comul x) |
ModuleCat.monModuleEquivalenceAlgebraForget._proof_5 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : CategoryTheory.Mon (ModuleCat R)) (x : R)
(x_1 : ↑(ModuleCat.MonModuleEquivalenceAlgebra.functor.obj A)), id (x • x_1) = id (x • x_1) |
CategoryTheory.Limits.prod.mapIso_hom | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
(f : W ≅ Y) (g : X ≅ Z), (CategoryTheory.Limits.prod.mapIso f g).hom = CategoryTheory.Limits.prod.map f.hom g.hom |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.