name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
SaturatedAddSubmonoid._sizeOf_1 | Mathlib.Algebra.Group.Submonoid.Saturation | {M : Type u_1} → {inst : AddZeroClass M} → [SizeOf M] → SaturatedAddSubmonoid M → ℕ |
FirstOrder.Language.Term.restrictVar | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} → {β : Type v'} → [inst : DecidableEq α] → (t : L.Term α) → (↥t.varFinset → β) → L.Term β |
ENNReal.nnreal_smul_lt_top_iff | Mathlib.Data.ENNReal.Action | ∀ {x : NNReal} {y : ENNReal}, x ≠ 0 → (x • y < ⊤ ↔ y < ⊤) |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getFolder | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.Name → Lean.CoreM Lean.Compiler.LCNF.Simp.ConstantFold.Folder |
SmoothBumpCovering.mk.inj | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} {inst : NormedAddCommGroup E} {inst_1 : NormedSpace ℝ E} {H : Type uH}
{inst_2 : TopologicalSpace H} {I : ModelWithCorners ℝ E H} {M : Type uM} {inst_3 : TopologicalSpace M}
{inst_4 : ChartedSpace H M} {inst_5 : FiniteDimensional ℝ E} {s : Set M} {c : ι → M}
{toFun : (i : ι) → SmoothBumpFunction I (c i)} {c_mem' : ∀ (i : ι), c i ∈ s}
{locallyFinite' : LocallyFinite fun i => Function.support ↑(toFun i)}
{eventuallyEq_one' : ∀ x ∈ s, ∃ i, ↑(toFun i) =ᶠ[nhds x] 1} {c_1 : ι → M}
{toFun_1 : (i : ι) → SmoothBumpFunction I (c_1 i)} {c_mem'_1 : ∀ (i : ι), c_1 i ∈ s}
{locallyFinite'_1 : LocallyFinite fun i => Function.support ↑(toFun_1 i)}
{eventuallyEq_one'_1 : ∀ x ∈ s, ∃ i, ↑(toFun_1 i) =ᶠ[nhds x] 1},
{ c := c, toFun := toFun, c_mem' := c_mem', locallyFinite' := locallyFinite',
eventuallyEq_one' := eventuallyEq_one' } =
{ c := c_1, toFun := toFun_1, c_mem' := c_mem'_1, locallyFinite' := locallyFinite'_1,
eventuallyEq_one' := eventuallyEq_one'_1 } →
c = c_1 ∧ toFun ≍ toFun_1 |
CategoryTheory.ObjectProperty.fullSubcategoryCongr_functor | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P P' : CategoryTheory.ObjectProperty C} (h : P = P'),
(CategoryTheory.ObjectProperty.fullSubcategoryCongr h).functor = CategoryTheory.ObjectProperty.ιOfLE ⋯ |
Filter.comap_embedding_atBot | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : Preorder γ] {e : β → γ},
(∀ (b₁ b₂ : β), e b₁ ≤ e b₂ ↔ b₁ ≤ b₂) → (∀ (c : γ), ∃ b, e b ≤ c) → Filter.comap e Filter.atBot = Filter.atBot |
Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.ConfigOptions.583794373._hygCtx._hyg.4 | Lean.Compiler.LCNF.ConfigOptions | IO (Lean.Option Bool) |
LieSubmodule.instAddCommMonoid._proof_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : LieSubmodule R L M), nsmulRec 0 x = 0 |
LocalizedModule.liftOn._proof_2 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_1} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] {α : Type u_3} (f : M × ↥S → α),
(∀ (p p' : M × ↥S), p ≈ p' → f p = f p') → ∀ (a b : M × ↥S), a ≈ b → f a = f b |
SemiNormedGrp.Hom.mk.injEq | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : SemiNormedGrp} (hom' hom'_1 : NormedAddGroupHom M.carrier N.carrier),
({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) |
CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_p₂ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
(S : J.Cover X) (x x_1 : S.Arrow) (r : x.Relation x_1), S.preOneHypercover.p₂ r = r.g₂ |
Std.ExtHashMap.getD_diff_of_mem_right | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β}, k ∈ m₂ → (m₁ \ m₂).getD k fallback = fallback |
OrderAddMonoidHom.coe_comp_orderHom | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : AddZeroClass α] [inst_4 : AddZeroClass β] [inst_5 : AddZeroClass γ] (f : β →+o γ) (g : α →+o β),
↑(f.comp g) = (↑f).comp ↑g |
CategoryTheory.CostructuredArrow.homMk'_id._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {T : D} {S : CategoryTheory.Functor C D}
(f : CategoryTheory.CostructuredArrow S T),
CategoryTheory.CostructuredArrow.mk
(CategoryTheory.CategoryStruct.comp (S.map (CategoryTheory.CategoryStruct.id f.left)) f.hom) =
f |
Set.pairwise_iUnion₂_iff | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set (Set α)},
DirectedOn (fun x1 x2 => x1 ⊆ x2) s → ((⋃ a ∈ s, a).Pairwise r ↔ ∀ a ∈ s, a.Pairwise r) |
_private.Lean.Server.AsyncList.0.IO.AsyncList.getFinishedPrefix.match_5 | Lean.Server.AsyncList | {ε α : Type} →
(motive : IO.AsyncList ε α → Sort u_1) →
(x : IO.AsyncList ε α) →
((hd : α) → (tl : IO.AsyncList ε α) → motive (IO.AsyncList.cons hd tl)) →
(Unit → motive IO.AsyncList.nil) →
((tl : Lean.Server.ServerTask (Except ε (IO.AsyncList ε α))) → motive (IO.AsyncList.delayed tl)) → motive x |
Lean.Meta.forallMetaTelescopeReducingUntilDefEq | Mathlib.Lean.Meta.Basic | Lean.Expr →
Lean.Expr →
optParam Lean.MetavarKind Lean.MetavarKind.natural →
Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) |
CategoryTheory.CommSq.mk._flat_ctor | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
{i : Y ⟶ Z},
autoParam (CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g i)
CategoryTheory.CommSq.w._autoParam →
CategoryTheory.CommSq f g h i |
_private.Mathlib.SetTheory.Cardinal.CountableCover.0.Cardinal.mk_subtype_le_of_countable_eventually_mem._simp_1_1 | Mathlib.SetTheory.Cardinal.CountableCover | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) |
surjective_of_isLocalized_span | Mathlib.RingTheory.LocalProperties.Exactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (s : Set R),
Ideal.span s = ⊤ →
∀ (Mₚ : ↑s → Type u_5) [inst_5 : (r : ↑s) → AddCommMonoid (Mₚ r)] [inst_6 : (r : ↑s) → Module R (Mₚ r)]
(f : (r : ↑s) → M →ₗ[R] Mₚ r) [inst_7 : ∀ (r : ↑s), IsLocalizedModule.Away (↑r) (f r)] (Nₚ : ↑s → Type u_6)
[inst_8 : (r : ↑s) → AddCommMonoid (Nₚ r)] [inst_9 : (r : ↑s) → Module R (Nₚ r)] (g : (r : ↑s) → N →ₗ[R] Nₚ r)
[inst_10 : ∀ (r : ↑s), IsLocalizedModule.Away (↑r) (g r)] (F : M →ₗ[R] N),
(∀ (r : ↑s), Function.Surjective ⇑((IsLocalizedModule.map (Submonoid.powers ↑r) (f r) (g r)) F)) →
Function.Surjective ⇑F |
CategoryTheory.IsCardinalFiltered.coeq_condition | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [hκ : Fact κ.IsRegular]
[inst_1 : CategoryTheory.IsCardinalFiltered J κ] {K : Type v'} {j j' : J} (f : K → (j ⟶ j')) (hK : HasCardinalLT K κ)
(k : K),
CategoryTheory.CategoryStruct.comp (f k) (CategoryTheory.IsCardinalFiltered.coeqHom f hK) =
CategoryTheory.IsCardinalFiltered.toCoeq f hK |
List.TProd.elim._proof_1 | Mathlib.Data.Prod.TProd | ∀ {ι : Type u_1} (i : ι) (is : List ι), ∀ j ∈ i :: is, ¬j = i → j ∈ is |
BooleanSubalgebra.instTopCoe | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → {L : BooleanSubalgebra α} → Top ↥L |
MeasureTheory.Measure.tprod | Mathlib.MeasureTheory.Constructions.Pi | {δ : Type u_4} →
{X : δ → Type u_5} →
[inst : (i : δ) → MeasurableSpace (X i)] →
(l : List δ) → ((i : δ) → MeasureTheory.Measure (X i)) → MeasureTheory.Measure (List.TProd X l) |
Polynomial.Chebyshev.C_add_two | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (R : Type u_1) [inst : CommRing R] (n : ℤ),
Polynomial.Chebyshev.C R (n + 2) = Polynomial.X * Polynomial.Chebyshev.C R (n + 1) - Polynomial.Chebyshev.C R n |
Lean.Import._sizeOf_1 | Lean.Setup | Lean.Import → ℕ |
CommGrpCat.id_apply | Mathlib.Algebra.Category.Grp.Basic | ∀ (X : CommGrpCat) (x : ↑X), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) x = x |
HasProd.mul_isCompl | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a b : α}
[ContinuousMul α] {s t : Set β},
IsCompl s t → HasProd (f ∘ Subtype.val) a → HasProd (f ∘ Subtype.val) b → HasProd f (a * b) |
Interval.«_aux_Mathlib_Order_Interval_Set_UnorderedInterval___macroRules_Interval_term[[_,_]]_1» | Mathlib.Order.Interval.Set.UnorderedInterval | Lean.Macro |
MonomialOrder.degree_smul_of_mem_nonZeroDivisors | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {r : R},
r ∈ nonZeroDivisors R → ∀ {f : MvPolynomial σ R}, m.degree (r • f) = m.degree f |
RatFunc.laurent_laurent | Mathlib.FieldTheory.Laurent | ∀ {R : Type u} [inst : CommRing R] (r s : R) (f : RatFunc R) [inst_1 : IsDomain R],
(RatFunc.laurent r) ((RatFunc.laurent s) f) = (RatFunc.laurent (r + s)) f |
MeasurableEquiv.mulLeft.congr_simp | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableMul G] (g g_1 : G),
g = g_1 → MeasurableEquiv.mulLeft g = MeasurableEquiv.mulLeft g_1 |
Filter.lift_lift_same_le_lift | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Set α → Filter β},
(f.lift fun s => f.lift (g s)) ≤ f.lift fun s => g s s |
BooleanSubalgebra.copy | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → (L : BooleanSubalgebra α) → (s : Set α) → s = ↑L → BooleanSubalgebra α |
FirstOrder.Language.partialOrderTheory.eq_1 | Mathlib.ModelTheory.Order | ∀ (L : FirstOrder.Language) [inst : L.IsOrdered],
L.partialOrderTheory = insert FirstOrder.Language.leSymb.antisymmetric L.preorderTheory |
_private.Mathlib.Order.Category.DistLat.0.DistLat.Hom.mk.inj | Mathlib.Order.Category.DistLat | ∀ {X Y : DistLat} {hom' hom'_1 : LatticeHom ↑X ↑Y}, { hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 |
CompactlySupportedContinuousMap.coeFnMonoidHom._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddMonoid β]
[inst_3 : ContinuousAdd β] (f g : CompactlySupportedContinuousMap α β), ⇑(f + g) = ⇑f + ⇑g |
IsIntegralClosure.equiv.congr_simp | Mathlib.Topology.Algebra.Valued.WithVal | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] (A' : Type u_4)
[inst_6 : CommRing A'] [inst_7 : Algebra A' B] [inst_8 : IsIntegralClosure A' R B] [inst_9 : Algebra R A]
[inst_10 : Algebra R A'] [inst_11 : IsScalarTower R A B] [inst_12 : IsScalarTower R A' B],
IsIntegralClosure.equiv R A B A' = IsIntegralClosure.equiv R A B A' |
Std.ExtDTreeMap.instDecidableMem | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} → [inst : Std.TransCmp cmp] → {m : Std.ExtDTreeMap α β cmp} → {a : α} → Decidable (a ∈ m) |
Std.DHashMap.Raw | Std.Data.DHashMap.RawDef | (α : Type u) → (α → Type v) → Type (max u v) |
Ideal.quotientEquiv._proof_6 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : Ring R] {S : Type u_2} [inst_1 : Ring S], RingHomClass (S →+* R) S R |
CategoryTheory.GlueData'.t''._proof_14 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (D : CategoryTheory.GlueData' C) (i : D.J), D.U i = D.U i |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.expMap_smul._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c |
Std.ExtTreeMap.getKey!_minKey! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α], t ≠ ∅ → t.getKey! t.minKey! = t.minKey! |
MeasureTheory.quasiMeasurePreserving_sub_left | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd₂ G] (μ : MeasureTheory.Measure G)
[MeasureTheory.SFinite μ] [MeasurableNeg G] [μ.IsAddLeftInvariant] (g : G),
MeasureTheory.Measure.QuasiMeasurePreserving (fun h => g - h) μ μ |
Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[inst : Std.TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF)
(h' : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.filterMap! f t) = true),
(f (t.getKey k ⋯) (Std.DTreeMap.Internal.Impl.Const.get t k ⋯)).isSome = true |
ProbabilityTheory.measure_condCDF_univ | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α),
(ProbabilityTheory.condCDF ρ a).measure Set.univ = 1 |
CategoryTheory.Limits.hasProducts_opposite | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasCoproducts C],
CategoryTheory.Limits.HasProducts Cᵒᵖ |
ProbabilityTheory.covarianceBilin_real | Mathlib.Probability.Moments.CovarianceBilin | ∀ {μ : MeasureTheory.Measure ℝ} [MeasureTheory.IsFiniteMeasure μ] (x y : ℝ),
((ProbabilityTheory.covarianceBilin μ) x) y = x * y * ProbabilityTheory.variance id μ |
Std.Roi.eq_succMany?_of_toList_eq_append_cons | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roi α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxi.IsAlwaysFinite α] {pref suff : List α} {cur : α} (h : r.toList = pref ++ cur :: suff),
cur = (Std.PRange.succMany? (pref.length + 1) r.lower).get ⋯ |
Mathlib.TacticAnalysis.ComplexConfig.test | Mathlib.Tactic.TacticAnalysis | (self : Mathlib.TacticAnalysis.ComplexConfig) →
Lean.Elab.ContextInfo → Lean.Elab.TacticInfo → self.ctx → Lean.MVarId → Lean.Elab.Command.CommandElabM self.out |
Metric.Snowflaking.preimage_toSnowflaking_eball | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoEMetricSpace X] (x : Metric.Snowflaking X α hα₀ hα₁)
(d : ENNReal),
⇑Metric.Snowflaking.toSnowflaking ⁻¹' Metric.eball x d = Metric.eball (Metric.Snowflaking.ofSnowflaking x) (d ^ α⁻¹) |
List.Shortlex.cons | Mathlib.Data.List.Shortlex | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Irrefl r] {a : α} {s t : List α},
List.Shortlex r s t → List.Shortlex r (a :: s) (a :: t) |
Min.casesOn | Init.Prelude | {α : Type u} → {motive : Min α → Sort u_1} → (t : Min α) → ((min : α → α → α) → motive { min := min }) → motive t |
CFC.neg_negPart_le | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : Module ℝ A] [inst_2 : SMulCommClass ℝ A A]
[inst_3 : IsScalarTower ℝ A A] [inst_4 : StarRing A] [inst_5 : TopologicalSpace A]
[inst_6 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_7 : PartialOrder A] [StarOrderedRing A]
{a : A}, autoParam (IsSelfAdjoint a) CFC.neg_negPart_le._auto_1 → -a⁻ ≤ a |
CategoryTheory.Equivalence.mapCommMon_inverse | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D] (e : C ≌ D)
[inst_6 : e.functor.Braided] [inst_7 : e.inverse.Braided] [inst_8 : e.IsMonoidal],
e.mapCommMon.inverse = e.inverse.mapCommMon |
Homeomorph.comp_isOpenMap_iff._simp_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (h : X ≃ₜ Y) {f : Z → X}, IsOpenMap (⇑h ∘ f) = IsOpenMap f |
CategoryTheory.Limits.walkingCospanOpEquiv_inverse_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ (X : CategoryTheory.Limits.WidePushoutShape CategoryTheory.Limits.WalkingPair),
CategoryTheory.Limits.walkingCospanOpEquiv.inverse.obj X = Opposite.op X |
CategoryTheory.IsSplitMono.casesOn | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.IsSplitMono f → Sort u} →
(t : CategoryTheory.IsSplitMono f) →
((exists_splitMono : Nonempty (CategoryTheory.SplitMono f)) → motive ⋯) → motive t |
MultilinearMap.domDomCongr_eq_iff._simp_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] {ι₁ : Type u_1} {ι₂ : Type u_2}
(σ : ι₁ ≃ ι₂) (f g : MultilinearMap R (fun x => M₂) M₃),
(MultilinearMap.domDomCongr σ f = MultilinearMap.domDomCongr σ g) = (f = g) |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_577 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
MeasureTheory.Measure.toOuterMeasure_top | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {x : MeasurableSpace α}, ⊤.toOuterMeasure = ⊤ |
_private.Mathlib.Analysis.ConstantSpeed.0.unique_unit_speed_on_Icc_zero._simp_1_1 | Mathlib.Analysis.ConstantSpeed | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) |
instIsLocalizationAlgebraMapSubmonoidPrimeComplLocalization | Mathlib.RingTheory.DedekindDomain.Instances | ∀ {R : Type u_1} (S : Type u_2) (T : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] {P : Ideal R} [inst_4 : P.IsPrime] [inst_5 : Algebra S T] [inst_6 : Algebra R T]
[IsScalarTower R S T],
IsLocalization (Algebra.algebraMapSubmonoid T (Algebra.algebraMapSubmonoid S P.primeCompl))
(Localization (Algebra.algebraMapSubmonoid T P.primeCompl)) |
List.zipWithM'._sunfold | Init.Data.List.Monadic | {m : Type u → Type v} →
[Monad m] → {α : Type w} → {β : Type x} → {γ : Type u} → (α → β → m γ) → List α → List β → m (List γ) |
_private.Lean.Meta.Eqns.0.Lean.Meta.mkSimpleEqThm.match_1 | Lean.Meta.Eqns | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((info : Lean.DefinitionVal) → motive (some (Lean.ConstantInfo.defnInfo info))) →
((x : Option Lean.ConstantInfo) → motive x) → motive x |
Function.smulCommClass | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} {α : Type u_7} [inst : SMul M α] [inst_1 : SMul N α]
[SMulCommClass M N α], SMulCommClass M N (ι → α) |
CategoryTheory.LiftableCone.validLift | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
{c : CategoryTheory.Limits.Cone (K.comp F)} →
(self : CategoryTheory.LiftableCone K F c) → F.mapCone self.liftedCone ≅ c |
FiniteGaloisIntermediateField.finGaloisGroup._proof_2 | Mathlib.FieldTheory.Galois.Profinite | ∀ {k : Type u_2} {K : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(L : FiniteGaloisIntermediateField k K), Finite Gal(↥L.toIntermediateField/k) |
Mathlib.Tactic.LibrarySearch.observe | Mathlib.Tactic.Observe | Lean.ParserDescr |
List.flatten._sunfold | Init.Prelude | {α : Type u_1} → List (List α) → List α |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.D₃.congr_simp | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular]
(D D_1 : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal J κ),
D = D_1 →
∀ (m₁ m₁_1 : J),
m₁ = m₁_1 →
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.D₃ D m₁ =
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.D₃ D_1 m₁_1 |
continuousAt_codRestrict_iff | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {t : Set Y}
(h1 : ∀ (x : X), f x ∈ t) {x : X}, ContinuousAt (Set.codRestrict f t h1) x ↔ ContinuousAt f x |
_private.Mathlib.Data.Set.Insert.0.HasSubset.Subset.ssubset_of_mem_notMem._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s t : Set α} {a : α}, s ⊆ t → a ∈ t → a ∉ s → s ⊂ t |
SetRel.IsSeparated.empty | Mathlib.Data.Rel.Separated | ∀ {X : Type u_1} {R : SetRel X X}, R.IsSeparated ∅ |
Matrix.isRepresentation.toEnd._proof_8 | Mathlib.LinearAlgebra.Matrix.Charpoly.LinearMap | ∀ {ι : Type u_1} [inst : Fintype ι] {M : Type u_3} [inst_1 : AddCommGroup M] (R : Type u_2) [inst_2 : CommRing R]
[inst_3 : Module R M] (b : ι → M) [inst_4 : DecidableEq ι], ↑0 ∈ Matrix.isRepresentation R b |
Finset.Ioc_subset_Ioc_left | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a₁ a₂ b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α],
a₁ ≤ a₂ → Finset.Ioc a₂ b ⊆ Finset.Ioc a₁ b |
CategoryTheory.CoreSmallCategoryOfSet.homEquiv | Mathlib.CategoryTheory.SmallRepresentatives | {Ω : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(self : CategoryTheory.CoreSmallCategoryOfSet Ω C) →
{X Y : ↑self.obj} → ↑(self.hom X Y) ≃ (self.objEquiv X ⟶ self.objEquiv Y) |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.substVar.match_4 | Lean.Meta.Tactic.Subst | (motive : Option (Lean.FVarId × Bool) → Sort u_1) →
(__discr : Option (Lean.FVarId × Bool)) →
((fvarId : Lean.FVarId) → (symm : Bool) → motive (some (fvarId, symm))) →
((x : Option (Lean.FVarId × Bool)) → motive x) → motive __discr |
DistribMulActionHom.mk.congr_simp | Mathlib.Algebra.Algebra.Unitization | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : DistribMulAction M A] {B : Type u_5} [inst_4 : AddMonoid B] [inst_5 : DistribMulAction N B]
(toMulActionHom toMulActionHom_1 : A →ₑ[⇑φ] B) (e_toMulActionHom : toMulActionHom = toMulActionHom_1)
(map_zero' : toMulActionHom.toFun 0 = 0)
(map_add' : ∀ (x y : A), toMulActionHom.toFun (x + y) = toMulActionHom.toFun x + toMulActionHom.toFun y),
{ toMulActionHom := toMulActionHom, map_zero' := map_zero', map_add' := map_add' } =
{ toMulActionHom := toMulActionHom_1, map_zero' := ⋯, map_add' := ⋯ } |
SubAddAction.closure | Mathlib.GroupTheory.GroupAction.SubMulAction.Closure | (R : Type u_1) → {M : Type u_2} → [inst : VAdd R M] → Set M → SubAddAction R M |
CategoryTheory.Functor.IsStronglyCartesian.domainIsoOfBaseIso._proof_5 | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u_4} {𝒳 : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} 𝒮]
[inst_1 : CategoryTheory.Category.{u_1, u_2} 𝒳] (p : CategoryTheory.Functor 𝒳 𝒮) {R R' S : 𝒮} {a a' b : 𝒳} {f : R ⟶ S}
{f' : R' ⟶ S} {g : R' ≅ R} (h : f' = CategoryTheory.CategoryStruct.comp g.hom f) (φ : a ⟶ b) (φ' : a' ⟶ b)
[inst_2 : p.IsStronglyCartesian f φ] [inst_3 : p.IsStronglyCartesian f' φ'],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.IsStronglyCartesian.map p f' φ' ⋯ φ)
(CategoryTheory.Functor.IsStronglyCartesian.map p f φ h φ') =
CategoryTheory.CategoryStruct.id a |
CategoryTheory.MorphismProperty.DescendsAlong.recOn | Mathlib.CategoryTheory.MorphismProperty.Descent | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P Q : CategoryTheory.MorphismProperty C} →
{motive : P.DescendsAlong Q → Sort u} →
(t : P.DescendsAlong Q) →
((of_isPullback :
∀ {A X Y Z : C} {fst : A ⟶ X} {snd : A ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z},
CategoryTheory.IsPullback fst snd f g → Q f → P fst → P g) →
motive ⋯) →
motive t |
CategoryTheory.Functor.whiskerRight_comp | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {G H K : CategoryTheory.Functor C D} (α : G ⟶ H)
(β : H ⟶ K) (F : CategoryTheory.Functor D E),
CategoryTheory.Functor.whiskerRight (CategoryTheory.CategoryStruct.comp α β) F =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight α F)
(CategoryTheory.Functor.whiskerRight β F) |
CategoryTheory.Grp.instMonObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {H : CategoryTheory.Grp C} [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Grp.homMk CategoryTheory.MonObj.one.hom) H)
(CategoryTheory.Grp.homMk CategoryTheory.MonObj.mul.hom) =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor H).hom |
Subgroup.instSMul | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | {G : Type u_2} → [inst : Group G] → (H : Subgroup G) → SMul (↥H.op) G |
LaurentPolynomial.C_apply | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (t : R) (n : ℤ), (LaurentPolynomial.C t) n = if n = 0 then t else 0 |
CategoryTheory.Functor.hom_ext_of_isLeftKanExtension | 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]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : F ⟶ L.comp F') [F'.IsLeftKanExtension α] {G : CategoryTheory.Functor D H} (γ₁ γ₂ : F' ⟶ G),
CategoryTheory.CategoryStruct.comp α (L.whiskerLeft γ₁) = CategoryTheory.CategoryStruct.comp α (L.whiskerLeft γ₂) →
γ₁ = γ₂ |
Bundle.Trivialization.preimageSingletonHomeomorph_symm_apply | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) {b : B} (hb : b ∈ e.baseSet) (p : F),
(e.preimageSingletonHomeomorph hb).symm p = ⟨↑e.symm (b, p), ⋯⟩ |
Std.ExtTreeSet.forM_eq_forM_toList | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} {m : Type w → Type w'} [inst : Std.TransCmp cmp]
[inst_1 : Monad m] [inst_2 : LawfulMonad m] {f : α → m PUnit.{w + 1}}, forM t f = t.toList.forM f |
Lean.Elab.ExpandDeclIdResult._sizeOf_inst | Lean.Elab.DeclModifiers | SizeOf Lean.Elab.ExpandDeclIdResult |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.isConstantApplication.aux.match_1 | Mathlib.Lean.Expr.Basic | (motive : Lean.Expr → ℕ → Sort u_1) →
(x : Lean.Expr) →
(x_1 : ℕ) →
((binderName : Lean.Name) →
(binderType b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
(n : ℕ) → motive (Lean.Expr.lam binderName binderType b binderInfo) n.succ) →
((e : Lean.Expr) → motive e 0) → ((x : Lean.Expr) → (x_2 : ℕ) → motive x x_2) → motive x x_1 |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.initAndRunWatchdogAux._sparseCasesOn_1 | Lean.Server.Watchdog | {motive : Lean.JsonRpc.Message → Sort u} →
(t : Lean.JsonRpc.Message) →
((method : String) →
(params? : Option Lean.Json.Structured) → motive (Lean.JsonRpc.Message.notification method params?)) →
((id : Lean.JsonRpc.RequestID) →
(method : String) →
(params? : Option Lean.Json.Structured) → motive (Lean.JsonRpc.Message.request id method params?)) →
(Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t |
Nat.toInt32 | Init.Data.SInt.Basic | ℕ → Int32 |
Std.Time.DateTime.ofPlainDateTime | Std.Time.Zoned.DateTime | Std.Time.PlainDateTime → (tz : Std.Time.TimeZone) → Std.Time.DateTime tz |
CommRingCat.Colimits.descMorphism._proof_4 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(s : CategoryTheory.Limits.Cocone F), CommRingCat.Colimits.descFun F s 0 = CommRingCat.Colimits.descFun F s 0 |
Finset.sum_sum_Ioi_add_eq_sum_sum_off_diag | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : LinearOrder α] [inst_2 : Fintype α]
[inst_3 : LocallyFiniteOrderTop α] [LocallyFiniteOrderBot α] (f : α → α → M),
∑ i, ∑ j ∈ Finset.Ioi i, (f j i + f i j) = ∑ i, ∑ j ∈ {i}ᶜ, f j i |
Filter.Germ.liftPred_const_iff._simp_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [l.NeBot] {p : β → Prop} {x : β}, Filter.Germ.LiftPred p ↑x = p x |
Set.seq.eq_1 | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u} {β : Type v} (s : Set (α → β)) (t : Set α), s.seq t = Set.image2 (fun f => f) s t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.