name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.JsonRpc.Message._sizeOf_1 | Lean.Data.JsonRpc | Lean.JsonRpc.Message → ℕ |
Cardinal.instMul | Mathlib.SetTheory.Cardinal.Defs | Mul Cardinal.{u} |
RelHom.toOrderHom | Mathlib.Order.Hom.Basic | {α : Type u_2} →
{β : Type u_3} →
[inst : PartialOrder α] → [inst_1 : Preorder β] → ((fun x1 x2 => x1 < x2) →r fun x1 x2 => x1 < x2) → α →o β |
CategoryTheory.OplaxFunctor.mapComp'_comp_mapComp'_whiskerRight_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} {C : Type u₂} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.OplaxFunctor B C) {b₀ b₁ b₂ b₃ : B} (f₀₁ : b₀ ⟶ b₁)
(f₁₂ : b₁ ⟶ b₂) (f₂₃ : b₂ ⟶ b₃) (f₀₂ : b₀ ⟶ b₂) (f₁₃ : b₁ ⟶ b₃) (f : b₀ ⟶ b₃)
(h₀₂ : CategoryTheory.CategoryStruct.comp f₀₁ f₁₂ = f₀₂) (h₁₃ : CategoryTheory.CategoryStruct.comp f₁₂ f₂₃ = f₁₃)
(hf : CategoryTheory.CategoryStruct.comp f₀₂ f₂₃ = f) {Z : F.obj b₀ ⟶ F.obj b₃}
(h : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (F.map f₀₁) (F.map f₁₂)) (F.map f₂₃) ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.mapComp' f₀₂ f₂₃ f ⋯)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (F.mapComp' f₀₁ f₁₂ f₀₂ h₀₂) (F.map f₂₃)) h) =
CategoryTheory.CategoryStruct.comp (F.mapComp' f₀₁ f₁₃ f ⋯)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (F.map f₀₁) (F.mapComp' f₁₂ f₂₃ f₁₃ h₁₃))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f₀₁) (F.map f₁₂) (F.map f₂₃)).inv h)) |
Ideal.image_subset_nonunits_valuationSubring | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_3} [inst : Field K] {A : Subring K} (I : Ideal ↥A),
I ≠ ⊤ → ∃ B, A ≤ B.toSubring ∧ ⇑A.subtype '' ↑I ⊆ ↑B.nonunits |
Subgroup.strictPeriods_le_periods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.strictPeriods ≤ 𝒢.periods |
_private.Lean.Elab.PreDefinition.Structural.Main.0.Lean.Elab.Structural.structuralRecursion.match_3 | Lean.Elab.PreDefinition.Structural.Main | (motive : Option (ℕ × Subarray ℕ) → Sort u_1) →
(x : Option (ℕ × Subarray ℕ)) →
(Unit → motive none) → ((recArgPos : ℕ) → (s' : Subarray ℕ) → motive (some (recArgPos, s'))) → motive x |
Polynomial.trailingDegree_lt_wf | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R], WellFounded fun p q => p.trailingDegree < q.trailingDegree |
MeasureTheory.OuterMeasure.isCaratheodory_iUnion_of_disjoint | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α) {s : ℕ → Set α},
(∀ (i : ℕ), m.IsCaratheodory (s i)) → Pairwise (Function.onFun Disjoint s) → m.IsCaratheodory (⋃ i, s i) |
QuadraticMap.ofPolar._proof_3 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N], SMulCommClass R R N |
RootPairing.chainBotIdx.eq_1 | Mathlib.LinearAlgebra.RootSystem.Chain | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Finite ι] [inst_1 : CommRing R]
[inst_2 : CharZero R] [inst_3 : IsDomain R] [inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : AddCommGroup N]
[inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsCrystallographic] (i j : ι),
RootPairing.chainBotIdx i j = if h : LinearIndependent R ![P.root i, P.root j] then Exists.choose ⋯ else j |
CategoryTheory.ShortComplex.RightHomologyData.opcyclesIso_inv_comp_descOpcycles_assoc | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData) {A : C} (k : S.X₂ ⟶ A)
(hk : CategoryTheory.CategoryStruct.comp S.f k = 0) [inst_2 : S.HasRightHomology] {Z : C} (h_1 : A ⟶ Z),
CategoryTheory.CategoryStruct.comp h.opcyclesIso.inv (CategoryTheory.CategoryStruct.comp (S.descOpcycles k hk) h_1) =
CategoryTheory.CategoryStruct.comp (h.descQ k hk) h_1 |
_private.Mathlib.Topology.LocalAtTarget.0.TopologicalSpace.IsOpenCover.isOpenMap_iff_restrictPreimage._simp_1_1 | Mathlib.Topology.LocalAtTarget | ∀ {α : Sort u_1} {p : α → Prop} {a b : Subtype p}, (a = b) = (↑a = ↑b) |
Rat.num_le_denom_iff | Mathlib.Algebra.Order.Ring.Unbundled.Rat | ∀ {q : ℚ}, q.num ≤ ↑q.den ↔ q ≤ 1 |
Function.Periodic.contDiff_qParam | Mathlib.Analysis.Complex.Periodic | ∀ {h : ℝ} (m : WithTop ℕ∞), ContDiff ℂ m (Function.Periodic.qParam h) |
MonCat.adjoinOneAdj._proof_1 | Mathlib.Algebra.Category.MonCat.Adjunctions | ∀ {X' X : Semigrp} {Y : MonCat} (f : X' ⟶ X) (g : X ⟶ (CategoryTheory.forget₂ MonCat Semigrp).obj Y),
(CategoryTheory.ConcreteCategory.homEquiv.trans
(WithOne.lift.symm.trans CategoryTheory.ConcreteCategory.homEquiv.symm)).symm
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (MonCat.adjoinOne.map f)
((CategoryTheory.ConcreteCategory.homEquiv.trans
(WithOne.lift.symm.trans CategoryTheory.ConcreteCategory.homEquiv.symm)).symm
g) |
Subalgebra.coe_unop | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R Aᵐᵒᵖ), ↑S.unop = MulOpposite.op ⁻¹' ↑S |
ENNReal.mul_div_right_comm | Mathlib.Data.ENNReal.Inv | ∀ {a b c : ENNReal}, a * b / c = a / c * b |
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.collectJpCasesInfo.match_1 | Lean.Compiler.LCNF.Simp.JpCases | (motive : Unit × Lean.Compiler.LCNF.Simp.JpCasesInfoMap → Sort u_1) →
(__discr : Unit × Lean.Compiler.LCNF.Simp.JpCasesInfoMap) →
((fst : Unit) → (s : Lean.Compiler.LCNF.Simp.JpCasesInfoMap) → motive (fst, s)) → motive __discr |
Real.instDistribLattice._proof_4 | Mathlib.Data.Real.Basic | ∀ (a b c : ℝ), a ≤ c → b ≤ c → max a b ≤ c |
Std.Time.Minute.instOrdOffset | Std.Time.Time.Unit.Minute | Ord Std.Time.Minute.Offset |
MonovaryOn.of_neg_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn (-f) g s → AntivaryOn f g s |
CategoryTheory.Functor.kernel | Mathlib.CategoryTheory.ObjectProperty.ContainsZero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} D] → CategoryTheory.Functor C D → CategoryTheory.ObjectProperty C |
WithLp.uniformEquiv_unitization_addEquiv_prod._proof_2 | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | ∀ (𝕜 : Type u_1) (A : Type u_2) [inst : NormedField 𝕜] [inst_1 : NonUnitalNormedRing A] [inst_2 : NormedSpace 𝕜 A],
UniformContinuous (WithLp.unitization_addEquiv_prod 𝕜 A).invFun |
Substring.Raw.Internal.get | Init.Data.String.Bootstrap | Substring.Raw → String.Pos.Raw → Char |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.natAbs_fdiv_le_natAbs._proof_1_4 | Init.Data.Int.DivMod.Lemmas | ∀ (b : ℤ) (a b : ℕ), ¬0 < a + 1 → False |
signedDist._proof_3 | Mathlib.Geometry.Euclidean.SignedDist | SMulCommClass ℝ ℝ ℝ |
Dynamics.coverEntropyInf_image_of_comap | Mathlib.Dynamics.TopologicalEntropy.Semiconj | ∀ {X : Type u_1} {Y : Type u_2} (u : UniformSpace Y) {S : X → X} {T : Y → Y} {φ : X → Y},
Function.Semiconj φ S T → ∀ (F : Set X), Dynamics.coverEntropyInf T (φ '' F) = Dynamics.coverEntropyInf S F |
Lists'.rec.eq._@.Mathlib.SetTheory.Lists.1973585389._hygCtx._hyg.4 | Mathlib.SetTheory.Lists | @Lists'.rec = @Lists'.rec✝ |
instOrOpInt8 | Init.Data.SInt.Basic | OrOp Int8 |
_private.Init.Data.UInt.Bitwise.0.UInt32.xor_not._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) |
Lean.Parser.Term.dbgTrace._regBuiltin.Lean.Parser.Term.dbgTrace_1 | Lean.Parser.Term | IO Unit |
Lean.Level.mvar.inj | Lean.Level | ∀ {a a_1 : Lean.LMVarId}, Lean.Level.mvar a = Lean.Level.mvar a_1 → a = a_1 |
CategoryTheory.yonedaMonFullyFaithful._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N : CategoryTheory.Mon C} (α : CategoryTheory.yonedaMon.obj M ⟶ CategoryTheory.yonedaMon.obj N),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one
((CategoryTheory.ConcreteCategory.hom (α.app (Opposite.op M.X))) (CategoryTheory.CategoryStruct.id M.X)) =
CategoryTheory.MonObj.one |
TwoSidedIdeal.subtype_injective | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] (I : TwoSidedIdeal R), Function.Injective ⇑I.subtype |
_private.Init.Data.Vector.Algebra.0.Vector.zero_hmul._proof_1_2 | Init.Data.Vector.Algebra | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {n : ℕ} [inst : Zero α] [inst_1 : Zero γ] [inst_2 : HMul α β γ],
(∀ (c : β), 0 * c = 0) → ∀ (c : Vector β n), 0 * c = 0 |
SimpleGraph.Subgraph.instMin._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G₁ G₂ : G.Subgraph) {v w : V},
G₁.Adj v w ∧ G₂.Adj v w → v ∈ G₁.verts ∧ v ∈ G₂.verts |
LinearOrderedCommGroupWithZero.zpow_succ' | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_3} [self : LinearOrderedCommGroupWithZero α] (n : ℕ) (a : α),
LinearOrderedCommGroupWithZero.zpow (↑n.succ) a = LinearOrderedCommGroupWithZero.zpow (↑n) a * a |
_private.Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic.0.Path.Homotopic.Quotient.symm_trans._simp_1_4 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ : X} {p q : Path x₀ x₁},
(Path.Homotopic.Quotient.mk p = Path.Homotopic.Quotient.mk q) = p.Homotopic q |
instRankConditionMulOpposite | Mathlib.LinearAlgebra.Matrix.InvariantBasisNumber | ∀ {R : Type u_1} [inst : Semiring R] [RankCondition R], RankCondition Rᵐᵒᵖ |
CategoryTheory.ShortComplex.Exact.isZero_of_both_zeros | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C}, S.Exact → S.f = 0 → S.g = 0 → CategoryTheory.Limits.IsZero S.X₂ |
AddMonoidHom.compLeftContinuousBounded._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {β : Type u_2} {γ : Type u_3} (α : Type u_1) [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
[inst_2 : AddMonoid β] [inst_3 : BoundedAdd β] [inst_4 : ContinuousAdd β] [inst_5 : PseudoMetricSpace γ]
[inst_6 : AddMonoid γ] [inst_7 : BoundedAdd γ] [inst_8 : ContinuousAdd γ] (g : β →+ γ) {C : NNReal}
(hg : LipschitzWith C ⇑g) (x x_1 : BoundedContinuousFunction α β),
BoundedContinuousFunction.comp (⇑g) hg (x + x_1) =
BoundedContinuousFunction.comp (⇑g) hg x + BoundedContinuousFunction.comp (⇑g) hg x_1 |
Std.ExtTreeMap.maxKey?_le | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
(∀ (k' : α), t.maxKey? = some k' → (cmp k' k).isLE = true) ↔ ∀ k' ∈ t, (cmp k' k).isLE = true |
CategoryTheory.ComposableArrows.Exact.exact'._auto_3 | Mathlib.Algebra.Homology.ExactSequence | Lean.Syntax |
_private.Lean.Expr.0.Lean.instReprExpr.repr.match_1 | Lean.Expr | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((a : ℕ) → motive (Lean.Expr.bvar a)) →
((a : Lean.FVarId) → motive (Lean.Expr.fvar a)) →
((a : Lean.MVarId) → motive (Lean.Expr.mvar a)) →
((a : Lean.Level) → motive (Lean.Expr.sort a)) →
((a : Lean.Name) → (a_1 : List Lean.Level) → motive (Lean.Expr.const a a_1)) →
((a a_1 : Lean.Expr) → motive (a.app a_1)) →
((a : Lean.Name) →
(a_1 a_2 : Lean.Expr) → (a_3 : Lean.BinderInfo) → motive (Lean.Expr.lam a a_1 a_2 a_3)) →
((a : Lean.Name) →
(a_1 a_2 : Lean.Expr) → (a_3 : Lean.BinderInfo) → motive (Lean.Expr.forallE a a_1 a_2 a_3)) →
((a : Lean.Name) →
(a_1 a_2 a_3 : Lean.Expr) → (a_4 : Bool) → motive (Lean.Expr.letE a a_1 a_2 a_3 a_4)) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((a : Lean.MData) → (a_1 : Lean.Expr) → motive (Lean.Expr.mdata a a_1)) →
((a : Lean.Name) → (a_1 : ℕ) → (a_2 : Lean.Expr) → motive (Lean.Expr.proj a a_1 a_2)) →
motive x |
normFromBounded._proof_1 | Mathlib.Analysis.Normed.Unbundled.SeminormFromBounded | ∀ {R : Type u_1} [inst : CommRing R] {f : R → ℝ} {c : ℝ} (f_zero : f 0 = 0) (f_nonneg : 0 ≤ f)
(f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y) (f_add : ∀ (a b : R), f (a + b) ≤ f a + f b)
(f_neg : ∀ (x : R), f (-x) = f x),
f ⁻¹' {0} = {0} → ∀ (x : R), (seminormFromBounded f_zero f_nonneg f_mul f_add f_neg).toFun x = 0 → x = 0 |
MulOpposite.coe_opLinearEquiv_addEquiv | Mathlib.Algebra.Module.Equiv.Opposite | ∀ (R : Type u) {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
↑(MulOpposite.opLinearEquiv R) = MulOpposite.opAddEquiv |
ValuativeRel.zero_vlt_coe_posSubmonoid | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (x : ↥(ValuativeRel.posSubmonoid R)), 0 <ᵥ ↑x |
Int8.toInt_ofIntLE | Init.Data.SInt.Lemmas | ∀ {x : ℤ} {h₁ : Int8.minValue.toInt ≤ x} {h₂ : x ≤ Int8.maxValue.toInt}, (Int8.ofIntLE x h₁ h₂).toInt = x |
contDiffWithinAt_succ_iff_hasFDerivWithinAt | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : WithTop ℕ∞},
n ≠ ↑⊤ →
(ContDiffWithinAt 𝕜 (n + 1) f s x ↔
∃ u ∈ nhdsWithin x (insert x s),
(n = ⊤ → AnalyticOn 𝕜 f u) ∧ ∃ f', (∀ x ∈ u, HasFDerivWithinAt f (f' x) u x) ∧ ContDiffWithinAt 𝕜 n f' u x) |
PerfectRing.lift_self | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} [inst : CommRing K] [inst_1 : CommRing L] (i : K →+* L) (p : ℕ) [inst_2 : ExpChar K p]
[inst_3 : IsPRadical i p] [inst_4 : ExpChar L p] [inst_5 : PerfectRing L p], PerfectRing.lift i i p = RingHom.id L |
interior_Iic' | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α},
(Set.Ioi a).Nonempty → interior (Set.Iic a) = Set.Iio a |
_private.Mathlib.LinearAlgebra.CliffordAlgebra.Even.0.CliffordAlgebra.even.lift.fFold | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q : QuadraticForm R M} →
{A : Type u_3} →
[inst_3 : Ring A] →
[inst_4 : Algebra R A] →
(f : CliffordAlgebra.EvenHom Q A) →
M →ₗ[R] A × ↥(CliffordAlgebra.even.lift.S✝ f) →ₗ[R] A × ↥(CliffordAlgebra.even.lift.S✝¹ f) |
Aesop.CtorNames.mk.noConfusion | Aesop.Script.CtorNames | {P : Sort u} →
{ctor : Lean.Name} →
{args : Array Lean.Name} →
{hasImplicitArg : Bool} →
{ctor' : Lean.Name} →
{args' : Array Lean.Name} →
{hasImplicitArg' : Bool} →
{ ctor := ctor, args := args, hasImplicitArg := hasImplicitArg } =
{ ctor := ctor', args := args', hasImplicitArg := hasImplicitArg' } →
(ctor = ctor' → args = args' → hasImplicitArg = hasImplicitArg' → P) → P |
ContinuousMap.Homotopic.prodMap | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} {Z : Type w} {Z' : Type x} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace Z'] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(Z, Z')},
f₀.Homotopic f₁ → g₀.Homotopic g₁ → (f₀.prodMap g₀).Homotopic (f₁.prodMap g₁) |
Std.DHashMap.Internal.Raw₀.Const.getKey?_insertManyIfNewUnit_list_of_contains_eq_false_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Internal.Raw₀ α fun x => Unit) [EquivBEq α]
[LawfulHashable α],
(↑m).WF →
∀ {l : List α} {k k' : α},
(k == k') = true →
m.contains k = false →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit m l)).getKey? k' = some k |
selfAdjoint.instCommRingSubtypeMemAddSubgroup._proof_7 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), ↑(x * y) = ↑x * ↑y |
Equiv.addMonoidWithOne._proof_1 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : AddMonoidWithOne β], e (e.symm ↑0) = e 0 |
Array.toListRev_iter | Std.Data.Iterators.Lemmas.Producers.Array | ∀ {β : Type w} {array : Array β}, array.iter.toListRev = array.toListRev |
Lean.Compiler.LCNF.anyFVarM | Lean.Compiler.LCNF.FVarUtil | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.Compiler.LCNF.TraverseFVar α] → (Lean.FVarId → m Bool) → α → m Bool |
Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty.noConfusion | Mathlib.Tactic.NormNum.BigOperators | {u : Lean.Level} →
{α : Q(Type u)} →
{s : Q(Finset «$α»)} →
{P : Sort u} →
{pf pf' : Q(«$s» = ∅)} →
Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty pf = Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty pf' →
(pf = pf' → P) → P |
IntermediateField.finrank_dvd_of_le_left | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{F E : IntermediateField K L}, F ≤ E → Module.finrank (↥E) L ∣ Module.finrank (↥F) L |
Set.Ici.boundedOrder | Mathlib.Order.LatticeIntervals | {α : Type u_1} → [inst : Preorder α] → [OrderTop α] → {a : α} → BoundedOrder ↑(Set.Ici a) |
CategoryTheory.Functor.PullbackObjObj.π_iso_of_iso_left_hom | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ f₁' : CategoryTheory.Arrow C₁}
{f₃ : CategoryTheory.Arrow C₃} (sq₁₃ : G.PullbackObjObj f₁.hom f₃.hom) (sq₁₃' : G.PullbackObjObj f₁'.hom f₃.hom)
(iso : f₁ ≅ f₁'), (sq₁₃.π_iso_of_iso_left sq₁₃' iso).hom = sq₁₃.mapArrowLeft sq₁₃' iso.inv |
Std.HashSet.getD_ofList_of_mem | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List α} {k k' fallback : α},
(k == k') = true → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (Std.HashSet.ofList l).getD k' fallback = k |
CategoryTheory.Limits.colimMap_eq | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimitsOfShape J C]
{G : CategoryTheory.Functor J C} (α : F ⟶ G), CategoryTheory.Limits.colimMap α = CategoryTheory.Limits.colim.map α |
InverseSystem.pEquivOnGlue._proof_5 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} {F : ι → Type u_3} {X : ι → Type u_2} {i : ι} [inst : LinearOrder ι]
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} [inst_1 : SuccOrder ι]
{equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} [inst_2 : WellFoundedLT ι]
(hi : Order.IsSuccPrelimit i) (e : (j : ↑(Set.Iio i)) → InverseSystem.PEquivOn f equivSucc (Set.Iic ↑j)) {i_1 : ι}
(hj : Order.succ i_1 ∈ Set.Iio i) (hi_1 : ¬IsMax i_1) (x : F ↑⟨Order.succ i_1, hj⟩),
((InverseSystem.piLTLim hi).symm ⟨fun j => ((e j).restrict ⋯).equiv, ⋯⟩ ⟨Order.succ i_1, hj⟩) x ⟨i_1, ⋯⟩ =
((equivSucc hi_1) x).2 |
Sublattice.coe_sup._simp_1 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L : Sublattice α} (a b : ↥L), ↑a ⊔ ↑b = ↑(a ⊔ b) |
_private.Lean.Elab.InfoTree.Main.0.Lean.Elab.formatStxRange.match_1 | Lean.Elab.InfoTree.Main | (motive : Lean.SourceInfo → Sort u_1) →
(info : Lean.SourceInfo) →
((leading : Substring.Raw) →
(pos : String.Pos.Raw) →
(trailing : Substring.Raw) →
(endPos : String.Pos.Raw) → motive (Lean.SourceInfo.original leading pos trailing endPos)) →
((pos endPos : String.Pos.Raw) → motive (Lean.SourceInfo.synthetic pos endPos true)) →
((x : Lean.SourceInfo) → motive x) → motive info |
Std.Time.Formats.leanDateTimeWithIdentifier | Std.Time.Format | Std.Time.GenericFormat Std.Time.Awareness.any |
Submonoid.coe_mul_self_eq | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {M : Type u_3} [inst : Monoid M] (s : Submonoid M), ↑s * ↑s = ↑s |
LinearMap.curry_uncurryLeft | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂]
(f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂), f.uncurryLeft.curryLeft = f |
FractionalIdeal.num_zero_eq | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P],
Function.Injective ⇑(algebraMap R P) → FractionalIdeal.num 0 = 0 |
smoothingFun_nonneg | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {R : Type u_1} [inst : CommRing R] (μ : RingSeminorm R), μ 1 ≤ 1 → ∀ (x : R), 0 ≤ smoothingFun μ x |
Lean.Parser.Term.doReassignArrow._regBuiltin.Lean.Parser.Term.doReassignArrow.formatter_7 | Lean.Parser.Do | IO Unit |
RingEquiv.sumArrowEquivProdArrow_apply | Mathlib.Algebra.Ring.Equiv | ∀ {α : Type u_2} {β : Type u_3} {R : Type u_4} [inst : NonAssocSemiring R] (x : α ⊕ β → R),
(RingEquiv.sumArrowEquivProdArrow α β R) x = (Equiv.sumArrowEquivProdArrow α β R) x |
AlgEquiv.prodUnique._proof_1 | Mathlib.Algebra.Algebra.Prod | ∀ {A : Type u_1} {B : Type u_2} [inst : Semiring A] [inst_1 : Semiring B] [inst_2 : Unique B],
Function.LeftInverse (RingEquiv.prodZeroRing A B).symm.invFun (RingEquiv.prodZeroRing A B).symm.toFun |
Mathlib.Tactic.TautoSet.specialize_all | Mathlib.Tactic.TautoSet | Lean.ParserDescr |
CategoryTheory.Functor.LaxLeftLinear.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D'] →
{F : CategoryTheory.Functor D D'} →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.MonoidalCategory C] →
[inst_4 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] →
[inst_5 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D'] →
(μₗ :
(c : C) →
(d : D) →
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj c (F.obj d) ⟶
F.obj (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj c d)) →
autoParam
(∀ {c c' : C} (f : c ⟶ c') (d : D),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomLeft f (F.obj d))
(μₗ c' d) =
CategoryTheory.CategoryStruct.comp (μₗ c d)
(F.map (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomLeft f d)))
CategoryTheory.Functor.LaxLeftLinear.μₗ_naturality_left._autoParam →
autoParam
(∀ (c : C) {d d' : D} (f : d ⟶ d'),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight c (F.map f))
(μₗ c d') =
CategoryTheory.CategoryStruct.comp (μₗ c d)
(F.map (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight c f)))
CategoryTheory.Functor.LaxLeftLinear.μₗ_naturality_right._autoParam →
autoParam
(∀ (c c' : C) (d : D),
CategoryTheory.CategoryStruct.comp
(μₗ (CategoryTheory.MonoidalCategoryStruct.tensorObj c c') d)
(F.map
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionAssocIso c c'
d).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionAssocIso c c'
(F.obj d)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight c
(μₗ c' d))
(μₗ c (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj c' d))))
CategoryTheory.Functor.LaxLeftLinear.μₗ_associativity._autoParam →
autoParam
(∀ (d : D),
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso
(F.obj d)).hom =
CategoryTheory.CategoryStruct.comp
(μₗ (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) d)
(F.map
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso d).hom))
CategoryTheory.Functor.LaxLeftLinear.μₗ_unitality._autoParam →
F.LaxLeftLinear C |
instCoeTCMulEquivOfMulEquivClass.eq_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : EquivLike F α β] [inst_1 : Mul α] [inst_2 : Mul β]
[inst_3 : MulEquivClass F α β], instCoeTCMulEquivOfMulEquivClass = { coe := MulEquivClass.toMulEquiv } |
Std.Time.Day.Ordinal.ofNat._auto_1 | Std.Time.Date.Unit.Day | Lean.Syntax |
CategoryTheory.Cat.Hom.isoMk_inv | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Category.{v, u} D]
{F G : CategoryTheory.Functor C D} (e : F ≅ G),
(CategoryTheory.Cat.Hom.isoMk e).inv = CategoryTheory.NatTrans.toCatHom₂ e.inv |
CommRingCat.forget₂Ring_preservesLimits | Mathlib.Algebra.Category.Ring.Limits | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommRingCat RingCat) |
eq_zero_of_neg_eq | Mathlib.Algebra.Order.Group.Defs | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] {a : α}, -a = a → a = 0 |
Besicovitch.exists_goodδ | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E],
∃ δ,
0 < δ ∧
δ < 1 ∧
∀ (s : Finset E),
(∀ c ∈ s, ‖c‖ ≤ 2) → (∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 - δ ≤ ‖c - d‖) → s.card ≤ Besicovitch.multiplicity E |
CompleteOrthogonalIdempotents.ringEquivOfIsMulCentral._proof_2 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {I : Type u_2} [inst : Fintype I] {e : I → R} [inst_1 : Semiring R]
(he : CompleteOrthogonalIdempotents e),
(∀ (i : I), IsMulCentral (e i)) →
∀ (r : R), (fun r => ∑ i, ↑(r i)) ((fun r i => ⟨(fun x => e i * x * e i) r, ⋯⟩) r) = r |
_private.Mathlib.Tactic.DepRewrite.0.Lean.MVarId.depRewrite.match_3 | Mathlib.Tactic.DepRewrite | (motive : Lean.Expr → Sort u_1) →
(eAbst : Lean.Expr) →
((binderName : Lean.Name) →
(binderType : Lean.Expr) →
(binderName_1 : Lean.Name) →
(binderType_1 eBody : Lean.Expr) →
(binderInfo binderInfo_1 : Lean.BinderInfo) →
motive
(Lean.Expr.lam binderName binderType (Lean.Expr.lam binderName_1 binderType_1 eBody binderInfo)
binderInfo_1)) →
((x : Lean.Expr) → motive x) → motive eAbst |
RingCon.ringConGen_eq | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R] (r : R → R → Prop),
ringConGen r = sInf {s | ∀ (x y : R), r x y → s x y} |
AddGroupSeminorm.map_zero' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {G : Type u_6} [inst : AddGroup G] (self : AddGroupSeminorm G), self.toFun 0 = 0 |
CompleteLatticeHom._sizeOf_1 | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
{inst : CompleteLattice α} → {inst_1 : CompleteLattice β} → [SizeOf α] → [SizeOf β] → CompleteLatticeHom α β → ℕ |
NonUnitalSubsemiring.instBot._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {a b : R}, a ∈ {0} → b ∈ {0} → a * b ∈ {0} |
Finmap.union.eq_1 | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s₁ s₂ : Finmap β),
s₁.union s₂ = s₁.liftOn₂ s₂ (fun s₁ s₂ => (s₁ ∪ s₂).toFinmap) ⋯ |
instRingCorner._proof_14 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalRing R] (idem : IsIdempotentElem e) (n : ℕ) (x : idem.Corner),
Semiring.npow (n + 1) x = Semiring.npow n x * x |
IncidenceAlgebra.instRing._proof_6 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : Ring 𝕜] (n : ℕ) (a : IncidenceAlgebra 𝕜 α),
SubNegMonoid.zsmul (Int.negSucc n) a = -SubNegMonoid.zsmul (↑n.succ) a |
SSet.RelativeMorphism.ofSimplex₀._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y : SSet} (f : X ⟶ Y) (x : X.obj (Opposite.op (SimplexCategory.mk 0)))
(y : Y.obj (Opposite.op (SimplexCategory.mk 0))),
f.app (Opposite.op (SimplexCategory.mk 0)) x = y →
CategoryTheory.CategoryStruct.comp (SSet.Subcomplex.ofSimplex x).ι f =
CategoryTheory.CategoryStruct.comp (SSet.const ⟨y, ⋯⟩) (SSet.Subcomplex.ofSimplex y).ι |
DFinsupp.hasAdd₂ | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{α : ι → Type u_2} →
{δ : (i : ι) → α i → Type v} →
[inst : (i : ι) → (j : α i) → AddZeroClass (δ i j)] → Add (Π₀ (i : ι) (j : α i), δ i j) |
_private.Init.Data.List.Find.0.List.head_flatten._simp_1_1 | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {xs : List α} (h : xs ≠ []), (xs.head h = a) = (xs.head? = some a) |
Sum.not_inr_le_inl._simp_1 | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a : α} {b : β}, (Sum.inr b ≤ Sum.inl a) = False |
CategoryTheory.op_epi_iff | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Epi f.op ↔ CategoryTheory.Mono f |
LLVM.DLLStorageClass | Lean.Compiler.IR.LLVMBindings | Type |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.