name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.coneUnopOfCoconeEquiv_inverse_map | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ} {Y X : CategoryTheory.Limits.Cone F.unop} (f : Y ⟶ X),
CategoryTheory.Limits.coneUnopOfCoconeEquiv.inverse.map f = Opposite.op { hom := f.hom.op, w := ⋯ } | null | true |
CategoryTheory.Limits.image.lift_mk_factorThruImage | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasImage f],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.image.lift
{ I := CategoryTheory.Limits.image f, m := CategoryTheory.Limits.image.ι f, m_mono := ⋯,
e := Categ... | null | true |
IsPrimitiveRoot.one | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M], IsPrimitiveRoot 1 1 | null | true |
sign_eq_sign_or_eq_neg | Mathlib.Basic.Sign.Defs | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] {a b : α},
a ≠ 0 → b ≠ 0 → SignType.sign a = SignType.sign b ∨ SignType.sign a = -SignType.sign b | null | true |
Mathlib.Tactic.LibraryRewrite.rpc | Mathlib.Tactic.Widget.LibraryRewrite | SelectInsertParams → Lean.Server.RequestM (Lean.Server.RequestTask ProofWidgets.Html) | The rpc method of the `rw??` widget. | true |
_private.Lean.Meta.CtorIdxHInj.0.Lean.Meta.initFn.match_1._@.Lean.Meta.CtorIdxHInj.1686831688._hygCtx._hyg.2 | Lean.Meta.CtorIdxHInj | (motive : Option Lean.InductiveVal → Sort u_1) →
(x : Option Lean.InductiveVal) →
((indVal : Lean.InductiveVal) → motive (some indVal)) → ((x : Option Lean.InductiveVal) → motive x) → motive x | null | false |
aeconst_of_dense_setOfPred_preimage_smul_ae | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {M : Type u_1} [inst : TopologicalSpace M] {X : Type u_2} [inst_1 : TopologicalSpace X] [R1Space X]
[inst_3 : MeasurableSpace X] [BorelSpace X] [inst_5 : SMul M X] [ContinuousSMul M X] {μ : MeasureTheory.Measure X}
[MeasureTheory.IsFiniteMeasure μ] [μ.InnerRegular] [ErgodicSMul M X μ] {s : Set X},
MeasureTheory... | Let `M` act continuously on an R₁ topological space `X`.
Let `μ` be a finite inner regular measure on `X` which is ergodic with respect to this action.
If a null measurable set `s` is a.e. equal
to its preimages under the action of a dense set of elements of `M`,
then it is either null or conull. | true |
Module.DirectLimit.exists_of | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] {G : ι → Type u_3}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] [Nonempty ι] [IsDirectedOrder ι] (z : Module.DirectLimit G f),
∃ i x, (Module.D... | Every element of the direct limit corresponds to some element in
some component of the directed system. | true |
Submodule.liftQSpanSingleton._proof_1 | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {R₂ : Type u_3}
{M₂ : Type u_4} [inst_3 : Ring R₂] [inst_4 : AddCommGroup M₂] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂} (x : M)
(f : M →ₛₗ[τ₁₂] M₂), f x = 0 → R ∙ x ≤ f.ker | null | false |
Balanced.smul_eq | Mathlib.Analysis.LocallyConvex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedDivisionRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{s : Set E} {a : 𝕜}, Balanced 𝕜 s → ‖a‖ = 1 → a • s = s | null | true |
MeasureTheory.isMulLeftInvariant_map_smul | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Semigroup G] [MeasurableMul G] {μ : MeasureTheory.Measure G}
{α : Type u_3} [inst_3 : SMul α G] [SMulCommClass α G G] [MeasurableConstSMul α G] [μ.IsMulLeftInvariant] (a : α),
(MeasureTheory.Measure.map (fun x => a • x) μ).IsMulLeftInvariant | The image of a left invariant measure under a left action is left invariant, assuming that
the action preserves multiplication. | true |
Set.image_const_sub_Iic | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (a b : α),
(fun x => a - x) '' Set.Iic b = Set.Ici (a - b) | null | true |
IsSelfNeg.sub | Mathlib.Algebra.Group.SelfInv | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] {a b : α}, IsSelfNeg a → IsSelfNeg b → IsSelfNeg (a - b) | null | true |
AnalyticAt.compContinuousLinearMap | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {u : E →L[𝕜] F} {f : F → G} {x : E},... | null | true |
_private.Mathlib.Analysis.Asymptotics.Basic.0.Asymptotics.IsBigOWith.exists_nonneg.match_1_1 | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {E : Type u_2} {F' : Type u_3} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {f : α → E}
{g' : α → F'} {l : Filter α} (motive : (∃ c' > 0, Asymptotics.IsBigOWith c' l f g') → Prop)
(x : ∃ c' > 0, Asymptotics.IsBigOWith c' l f g'),
(∀ (c : ℝ) (cpos : c > 0) (hc : Asymptotics.IsBigOWith c l ... | null | false |
PresheafOfModules.restrictScalarsCompToPresheaf | Mathlib.Algebra.Category.ModuleCat.Presheaf.ChangeOfRings | {C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{R R' : CategoryTheory.Functor Cᵒᵖ RingCat} →
(α : R ⟶ R') →
(PresheafOfModules.restrictScalars α).comp (PresheafOfModules.toPresheaf R) ≅ PresheafOfModules.toPresheaf R' | The isomorphism `restrictScalars α ⋙ toPresheaf R ≅ toPresheaf R'` for any
morphism of presheaves of rings `α : R ⟶ R'`. | true |
Representation.IntertwiningMap.range._proof_3 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_3} {G : Type u_4} {V : Type u_2} {W : Type u_1} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W) (f : ρ.IntertwiningMap σ) (g : G) {w : W} (v : V),
f.toLinea... | null | false |
Homeomorph.sumCongr_refl | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
(Homeomorph.refl X).sumCongr (Homeomorph.refl Y) = Homeomorph.refl (X ⊕ Y) | null | true |
_private.Mathlib.Condensed.Light.Sequence.0.InternalProjectivityProof.cover._proof_1 | Mathlib.Condensed.Light.Sequence | ∀ {S T : LightProfinite} (π : T ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj S LightProfinite.NatUnionInfty),
CompHausLike.HasProp (fun Y => TotallyDisconnectedSpace ↑Y ∧ SecondCountableTopology ↑Y)
↑{xy |
(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct.comp
... | null | false |
Lean.Parser.levelParser | Lean.Parser.Level | optParam ℕ 0 → Lean.Parser.Parser | null | true |
_private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.add'._proof_1 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_2} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_1}
[inst_2 : AddMonoid X] [inst_3 : DistribMulAction R X] (r₂ : X) (s₂ : ↥S) (a b : X × ↥S),
a ≈ b → OreLocalization.add''✝ a.1 a.2 r₂ s₂ = OreLocalization.add''✝ b.1 b.2 r₂ s₂ | null | false |
Real.binEntropy_le_log_two | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {p : ℝ}, Real.binEntropy p ≤ Real.log 2 | null | true |
Mathlib.MoveAdd.tacticMove_add_ | Mathlib.Tactic.MoveAdd | Lean.ParserDescr | `move_oper op [a]` repeatedly moves `a` to the far right hand side in applications of `op`.
Here the constant `op` refers to a binary associative commutative operation, and `a` is any term
(potentially with underscores).
If `a` contains underscores, they are filled in by unification with the first matching occurrence.... | true |
CategoryTheory.ObjectProperty.le_strictLimitsClosureStep._simp_1 | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C) {α : Type t}
(J : α → Type u') [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)],
(P ≤ P.strictLimitsClosureStep J) = True | null | false |
Int32.toInt_ofInt_of_le | Init.Data.SInt.Lemmas | ∀ {n : ℤ}, -2 ^ 31 ≤ n → n < 2 ^ 31 → (Int32.ofInt n).toInt = n | null | true |
List.ext_getElem | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ l₂ : List α},
l₁.length = l₂.length → (∀ (i : ℕ) (h₁ : i < l₁.length) (h₂ : i < l₂.length), l₁[i] = l₂[i]) → l₁ = l₂ | null | true |
Std.HashMap.Raw.getElem!_union | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited β], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∪ m₂)[k]! = m₂.getD k m₁[k]! | null | true |
isSimpleAddGroup_of_prime_card | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : AddGroup α] {p : ℕ} [hp : Fact (Nat.Prime p)], Nat.card α = p → IsSimpleAddGroup α | A finite group of prime order is simple. | true |
Distributions.«_aux_Mathlib_Analysis_Distribution_Distribution___macroRules_Distributions_term𝓓'^{_}(_,_)_1» | Mathlib.Analysis.Distribution.Distribution | Lean.Macro | null | false |
CategoryTheory.HasLiftingProperty.transfiniteComposition.wellOrderInductionData._proof_3 | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_3} [inst_1 : LinearOrder J]
[inst_2 : OrderBot J] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {X Y : C} {p : X ⟶ Y}
(f : F.obj ⊥ ⟶ X) (g : c.pt ⟶ Y) [inst_3 : SuccOrder J] (j : J)
(sq' : (CategoryTheory.HasLifting... | null | false |
_private.Mathlib.Data.List.Basic.0.List.getLastI.match_1.eq_1 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → Sort u_2) (h_1 : Unit → motive []) (h_2 : (a : α) → motive [a])
(h_3 : (head b : α) → motive [head, b]) (h_4 : (head head_1 : α) → (l : List α) → motive (head :: head_1 :: l)),
(match [] with
| [] => h_1 ()
| [a] => h_2 a
| [head, b] => h_3 head b
| head :: head_1... | null | true |
_private.Mathlib.Tactic.Matrix.ListMatrix.0.Mathlib.Tactic.Matrix.ListMatrix.getD_mul._proof_1_16 | Mathlib.Tactic.Matrix.ListMatrix | ∀ {α : Type u_1} {l i : ℕ} (A : List (List α)), i < l → i < A.length + (l - A.length) | null | false |
_private.Lean.Meta.Tactic.Simp.Arith.Int.Basic.0.Int.Internal.Linear.Expr.applyPerm.go.match_1 | Lean.Meta.Tactic.Simp.Arith.Int.Basic | (motive : Int.Internal.Linear.Expr → Sort u_1) →
(x : Int.Internal.Linear.Expr) →
((v : ℤ) → motive (Int.Internal.Linear.Expr.num v)) →
((i : Int.Internal.Linear.Var) → motive (Int.Internal.Linear.Expr.var i)) →
((a : Int.Internal.Linear.Expr) → motive a.neg) →
((a b : Int.Internal.Linear.... | null | false |
CategoryTheory.Limits.PreservesFiniteLimits.preservesFiniteLimits | Mathlib.CategoryTheory.Limits.Preserves.Finite | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D} [self : CategoryTheory.Limits.PreservesFiniteLimits F] (J : Type)
[inst_2 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J],
CategoryTheory.Limits... | null | true |
_private.Mathlib.Data.Finset.Prod.0.Finset.diag_insert._proof_1_1 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α] (a : α), (insert a s).diag = insert (a, a) s.diag | null | false |
FirstOrder.Language.BoundedFormula.restrictFreeVar.eq_def | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {α : Type u'} {β : Type v'} [inst : DecidableEq α] (x : ℕ) (x_1 : L.BoundedFormula α x)
(x_2 : ↥x_1.freeVarFinset → β),
x_1.restrictFreeVar x_2 =
match x, x_1, x_2 with
| _n, FirstOrder.Language.BoundedFormula.falsum, _f => FirstOrder.Language.BoundedFormula.falsum
| _n, Firs... | null | true |
PresheafOfModules.Hom | Mathlib.Algebra.Category.ModuleCat.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} → PresheafOfModules R → PresheafOfModules R → Type (max u₁ v) | A morphism of presheaves of modules consists of a family of linear maps which
satisfy the naturality condition. | true |
AddMonCat.adjoinZero.eq_1 | Mathlib.Algebra.Category.MonCat.Adjunctions | AddMonCat.adjoinZero =
{ obj := fun S => ↧(WithZero ↑S), map := fun {X Y} f => AddMonCat.ofHom (WithZero.mapAddHom (AddSemigrp.Hom.hom f)),
map_id := AddMonCat.adjoinZero._proof_1, map_comp := @AddMonCat.adjoinZero._proof_2 } | null | true |
Module.AEval.mapSubmodule._proof_2 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsScalarTower R R M | null | false |
_private.Mathlib.Logic.Equiv.PartialEquiv.0.PartialEquiv.IsImage.iff_preimage_eq._simp_1_5 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
IsSelfAdjoint.commute_cfcₙHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Commute | ∀ {𝕜 : Type u_1} {A : Type u_2} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : NonUnitalRing A] [inst_2 : StarRing A]
[inst_3 : Module 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A] [inst_6 : TopologicalSpace A]
[inst_7 : NonUnitalContinuousFunctionalCalculus 𝕜 A p] [IsTopologicalRing A] [T2Sp... | null | true |
CommGroupWithZero.instStrongNormalizedGCDMonoid._proof_10 | Mathlib.Algebra.GCDMonoid.Basic | ∀ (G₀ : Type u_1) [inst : CommGroupWithZero G₀] [inst_1 : DecidableEq G₀] (a b : G₀),
a = 0 ∨ b = 0 → normalize (if a = 0 ∨ b = 0 then 0 else 1) = if a = 0 ∨ b = 0 then 0 else 1 | null | false |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.IRType.isObj._sparseCasesOn_1 | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
(t : Lean.IR.IRType) →
motive_1 Lean.IR.IRType.object →
motive_1 Lean.IR.IRType.tagged →
motive_1 Lean.IR.IRType.tobject →
motive_1 Lean.IR.IRType.void → (Nat.hasNotBit 12672 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
Algebra.TensorProduct.map_ker | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_4} {S : Type u_5} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {A : Type u_6}
{B : Type u_7} {C : Type u_8} {D : Type u_9} [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Ring C] [inst_6 : Ring D]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : Algebra R C] [inst_10 : Algebra... | If `f` and `g` are surjective morphisms of algebras, then
the kernel of `Algebra.TensorProduct.map f g` is generated by the kernels of `f` and `g` | true |
Lean.Parser.Tactic.simpAllTraceArgsRest | Init.Tactics | Lean.ParserDescr | The common arguments of `simp_all?` and `simp_all?!`. | true |
_private.Mathlib.Order.Northcott.0.Northcott.comp_of_finite_fibers._proof_1_1 | Mathlib.Order.Northcott | ∀ {α : Type u_2} {β : Type u_1} {γ : Type u_3} (h : α → β) (h' : β → γ) [inst : LE γ] (c : γ),
h '' {a | (h' ∘ h) a ≤ c} ⊆ {a | h' a ≤ c} | null | false |
_private.Batteries.Data.List.Lemmas.0.List.mem_findIdxs_iff_pos_getElem._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {i : ℕ} {α : Type u_1} {xs : List α}, i < xs.length → i < xs.length | null | false |
Real.ceil_exp_one_eq_three | Mathlib.Analysis.Complex.ExponentialBounds | ⌈Real.exp 1⌉ = 3 | null | true |
CategoryTheory.WideSubcategory.ctorIdx | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{_P : CategoryTheory.MorphismProperty C} → {inst_1 : _P.IsMultiplicative} → CategoryTheory.WideSubcategory _P → ℕ | null | false |
SMulPosReflectLT.mk._flat_ctor | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β] [inst_3 : Zero β],
(∀ ⦃b : β⦄, 0 ≤ b → ∀ ⦃a₁ a₂ : α⦄, a₁ • b < a₂ • b → a₁ < a₂) → SMulPosReflectLT α β | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isSome_minKey?_modify._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
MeromorphicOn.meromorphicOn_fun_comp_sub_const_iff_meromorphicOn | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {c : 𝕜} {U : Set 𝕜},
MeromorphicOn (fun x => f (x - c)) U ↔ MeromorphicOn f (U - {c}) | Eta-expanded form of `MeromorphicOn.meromorphicOn_comp_sub_const_iff_meromorphicOn`
---
`MeromorphicOn` is invariant under translation. | true |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.forall_mem_keysArray_iff_forall_mem_getKey._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
Mathlib.Tactic.BicategoryLike.MkMor₂.recOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkMor₂ m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkMor₂ m) →
((ofExpr : Lean.Expr → m Mathlib.Tactic.BicategoryLike.Mor₂) → motive { ofExpr := ofExpr }) → motive t | null | false |
IsDiscrete.subsingleton_of_isPreirreducible | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsDiscrete s → IsPreirreducible s → s.Subsingleton | null | true |
CategoryTheory.Functor.CoconeTypes.precomp._proof_2 | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} J] {F : CategoryTheory.Functor J (Type u_3)}
(c : F.CoconeTypes) {J' : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} J'] (G : CategoryTheory.Functor J' J)
{j j' : J'} (f : j ⟶ j'), c.ι (G.obj j') ∘ ⇑(CategoryTheory.ConcreteCategory.hom ((G.comp F)... | null | false |
OreLocalization.instDivisionRingNonZeroDivisors._proof_6 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : Nontrivial R] [inst_2 : NoZeroDivisors R]
[inst_3 : OreLocalization.OreSet (nonZeroDivisors R)] (n : ℕ) (a : OreLocalization (nonZeroDivisors R) R),
a ^ Int.negSucc n = (a ^ ↑n.succ)⁻¹ | null | false |
LinearMap.toMatrix_basis_equiv | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {l : Type u_2} {M₁ : Type u_5} {M₂ : Type u_6} [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] [inst_5 : Fintype l]
[inst_6 : DecidableEq l] (b : Module.Basis l R M₁) (b' : Module.Basis l R M₂),
(LinearMap.toMatrix b' b... | null | true |
CategoryTheory.GrothendieckTopology.sheafification | Mathlib.CategoryTheory.Sites.ConcreteSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type w) →
[inst_1 : CategoryTheory.Category.{w', w} D] →
[∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X),
CategoryTheory.Limits.HasMultiequalizer (S.i... | The sheafification of a presheaf `P`, as a functor.
*NOTE:* Additional hypotheses are needed to obtain a proof that this is a sheaf! | true |
_private.Mathlib.Algebra.Homology.TotalComplex.0.HomologicalComplex₂.hasTotal_of_iso.match_1_1 | Mathlib.Algebra.Homology.TotalComplex | {I₁ : Type u_1} →
{I₂ : Type u_2} → (motive : I₁ × I₂ → Sort u_3) → (x : I₁ × I₂) → ((i₁ : I₁) → (i₂ : I₂) → motive (i₁, i₂)) → motive x | null | false |
Std.Time.instInhabitedOffsetX.default | Std.Time.Format.Modifier | Std.Time.OffsetX | null | true |
Array.SatisfiesM_foldlM._proof_2 | Batteries.Recycling.MonadSatisfying.Array | ∀ {α : Type u_1} {as : Array α} (i : Fin as.size), ↑i < as.size | null | false |
CategoryTheory.expComparison | Mathlib.CategoryTheory.Monoidal.Closed.Functor | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v, u'} D] →
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] →
(F : CategoryTheory.Functor C D) →
... | The exponential comparison map.
`F` is a Cartesian closed functor if this is an iso for all `A`.
| true |
_private.Mathlib.GroupTheory.Perm.Fin.0.Fin.cycleIcc_of_le_of_le._proof_1_14 | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} {i j k : Fin n}, i ≤ k → k ≤ j → ¬k = j → ↑k - ↑i < ↑j - ↑i | null | false |
AddMonoidHom.compLeft._proof_2 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {α : Type u_3} {β : Type u_1} [inst : AddZeroClass α] [inst_1 : AddZeroClass β] (f : α →+ β) (I : Type u_2)
(x x_1 : I → α), ⇑f ∘ (x + x_1) = ⇑f ∘ x + ⇑f ∘ x_1 | null | false |
CategoryTheory.ObjectProperty.subtypeOpEquiv._proof_3 | Mathlib.CategoryTheory.ObjectProperty.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.CategoryStruct.{u_1, u_2} C] (P : CategoryTheory.ObjectProperty C)
(x : Subtype P.op), P.op ↑x | null | false |
MeasureTheory.addEquivAddHaarChar_smul_eq_comap | Mathlib.MeasureTheory.Measure.Haar.MulEquivHaarChar | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : MeasurableSpace G] [inst_3 : BorelSpace G]
[inst_4 : IsTopologicalAddGroup G] [inst_5 : LocallyCompactSpace G] (μ : MeasureTheory.Measure G) [μ.IsAddHaarMeasure]
[μ.Regular] (φ : G ≃ₜ+ G), MeasureTheory.addEquivAddHaarChar φ • μ = MeasureT... | null | true |
Int.cast_neg_natCast._simp_1 | Mathlib.Data.Int.Cast.Field | ∀ {R : Type u_2} [inst : DivisionRing R] (n : ℕ), -↑n = ↑(-↑n) | null | false |
antitone_iff_apply₂ | Mathlib.Order.Monotone.Defs | ∀ {ι : Type u_1} {α : Type u} {β : ι → Type u_4} [inst : (i : ι) → Preorder (β i)] [inst_1 : Preorder α]
{f : α → (i : ι) → β i}, Antitone f ↔ ∀ (i : ι), Antitone fun x => f x i | null | true |
DiffContOnCl.circleAverage_re_herglotzRieszKernel_smul' | Mathlib.Analysis.Complex.Poisson | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℂ → E} {R : ℝ} {w : ℂ} [CompleteSpace E]
{c : ℂ},
DiffContOnCl ℂ f (Metric.ball c R) →
w ∈ Metric.ball c R → Real.circleAverage (fun z => ((z - c + (w - c)) / (z - c - (w - c))).re • f z) c R = f w | **Poisson integral formula** for ℂ-differentiable functions on arbitrary disks in the complex plane,
formulated with the real part of the Herglotz–Riesz kernel of integration expanded.
| true |
CategoryTheory.Iso.toCoalgEquiv_trans | Mathlib.Algebra.Category.CoalgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {X Y Z : CoalgCat R} (e : X ≅ Y) (f : Y ≅ Z),
(e ≪≫ f).toCoalgEquiv = e.toCoalgEquiv.trans f.toCoalgEquiv | null | true |
Lean.DataValue.noConfusion | Lean.Data.KVMap | {P : Sort u} → {t t' : Lean.DataValue} → t = t' → Lean.DataValue.noConfusionType P t t' | null | false |
Sum.instLocallyFiniteOrder._proof_2 | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (a b x : α ⊕ β), x ∈ Finset.sumLift₂ Finset.Ico Finset.Ico a b ↔ a ≤ x ∧ x < b | null | false |
CategoryTheory.SimplicialObject.Split | Mathlib.AlgebraicTopology.SimplicialObject.Split | (C : Type u_1) → [CategoryTheory.Category.{v_1, u_1} C] → Type (max u_1 v_1) | The category `SimplicialObject.Split C` is the category of simplicial objects
in `C` equipped with a splitting, and morphisms are morphisms of simplicial objects
which are compatible with the splittings. | true |
Int.Internal.Linear.Poly.getConst | Init.Data.Int.Linear | Int.Internal.Linear.Poly → ℤ | Returns the constant of the given linear polynomial. | true |
StableUnderGeneralization.image | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
GeneralizingMap f → ∀ {s : Set X}, StableUnderGeneralization s → StableUnderGeneralization (f '' s) | **Alias** of `GeneralizingMap.stableUnderGeneralization_image`. | true |
lTensor.inverse_of_rightInverse._proof_9 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_1} {P : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_2) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | null | false |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.FriendlyOperation.coind_comp_friend_left.match_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {basis_hd : ℝ → ℝ} →
{basis_tl : Tactic.ComputeAsymptotics.Basis} →
(motive :
(Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl →
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl) →
Prop) →
(motive_1 :
ℝ ×
... | null | false |
SubmoduleClass.module'._proof_3 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u_3} {R : Type u_4} {M : Type u_1} {T : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Semiring S] [inst_3 : Module R M] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M]
[inst_7 : SetLike T M] [inst_8 : AddSubmonoidClass T M] [inst_9 : SMulMemClass T R M] (t :... | null | false |
QuasispectrumRestricts.nonUnitalStarAlgHom._proof_12 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} [inst : Semifield R] [inst_1 : TopologicalSpace R] [inst_2 : Field S]
[inst_3 : TopologicalSpace S] [inst_4 : Algebra R S] [inst_5 : ContinuousSMul R S], Continuous ⇑(algebraMapCLM R S) | null | false |
CochainComplex.mkHom | Mathlib.Algebra.Homology.HomologicalComplex | {V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
(P Q : CochainComplex V ℕ) →
(zero : P.X 0 ⟶ Q.X 0) →
(one : P.X 1 ⟶ Q.X 1) →
CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp ... | A constructor for chain maps between `ℕ`-indexed cochain complexes,
working by induction on commutative squares.
You need to provide the components of the chain map in degrees 0 and 1,
show that these form a commutative square,
and then give a construction of each component,
and the fact that it forms a commutative sq... | true |
FractionalIdeal.quotientEquiv._proof_2 | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra R K], SMulCommClass R R K | null | false |
SummableUniformly.summable | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : AddCommMonoid α] {f : ι → β → α} {x : β}
[inst_1 : UniformSpace α], SummableUniformly f → Summable fun x_1 => f x_1 x | null | true |
_private.Init.Data.List.Lemmas.0.GetElem?.match_1.splitter | Init.Data.List.Lemmas | (elem : outParam (Type u_1)) →
(motive : Option elem → Sort u_2) →
(x : Option elem) → ((e : elem) → motive (some e)) → (Unit → motive none) → motive x | null | true |
CategoryTheory.MonoidalClosed.curry'_comp | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.Closed X] [inst_3 : CategoryTheory.Closed Y] (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.MonoidalClosed.curry' (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.Category... | null | true |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.uniqueBaseOn_inter_ground_eq._simp_1_2 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (M M' : Matroid α) (X : Set α), (M.restrict X = M'.restrict X) = ∀ I ⊆ X, M.Indep I ↔ M'.Indep I | null | false |
MeasureTheory.unifTight_iff_ennreal | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : NormedAddCommGroup β] {x : MeasurableSpace α} (f : ι → α → β)
(p : ENNReal) (μ : MeasureTheory.Measure α),
MeasureTheory.UnifTight f p μ ↔
∀ ⦃ε : ENNReal⦄, 0 < ε → ∃ s, μ s ≠ ⊤ ∧ ∀ (i : ι), MeasureTheory.eLpNorm (sᶜ.indicator (f i)) p μ ≤ ε | null | true |
TensorProduct.rightComm._proof_2 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_4) [inst : CommSemiring R] (M : Type u_1) (N : Type u_2) (P : Type u_3) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P],
TensorProduct.lift
(TensorProduct.lift
(↑LinearMap.lflip ∘ₗ (T... | null | false |
OrderHom.gfp_le_map | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, OrderHom.gfp f ≤ a → OrderHom.gfp f ≤ f a | null | true |
Std.DTreeMap.Internal.Impl.Equiv.getEntryLE_eq._proof_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF →
t₂.WF → t₁.Equiv t₂ → ∀ {k : α} {he : ∃ a ∈ t₁, (compare a k).isLE = true}, ∃ a ∈ t₂, (compare a k).isLE = true | null | false |
BddLat.dualEquiv._proof_1 | Mathlib.Order.Category.BddLat | ∀ {X Y : BddLat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id BddLat).map f)
(BddLat.Iso.mk (OrderIso.dualDual ↑Y.toLat)).hom =
CategoryTheory.CategoryStruct.comp (BddLat.Iso.mk (OrderIso.dualDual ↑X.toLat)).hom
((BddLat.dual.comp BddLat.dual).map f) | null | false |
Lean.instInhabitedLevel | Lean.Level | Inhabited Lean.Level | null | true |
instRingObjOppositeOpensCarrierOfPresheafSmoothSheaf._aux_3 | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_3} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_4} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_5} →
... | null | false |
self_le_mul_right | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {α : Type u} [inst : Mul α] [inst_1 : LE α] [CanonicallyOrderedMul α] (a b : α), a ≤ a * b | null | true |
MulAction.fixedBy_one_eq_univ | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ (α : Type u_1) (M : Type u_3) [inst : Monoid M] [inst_1 : MulAction M α], MulAction.fixedBy α 1 = Set.univ | null | true |
_private.Init.Data.Nat.Div.Lemmas.0.Nat.add_div_of_dvd_add_add_one._proof_1_1 | Init.Data.Nat.Div.Lemmas | ∀ {c : ℕ} {a b : ℕ}, c ≠ 0 → ¬0 < c → False | null | false |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.State.mk.inj | Mathlib.Tactic.GRewrite.Core | ∀ {cache : Std.HashSet (Option Lean.Expr × Lean.Expr × Bool)} {progress : Mathlib.Tactic.GRewrite.Progress✝}
{cache_1 : Std.HashSet (Option Lean.Expr × Lean.Expr × Bool)} {progress_1 : Mathlib.Tactic.GRewrite.Progress✝},
{ cache := cache, progress := progress } = { cache := cache_1, progress := progress_1 } →
c... | null | true |
LipschitzWith.uniformEquicontinuous | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace γ] [inst_1 : PseudoEMetricSpace β]
(f : α → γ → β) (K : NNReal), (∀ (c : α), LipschitzWith K (f c)) → UniformEquicontinuous f | If `f : α → γ → β` is a family of a functions, all of which are Lipschitz with the
same constant, then the family is uniformly equicontinuous. | true |
AlgebraicGeometry.Scheme.IdealSheafData.radical_mul | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData}, (I * J).radical = I.radical ⊓ J.radical | null | true |
FunLike.subNegZeroMonoid._proof_5 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : SMul ℕ F] [inst_2 : SubNegZeroMonoid β]
[IsSMulApply ℕ F α β] (f : F) (n : ℕ), ⇑(n • f) = n • ⇑f | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.