name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
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 | 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) | 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},
AnalyticAt 𝕜 f (u x) → AnalyticAt 𝕜 (f ∘ ⇑u) x | true |
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' | 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.toLinearMap v = w → f.toLinearMap ((ρ g) v) = (σ g) w | 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) | true |
Lean.Parser.levelParser | Lean.Parser.Level | optParam ℕ 0 → Lean.Parser.Parser | 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₂ | false |
Real.binEntropy_le_log_two | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {p : ℝ}, Real.binEntropy p ≤ Real.log 2 | true |
Mathlib.MoveAdd.tacticMove_add_ | Mathlib.Tactic.MoveAdd | Lean.ParserDescr | 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 | false |
Int32.toInt_ofInt_of_le | Init.Data.SInt.Lemmas | ∀ {n : ℤ}, -2 ^ 31 ≤ n → n < 2 ^ 31 → (Int32.ofInt n).toInt = n | 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₂ | 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]! | true |
RelEmbedding.isIrrefl | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ↪r s) [Std.Irrefl s], Std.Irrefl r | true |
isSimpleAddGroup_of_prime_card | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : AddGroup α] {p : ℕ} [hp : Fact (Nat.Prime p)], Nat.card α = p → IsSimpleAddGroup α | true |
Distributions.«_aux_Mathlib_Analysis_Distribution_Distribution___macroRules_Distributions_term𝓓'^{_}(_,_)_1» | Mathlib.Analysis.Distribution.Distribution | Lean.Macro | 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.HasLiftingProperty.transfiniteComposition.sqFunctor c p f g).obj (Opposite.op j))
(this :
∀
(sq :
CategoryTheory.CommSq sq'.f' (F.map (CategoryTheory.homOfLE ⋯)) p
(CategoryTheory.CategoryStruct.comp (c.ι.app (Order.succ j)) g)),
sq.HasLift),
CategoryTheory.CategoryStruct.comp ⋯.lift p =
CategoryTheory.CategoryStruct.comp (c.ι.app (Opposite.unop (Opposite.op (Order.succ j)))) g | 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 :: l => h_4 head head_1 l) =
h_1 () | true |
Hyperreal.infinitePos_add_not_infiniteNeg | Mathlib.Analysis.Real.Hyperreal | ∀ {x y : ℝ*}, x.InfinitePos → ¬y.InfiniteNeg → (x + y).InfinitePos | true |
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.PreservesLimitsOfShape J F | 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 | 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, FirstOrder.Language.BoundedFormula.equal t₁ t₂, f =>
FirstOrder.Language.BoundedFormula.equal (t₁.restrictVarLeft (f ∘ Set.inclusion ⋯))
(t₂.restrictVarLeft (f ∘ Set.inclusion ⋯))
| _n, FirstOrder.Language.BoundedFormula.rel R ts, f =>
FirstOrder.Language.BoundedFormula.rel R fun i => (ts i).restrictVarLeft (f ∘ Set.inclusion ⋯)
| _n, φ₁.imp φ₂, f => (φ₁.restrictFreeVar (f ∘ Set.inclusion ⋯)).imp (φ₂.restrictFreeVar (f ∘ Set.inclusion ⋯))
| _n, φ.all, f => (φ.restrictFreeVar f).all | 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) | true |
Lean.Elab.Do.elabDoHave | Lean.Elab.BuiltinDo.Let | Lean.Elab.Do.DoElab | true |
SSet.Truncated.Path.arrow._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {n : ℕ}, (SimplexCategory.mk 1).len ≤ n + 1 | false |
AddMonCat.adjoinZero.eq_1 | Mathlib.Algebra.Category.MonCat.Adjunctions | AddMonCat.adjoinZero =
{ obj := fun S => AddMonCat.of (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 } | 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 | 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)) | 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] [T2Space A] {a b : A} (ha : p a),
IsSelfAdjoint a → Commute a b → ∀ (f : ContinuousMapZero (↑(quasispectrum 𝕜 a)) 𝕜), Commute ((cfcₙHom ha) f) b | true |
_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 | 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 R D] [inst_11 : Algebra S A]
[inst_12 : Algebra S B] [inst_13 : IsScalarTower R S A] [inst_14 : IsScalarTower R S B] (f : A →ₐ[S] B)
(g : C →ₐ[R] D),
Function.Surjective ⇑f →
Function.Surjective ⇑g →
RingHom.ker (Algebra.TensorProduct.map f g) =
Ideal.map Algebra.TensorProduct.includeLeft (RingHom.ker f) ⊔
Ideal.map Algebra.TensorProduct.includeRight (RingHom.ker g) | true |
Lean.Parser.Tactic.simpAllTraceArgsRest | Init.Tactics | Lean.ParserDescr | true |
_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 | false |
Real.ceil_exp_one_eq_three | Mathlib.Analysis.Complex.ExponentialBounds | ⌈Real.exp 1⌉ = 3 | 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 → ℕ | 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 α β | 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) | false |
_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) | 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 | false |
Lean.Elab.Tactic.Do.State.mk.noConfusion | Lean.Elab.Tactic.Do.VCGen.Basic | {P : Sort u} →
{fuel : Lean.Elab.Tactic.Do.Fuel} →
{simpState : Lean.Meta.Simp.State} →
{invariants vcs : Array Lean.MVarId} →
{fuel' : Lean.Elab.Tactic.Do.Fuel} →
{simpState' : Lean.Meta.Simp.State} →
{invariants' vcs' : Array Lean.MVarId} →
{ fuel := fuel, simpState := simpState, invariants := invariants, vcs := vcs } =
{ fuel := fuel', simpState := simpState', invariants := invariants', vcs := vcs' } →
(fuel = fuel' → simpState = simpState' → invariants = invariants' → vcs = vcs' → P) → P | false |
IsDiscrete.subsingleton_of_isPreirreducible | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsDiscrete s → IsPreirreducible s → s.Subsingleton | 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') ∘ (G.comp F).map f = c.ι (G.obj j) | false |
MvPolynomial.pUnitAlgEquiv._proof_2 | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u_1) [inst : CommSemiring R] (a : R),
MvPolynomial.eval₂ Polynomial.C (fun x => Polynomial.X)
(Polynomial.eval₂ MvPolynomial.C (MvPolynomial.X PUnit.unit) (Polynomial.C a)) =
Polynomial.C a | 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),
DivInvMonoid.zpow (Int.negSucc n) a = (DivInvMonoid.zpow (↑n.succ) a)⁻¹ | 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) ↑(b'.equiv b (Equiv.refl l)) = 1 | 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.index P)] →
[∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D] →
CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ D) (CategoryTheory.Functor Cᵒᵖ D) | 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 | false |
Std.Time.instInhabitedOffsetX.default | Std.Time.Format.Basic | Std.Time.OffsetX | true |
Array.SatisfiesM_foldlM._proof_2 | Batteries.Data.Array.Monadic | ∀ {α : Type u_1} {as : Array α} (i : Fin as.size), ↑i < as.size | 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) →
[inst_4 : CategoryTheory.MonoidalClosed C] →
[inst_5 : CategoryTheory.MonoidalClosed D] →
[CategoryTheory.Limits.PreservesLimitsOfShape
(CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F] →
(A : C) → CategoryTheory.TwoSquare (CategoryTheory.ihom A) F F (CategoryTheory.ihom (F.obj A)) | true |
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 | 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 | 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 φ • μ = MeasureTheory.Measure.comap (⇑φ) μ | true |
Int.cast_neg_natCast._simp_1 | Mathlib.Data.Int.Cast.Field | ∀ {R : Type u_2} [inst : DivisionRing R] (n : ℕ), -↑n = ↑(-↑n) | 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 | 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 | 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 | true |
Lean.DataValue.noConfusion | Lean.Data.KVMap | {P : Sort u} → {t t' : Lean.DataValue} → t = t' → Lean.DataValue.noConfusionType P t t' | 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 | false |
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) | 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 R Q] {h : P → N},
Function.Exact ⇑f ⇑g →
Function.RightInverse h ⇑g →
∀ (p p' : P),
(LinearMap.lTensor Q f).range.mkQ ∘ₗ (TensorProduct.mk R Q N).flip (h (p + p')) =
(LinearMap.lTensor Q f).range.mkQ ∘ₗ (TensorProduct.mk R Q N).flip (h p) +
(LinearMap.lTensor Q f).range.mkQ ∘ₗ (TensorProduct.mk R Q N).flip (h p') | 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 : T) (x : S), x • 0 = 0 | false |
QuasispectrumRestricts.nonUnitalStarAlgHom._proof_12 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {S : Type u_1} [inst : Field S] [inst_1 : TopologicalSpace S] [IsTopologicalRing S], ContinuousAdd S | 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 (P.d 0 1) one →
((n : ℕ) →
(p :
(f : P.X n ⟶ Q.X n) ×'
(f' : P.X (n + 1) ⟶ Q.X (n + 1)) ×'
CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) =
CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f') →
(f'' : P.X (n + 2) ⟶ Q.X (n + 2)) ×'
CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) =
CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f'') →
(P ⟶ Q) | true |
Tropical.instMulOneClassTropical._proof_2 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : AddZeroClass R] (x : Tropical R), x * 1 = x | false |
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 | false |
Lean.Parser.Command.open._regBuiltin.Lean.Parser.Command.openScoped.parenthesizer_59 | Lean.Parser.Command | IO Unit | false |
_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 | true |
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 | true |
Lean.Elab.Tactic.evalSubst._regBuiltin.Lean.Elab.Tactic.evalSubst.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | false |
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.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalClosed.curry' f)
(CategoryTheory.MonoidalClosed.curry' g))
(CategoryTheory.MonoidalClosed.comp X Y Z)) | 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 | 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 μ ≤ ε | 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 ∘ₗ (TensorProduct.mk R M N).compr₂ (TensorProduct.mk R (TensorProduct R M N) P))) ∘ₗ
TensorProduct.lift
(TensorProduct.lift
(↑LinearMap.lflip ∘ₗ (TensorProduct.mk R M P).compr₂ (TensorProduct.mk R (TensorProduct R M P) N))) =
LinearMap.id | false |
OrderHom.gfp_le_map | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, OrderHom.gfp f ≤ a → OrderHom.gfp f ≤ f a | 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 | false |
BddLat.dualEquiv._proof_1 | Mathlib.Order.Category.BddLat | ∀ {X Y : BddLat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id BddLat).map f)
((fun X => BddLat.Iso.mk (OrderIso.dualDual ↑X.toLat)) Y).hom =
CategoryTheory.CategoryStruct.comp ((fun X => BddLat.Iso.mk (OrderIso.dualDual ↑X.toLat)) X).hom
((BddLat.dual.comp BddLat.dual).map f) | false |
Lean.instInhabitedLevel | Lean.Level | Inhabited Lean.Level | true |
self_le_mul_right | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {α : Type u} [inst : Mul α] [inst_1 : LE α] [CanonicallyOrderedMul α] (a b : α), a ≤ a * b | 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 | 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 | false |
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 | true |
AlgebraicGeometry.Scheme.IdealSheafData.radical_mul | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData}, (I * J).radical = I.radical ⊓ J.radical | true |
WithZero.instSemiring._proof_14 | Mathlib.Algebra.Ring.WithZero | ∀ {α : Type u_1} [inst : Semiring α] (n : ℕ), ↑(n + 1) = ↑n + 1 | false |
MaximalFor.not_gt | Mathlib.Order.Minimal | ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] {Q : ι → Prop} {f : ι → α} {i j : ι},
MaximalFor Q f i → Q j → ¬f i < f j | true |
CategoryTheory.MonoidalCategory.DayConvolution.hexagon_reverse | Mathlib.CategoryTheory.Monoidal.DayConvolution.Braided | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.BraidedCategory C]
[inst_4 : CategoryTheory.MonoidalCategory V] [inst_5 : CategoryTheory.BraidedCategory V]
(F G : CategoryTheory.Functor C V)
[inst_6 :
∀ (v : V) (d : C),
CategoryTheory.Limits.PreservesColimitsOfShape
(CategoryTheory.CostructuredArrow (CategoryTheory.MonoidalCategory.tensor C) d)
(CategoryTheory.MonoidalCategory.tensorLeft v)]
[inst_7 :
∀ (v : V) (d : C),
CategoryTheory.Limits.PreservesColimitsOfShape
(CategoryTheory.CostructuredArrow (CategoryTheory.MonoidalCategory.tensor C) d)
(CategoryTheory.MonoidalCategory.tensorRight v)]
(H : CategoryTheory.Functor C V) [inst_8 : CategoryTheory.MonoidalCategory.DayConvolution F G]
[inst_9 : CategoryTheory.MonoidalCategory.DayConvolution G H]
[inst_10 :
CategoryTheory.MonoidalCategory.DayConvolution F (CategoryTheory.MonoidalCategory.DayConvolution.convolution G H)]
[inst_11 :
CategoryTheory.MonoidalCategory.DayConvolution (CategoryTheory.MonoidalCategory.DayConvolution.convolution F G) H]
[inst_12 :
CategoryTheory.MonoidalCategory.DayConvolution H (CategoryTheory.MonoidalCategory.DayConvolution.convolution F G)]
[inst_13 : CategoryTheory.MonoidalCategory.DayConvolution H F]
[inst_14 :
CategoryTheory.MonoidalCategory.DayConvolution (CategoryTheory.MonoidalCategory.DayConvolution.convolution H F) G]
[inst_15 : CategoryTheory.MonoidalCategory.DayConvolution H G]
[inst_16 :
CategoryTheory.MonoidalCategory.DayConvolution F (CategoryTheory.MonoidalCategory.DayConvolution.convolution H G)]
[inst_17 : CategoryTheory.MonoidalCategory.DayConvolution F H]
[inst_18 :
CategoryTheory.MonoidalCategory.DayConvolution (CategoryTheory.MonoidalCategory.DayConvolution.convolution F H) G],
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.DayConvolution.associator F G H).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.DayConvolution.braiding
(CategoryTheory.MonoidalCategory.DayConvolution.convolution F G) H).hom
(CategoryTheory.MonoidalCategory.DayConvolution.associator H F G).inv) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.DayConvolution.map (CategoryTheory.CategoryStruct.id F)
(CategoryTheory.MonoidalCategory.DayConvolution.braiding G H).hom)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.DayConvolution.associator F H G).inv
(CategoryTheory.MonoidalCategory.DayConvolution.map
(CategoryTheory.MonoidalCategory.DayConvolution.braiding F H).hom (CategoryTheory.CategoryStruct.id G))) | true |
Matrix.transposeRingEquiv._proof_2 | Mathlib.Data.Matrix.Basic | ∀ (m : Type u_1) (α : Type u_2) [inst : AddCommMonoid α] (x y : Matrix m m α),
((Matrix.transposeAddEquiv m m α).trans MulOpposite.opAddEquiv).toFun (x + y) =
((Matrix.transposeAddEquiv m m α).trans MulOpposite.opAddEquiv).toFun x +
((Matrix.transposeAddEquiv m m α).trans MulOpposite.opAddEquiv).toFun y | false |
RingCat.Colimits.instRingColimitType._proof_8 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat)
(x y z : RingCat.Colimits.ColimitType F), (x + y) * z = x * z + y * z | false |
Batteries.Tactic.GeneralizeProofs.AContext.depth | Batteries.Tactic.GeneralizeProofs | Batteries.Tactic.GeneralizeProofs.AContext → ℕ | true |
_private.Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2.0.MeasureTheory.inner_condExpL2_eq_inner_fun._simp_1_2 | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2 | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(U : Submodule 𝕜 E) [inst_3 : U.HasOrthogonalProjection] (v : E), ↑(U.orthogonalProjection v) = U.starProjection v | false |
CategoryTheory.MonoidalCategory.tensorIso_def | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y X' Y' : C}
(f : X ≅ Y) (g : X' ≅ Y'),
CategoryTheory.MonoidalCategory.tensorIso f g =
CategoryTheory.MonoidalCategory.whiskerRightIso f X' ≪≫ CategoryTheory.MonoidalCategory.whiskerLeftIso Y g | true |
Mathlib.Tactic.ITauto.Proof.intro | Mathlib.Tactic.ITauto | Lean.Name → Mathlib.Tactic.ITauto.Proof → Mathlib.Tactic.ITauto.Proof | true |
ENNReal.logOrderIso_symm | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLogExp | ENNReal.logOrderIso.symm = EReal.expOrderIso | true |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_left_ne._simp_1_4 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimTargetInfo.expr | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimTargetInfo✝ → Lean.Expr | true |
_private.Mathlib.NumberTheory.Harmonic.Bounds.0.harmonic_le_one_add_log._simp_1_3 | Mathlib.NumberTheory.Harmonic.Bounds | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (n : ℕ), (0 ≤ ↑n) = True | false |
Mathlib.Tactic.FieldSimp.DenomCondition.none.sizeOf_spec | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} {iM : Q(GroupWithZero «$M»)}, sizeOf Mathlib.Tactic.FieldSimp.DenomCondition.none = 1 | true |
CategoryTheory.Functor.Monoidal.ε_η._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | false |
Array.count_pos_iff | Init.Data.Array.Count | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {xs : Array α}, 0 < Array.count a xs ↔ a ∈ xs | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.