name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
IsRightUniformGroup.toIsTopologicalGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {G : Type u_7} {inst : UniformSpace G} {inst_1 : Group G} [self : IsRightUniformGroup G], IsTopologicalGroup G |
Std.DTreeMap.Internal.Impl.Const.get!_insertManyIfNewUnit_empty_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {l : List α} {k : α},
Std.DTreeMap.Internal.Impl.Const.get!
(↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit Std.DTreeMap.Internal.Impl.empty l ⋯)) k =
() |
Lean.Meta.LazyDiscrTree.Cache.rec | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.Cache → Sort u} →
((ngen : Lean.NameGenerator) →
(core : Lean.Core.Cache) → («meta» : Lean.Meta.Cache) → motive { ngen := ngen, core := core, «meta» := «meta» }) →
(t : Lean.Meta.LazyDiscrTree.Cache) → motive t |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.foldlM.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(x : δ) (a : α) (b : β a) (es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldlM f x (Std.DHashMap.Internal.AssocList.cons a b es) = do
let d ← f x a b
Std.DHashMap.Internal.AssocList.foldlM f d es |
Finsupp.some_zero | Mathlib.Data.Finsupp.Option | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M], Finsupp.some 0 = 0 |
CategoryTheory.Pi.ext | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type w₀} (C : I → Type u₁) [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i}
{f g : X ⟶ Y}, (∀ (i : I), f i = g i) → f = g |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.empty_isBase_iff._simp_1_4 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M₁ M₂ : Matroid α}, (M₁ = M₂) = (M₁.E = M₂.E ∧ ∀ ⦃I : Set α⦄, I ⊆ M₁.E → (M₁.Indep I ↔ M₂.Indep I)) |
chart_mem_atlas | Mathlib.Geometry.Manifold.ChartedSpace | ∀ (H : Type u_5) {M : Type u_6} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(x : M), chartAt H x ∈ atlas H M |
Lean.Meta.SparseCasesOnInfo.recOn | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnInfo → Sort u} →
(t : Lean.Meta.SparseCasesOnInfo) →
((indName : Lean.Name) →
(majorPos arity : ℕ) →
(insterestingCtors : Array Lean.Name) →
motive
{ indName := indName, majorPos := majorPos, arity := arity, insterestingCtors := insterestingCtors }) →
motive t |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabFunValues.match_5 | Lean.Elab.MutualDef | (motive : Option (Lean.Language.SnapshotBundle (Option Lean.Elab.BodyProcessedSnapshot)) → Sort u_1) →
(x : Option (Lean.Language.SnapshotBundle (Option Lean.Elab.BodyProcessedSnapshot))) →
((snap : Lean.Language.SnapshotBundle (Option Lean.Elab.BodyProcessedSnapshot)) → motive (some snap)) →
((x : Option (Lean.Language.SnapshotBundle (Option Lean.Elab.BodyProcessedSnapshot))) → motive x) → motive x |
AddCommGroup.nsmul_add_modEq | Mathlib.Algebra.Group.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoid M] {a p : M} (n : ℕ), n • p + a ≡ a [PMOD p] |
Mathlib.Tactic.Widget.StringDiagram.Node.recOn | Mathlib.Tactic.Widget.StringDiagram | {motive : Mathlib.Tactic.Widget.StringDiagram.Node → Sort u} →
(t : Mathlib.Tactic.Widget.StringDiagram.Node) →
((a : Mathlib.Tactic.Widget.StringDiagram.AtomNode) → motive (Mathlib.Tactic.Widget.StringDiagram.Node.atom a)) →
((a : Mathlib.Tactic.Widget.StringDiagram.IdNode) → motive (Mathlib.Tactic.Widget.StringDiagram.Node.id a)) →
motive t |
SimpleGraph.Hom.toCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {α : Type u_4} →
{β : Type u_5} → {A : SimpleGraph α} → {B : SimpleGraph β} → (f : A →g B) → Function.Injective ⇑f → A.Copy B |
List.forIn'_pure_yield_eq_foldl | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {l : List α}
(f : (a : α) → a ∈ l → β → β) (init : β),
(forIn' l init fun a m_1 b => pure (ForInStep.yield (f a m_1 b))) =
pure
(List.foldl
(fun b x =>
match x with
| ⟨a, h⟩ => f a h b)
init l.attach) |
_private.Mathlib.Data.Finset.SMulAntidiagonal.0.Finset.support_vaddAntidiagonal_subset_vadd.match_1_1 | Mathlib.Data.Finset.SMulAntidiagonal | ∀ {G : Type u_2} {P : Type u_1} [inst : PartialOrder G] [inst_1 : PartialOrder P] [inst_2 : VAdd G P]
[inst_3 : IsOrderedCancelVAdd G P] {s : Set G} {t : Set P} {hs : s.IsPWO} {ht : t.IsPWO} (a : P)
(motive : a ∈ {a | (Finset.VAddAntidiagonal hs ht a).Nonempty} → Prop)
(x : a ∈ {a | (Finset.VAddAntidiagonal hs ht a).Nonempty}),
(∀ (b : G × P) (hb : b ∈ Finset.VAddAntidiagonal hs ht a), motive ⋯) → motive x |
LieSubalgebra.mem_normalizer_iff' | Mathlib.Algebra.Lie.Normalizer | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) (x : L), x ∈ H.normalizer ↔ ∀ y ∈ H, ⁅y, x⁆ ∈ H |
Cardinal.mk_univ_real | Mathlib.Analysis.Real.Cardinality | Cardinal.mk ↑Set.univ = Cardinal.continuum |
Lean.Grind.CommRing.Expr._sizeOf_inst | Init.Grind.Ring.CommSolver | SizeOf Lean.Grind.CommRing.Expr |
LieRinehartAlgebra | Mathlib.Algebra.LieRinehartAlgebra.Defs | (R : Type u_1) →
(A : Type u_2) →
(L : Type u_3) →
[inst : CommRing A] →
[inst_1 : LieRing L] →
[inst_2 : Module A L] →
[inst_3 : LieRingModule L A] →
[LieRinehartRing A L] → [inst_5 : CommRing R] → [Algebra R A] → [LieAlgebra R L] → Prop |
Aesop.FVarIdSubst.ctorIdx | Aesop.RuleTac.FVarIdSubst | Aesop.FVarIdSubst → ℕ |
MeasureTheory.average | Mathlib.MeasureTheory.Integral.Average | {α : Type u_1} →
{E : Type u_2} →
{m0 : MeasurableSpace α} → [inst : NormedAddCommGroup E] → [NormedSpace ℝ E] → MeasureTheory.Measure α → (α → E) → E |
MvPowerSeries.X_dvd_iff | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {s : σ} {φ : MvPowerSeries σ R},
MvPowerSeries.X s ∣ φ ↔ ∀ (m : σ →₀ ℕ), m s = 0 → (MvPowerSeries.coeff m) φ = 0 |
intervalIntegral.integral_hasDerivAt_of_tendsto_ae_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {c : E}
{a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
Filter.Tendsto f (nhds b ⊓ MeasureTheory.ae MeasureTheory.volume) (nhds c) →
HasDerivAt (fun u => ∫ (x : ℝ) in a..u, f x) c b |
_private.Mathlib.RingTheory.WittVector.WittPolynomial.0.xInTermsOfW_vars_aux._proof_1_3 | Mathlib.RingTheory.WittVector.WittPolynomial | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], NeZero p |
LinearMap.range_eq_top_of_surjective | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂), Function.Surjective ⇑f → f.range = ⊤ |
_private.Lean.Data.PersistentArray.0.Lean.PersistentArray.foldlMAux.match_1 | Lean.Data.PersistentArray | {α : Type u_1} →
{β : Type u_3} →
(motive : Lean.PersistentArrayNode α → β → Sort u_2) →
(x : Lean.PersistentArrayNode α) →
(x_1 : β) →
((cs : Array (Lean.PersistentArrayNode α)) → (b : β) → motive (Lean.PersistentArrayNode.node cs) b) →
((vs : Array α) → (b : β) → motive (Lean.PersistentArrayNode.leaf vs) b) → motive x x_1 |
AnalyticAt.fun_pow | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {A : Type u_7} [inst_3 : NormedRing A] [inst_4 : NormedAlgebra 𝕜 A] {f : E → A} {z : E},
AnalyticAt 𝕜 f z → ∀ (n : ℕ), AnalyticAt 𝕜 (fun i => f i ^ n) z |
RootPairing.flipEquiv._proof_1 | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ (ι : Type u_1) (R : Type u_2) (M : Type u_3) (N : Type u_4) [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N],
Function.LeftInverse (fun P => P.flip) fun P => P.flip |
Affine.Simplex.sum_excenterWeights | Mathlib.Geometry.Euclidean.Incenter | ∀ {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) (signs : Finset (Fin (n + 1)))
[inst_5 : Decidable (s.ExcenterExists signs)],
∑ i, s.excenterWeights signs i = if s.ExcenterExists signs then 1 else 0 |
IsBaseChange.directSumPow | Mathlib.RingTheory.TensorProduct.IsBaseChangePi | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (ι : Type u_3)
{M : Type u_6} {M' : Type u_7} [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid M'] [inst_5 : Module R M]
[inst_6 : Module R M'] [inst_7 : Module S M'] [inst_8 : IsScalarTower R S M'] {ε : M →ₗ[R] M'},
IsBaseChange S ε → IsBaseChange S (DirectSum.lmap fun x => ε) |
RingCon.instRingQuotient._proof_8 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Ring R] (c : RingCon R) (x : ℤ) (x_1 : R), Quotient.mk'' (x • x_1) = Quotient.mk'' (x • x_1) |
ProbabilityTheory.condIndepFun_iff_condExp_inter_preimage_eq_mul | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{hm' : m' ≤ mΩ} {μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'},
Measurable f →
Measurable g →
(ProbabilityTheory.CondIndepFun m' hm' f g μ ↔
∀ (s : Set β) (t : Set β'),
MeasurableSet s →
MeasurableSet t →
μ[(f ⁻¹' s ∩ g ⁻¹' t).indicator fun ω => 1 | m'] =ᵐ[μ] fun ω =>
μ[(f ⁻¹' s).indicator fun ω => 1 | m'] ω * μ[(g ⁻¹' t).indicator fun ω => 1 | m'] ω) |
CategoryTheory.Bimon.instBimonObjXXMon | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → (M : CategoryTheory.Bimon C) → CategoryTheory.BimonObj M.X.X |
CommMonCat.units._proof_1 | Mathlib.Algebra.Category.Grp.Adjunctions | ∀ (x : CommMonCat),
CommGrpCat.ofHom (Units.map (CommMonCat.Hom.hom (CategoryTheory.CategoryStruct.id x))) =
CategoryTheory.CategoryStruct.id (CommGrpCat.of (↑x)ˣ) |
sub_one_mul_padicValNat_choose_eq_sub_sum_digits' | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p k n : ℕ} [hp : Fact (Nat.Prime p)],
(p - 1) * padicValNat p ((n + k).choose k) = (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum |
CategoryTheory.Endofunctor.Coalgebra.Hom.id._proof_2 | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor C C}
(V : CategoryTheory.Endofunctor.Coalgebra F),
CategoryTheory.CategoryStruct.comp V.str (F.map (CategoryTheory.CategoryStruct.id V.V)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id V.V) V.str |
_private.Mathlib.Topology.Constructions.SumProd.0.isOpenMap_inr._simp_1_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
IsOpen s = (IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s)) |
DiscreteQuotient.equivFinsetClopens | Mathlib.Topology.DiscreteQuotient | (X : Type u_2) →
[inst : TopologicalSpace X] →
[inst_1 : CompactSpace X] → DiscreteQuotient X ≃ ↑(Set.range (DiscreteQuotient.finsetClopens X)) |
ULiftable.up' | Mathlib.Control.ULiftable | {f : Type u₀ → Type u₁} → {g : Type v₀ → Type v₁} → [ULiftable f g] → f PUnit.{u₀ + 1} → g PUnit.{v₀ + 1} |
List.pmap_attach | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {p : { x // x ∈ l } → Prop} {f : (a : { x // x ∈ l }) → p a → β}
(H : ∀ a ∈ l.attach, p a), List.pmap f l.attach H = List.pmap (fun a h => f ⟨a, ⋯⟩ ⋯) l ⋯ |
Real.RingHom.unique | Mathlib.Data.Real.CompleteField | Unique (ℝ →+* ℝ) |
ContinuousCohomology.continuousCohomologyZeroIso._proof_3 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ (R : Type u_3) (G : Type u_1) [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] {X Y : Action (TopModuleCat R) G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((continuousCohomology R G 0).map f)
((fun X =>
(CategoryTheory.ShortComplex.HomologyData.ofIsLimitKernelFork
(HomologicalComplex.sc ((ContinuousCohomology.homogeneousCochains R G).obj X) 0) ⋯
(CategoryTheory.Limits.KernelFork.ofι
(TopModuleCat.kerι
(HomologicalComplex.sc ((ContinuousCohomology.homogeneousCochains R G).obj X) 0).g)
⋯)
(TopModuleCat.isLimitKer
(HomologicalComplex.sc ((ContinuousCohomology.homogeneousCochains R G).obj X)
0).g)).left.homologyIso ≪≫
TopModuleCat.ofIso
(ContinuousCohomology.kerHomogeneousCochainsZeroEquiv R G X ((ComplexShape.up ℕ).next 0)
ContinuousCohomology.continuousCohomologyZeroIso._proof_2))
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X =>
(CategoryTheory.ShortComplex.HomologyData.ofIsLimitKernelFork
(HomologicalComplex.sc ((ContinuousCohomology.homogeneousCochains R G).obj X) 0) ⋯
(CategoryTheory.Limits.KernelFork.ofι
(TopModuleCat.kerι
(HomologicalComplex.sc ((ContinuousCohomology.homogeneousCochains R G).obj X) 0).g)
⋯)
(TopModuleCat.isLimitKer
(HomologicalComplex.sc ((ContinuousCohomology.homogeneousCochains R G).obj X)
0).g)).left.homologyIso ≪≫
TopModuleCat.ofIso
(ContinuousCohomology.kerHomogeneousCochainsZeroEquiv R G X ((ComplexShape.up ℕ).next 0)
ContinuousCohomology.continuousCohomologyZeroIso._proof_2))
X).hom
((ContinuousCohomology.invariants R G).map f) |
Metric.exists_isBounded_image_of_tendsto | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_3} {β : Type u_4} [inst : PseudoMetricSpace β] {l : Filter α} {f : α → β} {x : β},
Filter.Tendsto f l (nhds x) → ∃ s ∈ l, Bornology.IsBounded (f '' s) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKeyD_filter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
Lean.IR.UnboxResult.unboxAttr._regBuiltin.Lean.IR.UnboxResult.unboxAttr.docString_1 | Lean.Compiler.IR.UnboxResult | IO Unit |
LieModule.rank_le_finrank | Mathlib.Algebra.Lie.Rank | ∀ (R : Type u_1) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : LieRingModule L M] [inst_8 : LieModule R L M] [inst_9 : Module.Finite R M] [inst_10 : Module.Free R M]
[Nontrivial R], LieModule.rank R L M ≤ Module.finrank R M |
Set.Finite.isGδ_compl | Mathlib.Topology.Separation.GDelta | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} [T1Space X], s.Finite → IsGδ sᶜ |
LieAlgebra.Orthogonal.typeB | Mathlib.Algebra.Lie.Classical | (l : Type u_4) →
(R : Type u₂) →
[inst : DecidableEq l] →
[inst_1 : CommRing R] → [inst_2 : Fintype l] → LieSubalgebra R (Matrix (Unit ⊕ l ⊕ l) (Unit ⊕ l ⊕ l) R) |
CategoryTheory.Over.opEquivOpUnder._proof_4 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) {Z Y : (CategoryTheory.Under X)ᵒᵖ} (f : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp f.unop.right.op (CategoryTheory.Over.mk (Opposite.unop Y).hom.op).hom =
(CategoryTheory.Over.mk (Opposite.unop Z).hom.op).hom |
Array.PrefixTable.step | Batteries.Data.Array.Match | {α : Type u_1} → [BEq α] → (t : Array.PrefixTable α) → α → Fin (t.size + 1) → Fin (t.size + 1) |
Finset.sigmaLift | Mathlib.Data.Finset.Sigma | {ι : Type u_1} →
{α : ι → Type u_2} →
{β : ι → Type u_3} →
{γ : ι → Type u_4} → [DecidableEq ι] → (⦃i : ι⦄ → α i → β i → Finset (γ i)) → Sigma α → Sigma β → Finset (Sigma γ) |
CategoryTheory.MonoidalCategory.externalProductBifunctorCurried_obj_map_app_app | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | ∀ (J₁ : Type u₁) (J₂ : Type u₂) (C : Type u₃) [inst : CategoryTheory.Category.{v₁, u₁} J₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.Functor J₁ C) {X_1 Y : CategoryTheory.Functor J₂ C}
(f : X_1 ⟶ Y) (X_2 : J₁) (c : J₂),
((((CategoryTheory.MonoidalCategory.externalProductBifunctorCurried J₁ J₂ C).obj X).map f).app X_2).app c =
CategoryTheory.MonoidalCategoryStruct.whiskerLeft (X.obj X_2) (f.app c) |
Std.TreeMap.Raw.Equiv.minEntry?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.minEntry? = t₂.minEntry? |
MeasureTheory.lintegral_liminf_le' | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : ℕ → α → ENNReal},
(∀ (n : ℕ), AEMeasurable (f n) μ) →
∫⁻ (a : α), Filter.liminf (fun n => f n a) Filter.atTop ∂μ ≤
Filter.liminf (fun n => ∫⁻ (a : α), f n a ∂μ) Filter.atTop |
SimpleGraph.killCopies.edgeSet.instFintype | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} →
{W : Type u_2} → {G : SimpleGraph V} → {H : SimpleGraph W} → [Fintype ↑G.edgeSet] → Fintype ↑(G.killCopies H).edgeSet |
HasSummableGeomSeries.rec | Mathlib.Analysis.SpecificLimits.Normed | {K : Type u_4} →
[inst : NormedRing K] →
{motive : HasSummableGeomSeries K → Sort u} →
((summable_geometric_of_norm_lt_one : ∀ (ξ : K), ‖ξ‖ < 1 → Summable fun n => ξ ^ n) → motive ⋯) →
(t : HasSummableGeomSeries K) → motive t |
HNNExtension.NormalWord.ReducedWord.prod.eq_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B) (w : HNNExtension.NormalWord.ReducedWord G A B),
HNNExtension.NormalWord.ReducedWord.prod φ w =
HNNExtension.of w.head * (List.map (fun x => HNNExtension.t ^ ↑x.1 * HNNExtension.of x.2) w.toList).prod |
SeparationQuotient.instMulZeroOneClass._proof_3 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M₀ : Type u_1} [inst : TopologicalSpace M₀] [inst_1 : MulZeroOneClass M₀] [inst_2 : ContinuousMul M₀] (a b : M₀),
SeparationQuotient.mk (a * b) = SeparationQuotient.mk a * SeparationQuotient.mk b |
MeasureTheory.Filtration.mono | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {i j : ι}
(f : MeasureTheory.Filtration ι m), i ≤ j → ↑f i ≤ ↑f j |
CategoryTheory.Abelian.Ext.preadditiveYoneda_homologySequenceδ_singleTriangle_apply._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ {n₀ n₁ : ℕ}, 1 + n₀ = n₁ → ↑n₀ + 1 = ↑n₁ |
Module.Flat.rTensor_exact | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u} (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Flat R M]
⦃N : Type u_1⦄ ⦃N' : Type u_2⦄ ⦃N'' : Type u_3⦄ [inst_4 : AddCommGroup N] [inst_5 : AddCommGroup N']
[inst_6 : AddCommGroup N''] [inst_7 : Module R N] [inst_8 : Module R N'] [inst_9 : Module R N''] ⦃f : N →ₗ[R] N'⦄
⦃g : N' →ₗ[R] N''⦄, Function.Exact ⇑f ⇑g → Function.Exact ⇑(LinearMap.rTensor M f) ⇑(LinearMap.rTensor M g) |
WeierstrassCurve.Jacobian.negAddY._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | (2 + 1).AtLeastTwo |
Std.DTreeMap.Raw.alter | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.LawfulEqCmp cmp] →
Std.DTreeMap.Raw α β cmp → (a : α) → (Option (β a) → Option (β a)) → Std.DTreeMap.Raw α β cmp |
_private.Lean.Meta.Tactic.Generalize.0.Lean.Meta.generalizeCore | Lean.Meta.Tactic.Generalize | Lean.MVarId → Array Lean.Meta.GeneralizeArg → Lean.Meta.TransparencyMode → Lean.MetaM (Array Lean.FVarId × Lean.MVarId) |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.support_gaussianPDF._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True |
IsMin.eq_of_ge | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, IsMin a → b ≤ a → a = b |
DifferentiableOn.congr | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : 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 f₁ : E → F} {s : Set E},
DifferentiableOn 𝕜 f s → (∀ x ∈ s, f₁ x = f x) → DifferentiableOn 𝕜 f₁ s |
ENNReal.Lp_add_le | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} (s : Finset ι) (f g : ι → ENNReal) {p : ℝ},
1 ≤ p → (∑ i ∈ s, (f i + g i) ^ p) ^ (1 / p) ≤ (∑ i ∈ s, f i ^ p) ^ (1 / p) + (∑ i ∈ s, g i ^ p) ^ (1 / p) |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.skewAdjoint.isStarNormal_of_mem._simp_1_2 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u} [inst : Mul R] [inst_1 : HasDistribNeg R] {a b : R}, Commute a b → Commute (-a) b = True |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.IsPos.or_neg._proof_1_2 | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (b : P.Base)
[inst_5 : CharZero R] (i : ι), b.height i ≠ 0 → 0 < b.height i ∨ 0 < -b.height i |
LinearMap.toMatrixₛₗ₂'_symm | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {R₁ : Type u_2} {S₁ : Type u_3} {R₂ : Type u_4} {S₂ : Type u_5} {N₂ : Type u_10} {n : Type u_11}
{m : Type u_12} [inst : CommSemiring R] [inst_1 : AddCommMonoid N₂] [inst_2 : Module R N₂] [inst_3 : Semiring R₁]
[inst_4 : Semiring R₂] [inst_5 : Semiring S₁] [inst_6 : Semiring S₂] [inst_7 : Module S₁ N₂] [inst_8 : Module S₂ N₂]
[inst_9 : SMulCommClass S₁ R N₂] [inst_10 : SMulCommClass S₂ R N₂] [inst_11 : SMulCommClass S₂ S₁ N₂] (σ₁ : R₁ →+* S₁)
(σ₂ : R₂ →+* S₂) [inst_12 : Fintype n] [inst_13 : Fintype m] [inst_14 : DecidableEq n] [inst_15 : DecidableEq m],
(LinearMap.toMatrixₛₗ₂' R).symm = Matrix.toLinearMapₛₗ₂' R σ₁ σ₂ |
Equiv.Perm.SameCycle.equivalence | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} (f : Equiv.Perm α), Equivalence f.SameCycle |
Lean.Widget.PanelWidgetInstance.mk.injEq | Lean.Widget.UserWidget | ∀ (toWidgetInstance : Lean.Widget.WidgetInstance) (range? : Option Lean.Lsp.Range) (name? : Option String)
(toWidgetInstance_1 : Lean.Widget.WidgetInstance) (range?_1 : Option Lean.Lsp.Range) (name?_1 : Option String),
({ toWidgetInstance := toWidgetInstance, range? := range?, name? := name? } =
{ toWidgetInstance := toWidgetInstance_1, range? := range?_1, name? := name?_1 }) =
(toWidgetInstance = toWidgetInstance_1 ∧ range? = range?_1 ∧ name? = name?_1) |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.findTactic?.merge._sparseCasesOn_3 | Lean.Server.CodeActions.Provider | {motive : Bool → Sort u} → (t : Bool) → motive false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
LinearEquiv.domMulActCongrRight._proof_6 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_4} {R₁' : Type u_5} {R₂' : Type u_6} {M₁ : Type u_2} {M₁' : Type u_1} {M₂' : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁' M₁']
[inst_8 : Module R₂' M₂'] {σ₁'₂' : R₁' →+* R₂'} {σ₂'₁' : R₂' →+* R₁'} {σ₁₁' : R₁ →+* R₁'} {σ₁₂' : R₁ →+* R₂'}
[inst_9 : RingHomInvPair σ₁'₂' σ₂'₁'] [inst_10 : RingHomInvPair σ₂'₁' σ₁'₂']
[inst_11 : RingHomCompTriple σ₁₁' σ₁'₂' σ₁₂'] [inst_12 : RingHomCompTriple σ₁₂' σ₂'₁' σ₁₁'] (e₂ : M₁' ≃ₛₗ[σ₁'₂'] M₂'),
Function.RightInverse ((LinearEquiv.refl R₁ M₁).arrowCongrAddEquiv e₂).invFun
((LinearEquiv.refl R₁ M₁).arrowCongrAddEquiv e₂).toFun |
MulZeroClass.rec | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
{motive : MulZeroClass M₀ → Sort u_1} →
([toMul : Mul M₀] →
[toZero : Zero M₀] →
(zero_mul : ∀ (a : M₀), 0 * a = 0) →
(mul_zero : ∀ (a : M₀), a * 0 = 0) →
motive { toMul := toMul, toZero := toZero, zero_mul := zero_mul, mul_zero := mul_zero }) →
(t : MulZeroClass M₀) → motive t |
CategoryTheory.toOverIsoToOverUnit_hom_app_left | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C),
(CategoryTheory.toOverIsoToOverUnit.hom.app X).left =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.equivToOverUnit C).unit.app
((CategoryTheory.toOver (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).obj X)).left
(CategoryTheory.SemiCartesianMonoidalCategory.fst X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow_add_gt.match_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ), (x = 0 → motive 0) → (∀ (d : ℕ), x = d.succ → motive d.succ) → motive x |
CategoryTheory.Coverage.mem_toGrothendieck | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {K : CategoryTheory.Coverage C} {X : C}
{S : CategoryTheory.Sieve X}, S ∈ K.toGrothendieck X ↔ K.Saturate X S |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0._regBuiltin.String.reduceBNe.declare_74._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.904556020._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit |
Fintype.decidableEqEmbeddingFintype._proof_1 | Mathlib.Data.Fintype.Defs | ∀ {α : Type u_1} {β : Type u_2} (a b : α ↪ β), ⇑a = ⇑b ↔ a = b |
CategoryTheory.Presheaf.compULiftYonedaIsoULiftYonedaCompLan.presheafHom | Mathlib.CategoryTheory.Limits.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G :
CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂)))
(CategoryTheory.Functor Dᵒᵖ (Type (max w v₁ v₂)))} →
(F.comp CategoryTheory.uliftYoneda.{max w v₁, v₂, u₂} ⟶
CategoryTheory.uliftYoneda.{max w v₂, v₁, u₁}.comp G) →
(P : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) → P ⟶ F.op.comp (G.obj P) |
Lean.Meta.Sym.State.casesOn | Lean.Meta.Sym.SymM | {motive : Lean.Meta.Sym.State → Sort u} →
(t : Lean.Meta.Sym.State) →
((share : Lean.Meta.Sym.AlphaShareCommon.State) →
(maxFVar : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option Lean.FVarId)) →
(proofInstInfo : Lean.PHashMap Lean.Name (Option Lean.Meta.Sym.ProofInstInfo)) →
(inferType : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Expr) →
(getLevel : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Level) →
(congrInfo : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Sym.CongrInfo) →
(defEqI : Lean.PHashMap (Lean.Meta.Sym.ExprPtr × Lean.Meta.Sym.ExprPtr) Bool) →
(debug : Bool) →
motive
{ share := share, maxFVar := maxFVar, proofInstInfo := proofInstInfo, inferType := inferType,
getLevel := getLevel, congrInfo := congrInfo, defEqI := defEqI, debug := debug }) →
motive t |
HomotopicalAlgebra.Precylinder.symm_I | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P : HomotopicalAlgebra.Precylinder A), P.symm.I = P.I |
BitVec.instCommutativeHOr | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, Std.Commutative fun x y => x ||| y |
Subgroup.commensurable_strictPeriods_periods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.strictPeriods.Commensurable 𝒢.periods |
SimpleGraph.FinsubgraphHom.restrict._proof_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {G' G'' : G.Finsubgraph}, G'' ≤ G' → ∀ v ∈ (↑G'').verts, v ∈ (↑G').verts |
FP.emin.eq_1 | Mathlib.Data.FP.Basic | ∀ [C : FP.FloatCfg], FP.emin = 1 - ↑FP.FloatCfg.emax |
IsRelUpperSet.iInter | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {ι : Sort u_2} {P : α → Prop} [inst : LE α] [Nonempty ι] {f : ι → Set α},
(∀ (i : ι), IsRelUpperSet (f i) P) → IsRelUpperSet (⋂ i, f i) P |
List.Sublist.below | Init.Data.List.Basic | {α : Type u_1} → {motive : (a a_1 : List α) → a.Sublist a_1 → Prop} → {a a_1 : List α} → a.Sublist a_1 → Prop |
Function.Embedding.coeWithTop_apply | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} (a : α), Function.Embedding.coeWithTop a = ↑a |
AddMonoid.Coprod.swap_comp_inr | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
(AddMonoid.Coprod.swap M N).comp AddMonoid.Coprod.inr = AddMonoid.Coprod.inl |
CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.compYonedaColimitIsoColimitCompYoneda | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type v} →
[inst_1 : CategoryTheory.SmallCategory I] →
(F : CategoryTheory.Functor I (CategoryTheory.Functor Cᵒᵖ (Type v))) →
{J : Type v} →
[inst_2 : CategoryTheory.SmallCategory J] →
(G :
CategoryTheory.Functor J
(CategoryTheory.CostructuredArrow CategoryTheory.yoneda (CategoryTheory.Limits.colimit F))) →
{K : Type v} →
[inst_3 : CategoryTheory.SmallCategory K] →
(H : CategoryTheory.Functor K (CategoryTheory.Over (CategoryTheory.Limits.colimit F))) →
(G.op.comp
(CategoryTheory.CostructuredArrow.toOver CategoryTheory.yoneda
(CategoryTheory.Limits.colimit F)).op).comp
(CategoryTheory.yoneda.obj (CategoryTheory.Limits.colimit H)) ≅
CategoryTheory.Limits.colimit
(H.comp
(CategoryTheory.yoneda.comp
((CategoryTheory.Functor.whiskeringLeft Jᵒᵖ
(CategoryTheory.Over (CategoryTheory.Limits.colimit F))ᵒᵖ (Type (max u v))).obj
(G.op.comp
(CategoryTheory.CostructuredArrow.toOver CategoryTheory.yoneda
(CategoryTheory.Limits.colimit F)).op)))) |
isClosed_setOf_isCompactOperator | Mathlib.Analysis.Normed.Operator.Compact | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NontriviallyNormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ₁₂ : 𝕜₁ →+* 𝕜₂}
{M₁ : Type u_3} {M₂ : Type u_4} [inst_2 : SeminormedAddCommGroup M₁] [inst_3 : AddCommGroup M₂]
[inst_4 : NormedSpace 𝕜₁ M₁] [inst_5 : Module 𝕜₂ M₂] [inst_6 : UniformSpace M₂] [inst_7 : IsUniformAddGroup M₂]
[ContinuousConstSMul 𝕜₂ M₂] [T2Space M₂] [CompleteSpace M₂], IsClosed {f | IsCompactOperator ⇑f} |
Nat.lt_irrefl | Init.Prelude | ∀ (n : ℕ), ¬n < n |
Fin.sub_eq_add_neg | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (x y : Fin n), x - y = x + -y |
_private.Mathlib.NumberTheory.LSeries.Convergence.0.LSeriesSummable_of_abscissaOfAbsConv_lt_re._simp_1_2 | Mathlib.NumberTheory.LSeries.Convergence | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] {s : Set α} {b : α}, (sInf s < b) = ∃ a ∈ s, a < b |
CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {T : CategoryTheory.Comonad C}
{D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget))
(t : CategoryTheory.Limits.IsLimit c) [inst_2 : CategoryTheory.Limits.PreservesLimit (D.comp T.forget) T.toFunctor]
[inst_3 : CategoryTheory.Limits.PreservesLimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor] (A B : J)
(f : A ⟶ B),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const J).obj (CategoryTheory.Comonad.ForgetCreatesLimits'.conePoint c t)).map f)
{ f := c.π.app B, h := ⋯ } =
CategoryTheory.CategoryStruct.comp { f := c.π.app A, h := ⋯ } (D.map f) |
SimpleGraph.not_isUniform_iff | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {G : SimpleGraph α}
[inst_3 : DecidableRel G.Adj] {ε : 𝕜} {s t : Finset α},
¬G.IsUniform ε s t ↔
∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity s t| |
Std.TreeMap.foldl | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → {δ : Type w} → (δ → α → β → δ) → δ → Std.TreeMap α β cmp → δ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.