name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Lean.Compiler.LCNF.JoinPointCommonArgs.AnalysisCtx._sizeOf_inst
|
Lean.Compiler.LCNF.JoinPoints
|
SizeOf Lean.Compiler.LCNF.JoinPointCommonArgs.AnalysisCtx
|
CompositionSeries.Equivalent.trans
|
Mathlib.Order.JordanHolder
|
∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] {s₁ s₂ s₃ : CompositionSeries X},
s₁.Equivalent s₂ → s₂.Equivalent s₃ → s₁.Equivalent s₃
|
Filter.EventuallyLE.rfl
|
Mathlib.Order.Filter.Basic
|
∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {f : α → β}, f ≤ᶠ[l] f
|
_private.Lean.Compiler.Old.0.Lean.Compiler.getDeclNamesForCodeGen.match_1
|
Lean.Compiler.Old
|
(motive : Lean.Declaration → Sort u_1) →
(x : Lean.Declaration) →
((name : Lean.Name) →
(levelParams : List Lean.Name) →
(type value : Lean.Expr) →
(hints : Lean.ReducibilityHints) →
(safety : Lean.DefinitionSafety) →
(all : List Lean.Name) →
motive
(Lean.Declaration.defnDecl
{ name := name, levelParams := levelParams, type := type, value := value, hints := hints,
safety := safety, all := all })) →
((name : Lean.Name) →
(levelParams : List Lean.Name) →
(type value : Lean.Expr) →
(isUnsafe : Bool) →
(all : List Lean.Name) →
motive
(Lean.Declaration.opaqueDecl
{ name := name, levelParams := levelParams, type := type, value := value, isUnsafe := isUnsafe,
all := all })) →
((name : Lean.Name) →
(levelParams : List Lean.Name) →
(type : Lean.Expr) →
(isUnsafe : Bool) →
motive
(Lean.Declaration.axiomDecl
{ name := name, levelParams := levelParams, type := type, isUnsafe := isUnsafe })) →
((defs : List Lean.DefinitionVal) → motive (Lean.Declaration.mutualDefnDecl defs)) →
((x : Lean.Declaration) → motive x) → motive x
|
IsCoprime.mono
|
Mathlib.RingTheory.Coprime.Basic
|
∀ {R : Type u} [inst : CommSemiring R] {x y z w : R}, x ∣ y → z ∣ w → IsCoprime y w → IsCoprime x z
|
_private.Mathlib.Algebra.Module.Presentation.Tensor.0.Module.Relations.tensor.match_1.eq_1
|
Mathlib.Algebra.Module.Presentation.Tensor
|
∀ {A : Type u_5} [inst : CommRing A] (relations₁ : Module.Relations A) (relations₂ : Module.Relations A)
(motive : relations₁.R × relations₂.G ⊕ relations₁.G × relations₂.R → Sort u_6) (r₁ : relations₁.R)
(g₂ : relations₂.G) (h_1 : (r₁ : relations₁.R) → (g₂ : relations₂.G) → motive (Sum.inl (r₁, g₂)))
(h_2 : (g₁ : relations₁.G) → (r₂ : relations₂.R) → motive (Sum.inr (g₁, r₂))),
(match Sum.inl (r₁, g₂) with
| Sum.inl (r₁, g₂) => h_1 r₁ g₂
| Sum.inr (g₁, r₂) => h_2 g₁ r₂) =
h_1 r₁ g₂
|
LinearMap.baseChange_comp
|
Mathlib.LinearAlgebra.TensorProduct.Tower
|
∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid N]
[inst_5 : AddCommMonoid P] [inst_6 : Module R M] [inst_7 : Module R N] [inst_8 : Module R P] (f : M →ₗ[R] N)
(g : N →ₗ[R] P), LinearMap.baseChange A (g ∘ₗ f) = LinearMap.baseChange A g ∘ₗ LinearMap.baseChange A f
|
IsSl2Triple
|
Mathlib.Algebra.Lie.Sl2
|
{L : Type u_2} → [LieRing L] → L → L → L → Prop
|
SSet.PtSimplex.MulStruct.ctorIdx
|
Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct
|
{X : SSet} →
{n : ℕ} →
{x : X.obj (Opposite.op (SimplexCategory.mk 0))} → {f g fg : X.PtSimplex n x} → {i : Fin n} → f.MulStruct g fg i → ℕ
|
UInt32.ofBitVec_add
|
Init.Data.UInt.Lemmas
|
∀ (a b : BitVec 32), { toBitVec := a + b } = { toBitVec := a } + { toBitVec := b }
|
bddAbove_range_mul
|
Mathlib.Algebra.Order.GroupWithZero.Bounds
|
∀ {α : Type u_1} {β : Type u_2} [Nonempty α] {u v : α → β} [inst : Preorder β] [inst_1 : Zero β] [inst_2 : Mul β]
[PosMulMono β] [MulPosMono β],
BddAbove (Set.range u) → 0 ≤ u → BddAbove (Set.range v) → 0 ≤ v → BddAbove (Set.range (u * v))
|
Complex.tendsto_norm_tan_of_cos_eq_zero
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.ComplexDeriv
|
∀ {x : ℂ}, Complex.cos x = 0 → Filter.Tendsto (fun x => ‖Complex.tan x‖) (nhdsWithin x {x}ᶜ) Filter.atTop
|
_private.Mathlib.Algebra.Group.Semiconj.Defs.0.SemiconjBy.transitive.match_1_1
|
Mathlib.Algebra.Group.Semiconj.Defs
|
∀ {S : Type u_1} [inst : Semigroup S]
(motive : (x x_1 x_2 : S) → (∃ c, SemiconjBy c x x_1) → (∃ c, SemiconjBy c x_1 x_2) → Prop) (x x_1 x_2 : S)
(x_3 : ∃ c, SemiconjBy c x x_1) (x_4 : ∃ c, SemiconjBy c x_1 x_2),
(∀ (x x_5 x_6 x_7 : S) (hx : SemiconjBy x_7 x x_5) (y : S) (hy : SemiconjBy y x_5 x_6), motive x x_5 x_6 ⋯ ⋯) →
motive x x_1 x_2 x_3 x_4
|
Subtype.t0Space
|
Mathlib.Topology.Separation.Basic
|
∀ {X : Type u_1} [inst : TopologicalSpace X] [T0Space X] {p : X → Prop}, T0Space (Subtype p)
|
groupHomology.cycles₁IsoOfIsTrivial.eq_1
|
Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree
|
∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G) [inst_2 : A.IsTrivial],
groupHomology.cycles₁IsoOfIsTrivial A = (LinearEquiv.ofTop (groupHomology.cycles₁ A) ⋯).toModuleIso
|
Matroid.subsingleton_indep._auto_1
|
Mathlib.Combinatorics.Matroid.Loop
|
Lean.Syntax
|
InfHom.withBot_toFun
|
Mathlib.Order.Hom.WithTopBot
|
∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] (f : InfHom α β) (a : WithBot α),
f.withBot a = WithBot.map (⇑f) a
|
CategoryTheory.normalOfIsPushoutSndOfNormal._proof_4
|
Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic
|
∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S} [gn : CategoryTheory.NormalEpi g]
(comm : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k)
(t : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.PushoutCocone.mk h k comm)),
0 = CategoryTheory.CategoryStruct.comp 0 f →
CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ h ⋯) =
CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofork.ofπ h ⋯)
|
Std.TreeSet.Raw.max?_eq_none_iff._simp_1
|
Std.Data.TreeSet.Raw.Lemmas
|
∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → (t.max? = none) = (t.isEmpty = true)
|
two_mul_le_add_mul_sq
|
Mathlib.Algebra.Order.Field.Basic
|
∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a b ε : α},
0 < ε → 2 * a * b ≤ ε * a ^ 2 + ε⁻¹ * b ^ 2
|
CategoryTheory.Limits.IsImage.instInhabitedSelf
|
Mathlib.CategoryTheory.Limits.Shapes.Images
|
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_1 : CategoryTheory.Mono f] →
Inhabited (CategoryTheory.Limits.IsImage (CategoryTheory.Limits.MonoFactorisation.self f))
|
Lean.Elab.Command.ComputedFieldView.mk.injEq
|
Lean.Elab.MutualInductive
|
∀ (ref modifiers : Lean.Syntax) (fieldId : Lean.Name) (type : Lean.Term)
(matchAlts : Lean.TSyntax `Lean.Parser.Term.matchAlts) (ref_1 modifiers_1 : Lean.Syntax) (fieldId_1 : Lean.Name)
(type_1 : Lean.Term) (matchAlts_1 : Lean.TSyntax `Lean.Parser.Term.matchAlts),
({ ref := ref, modifiers := modifiers, fieldId := fieldId, type := type, matchAlts := matchAlts } =
{ ref := ref_1, modifiers := modifiers_1, fieldId := fieldId_1, type := type_1, matchAlts := matchAlts_1 }) =
(ref = ref_1 ∧ modifiers = modifiers_1 ∧ fieldId = fieldId_1 ∧ type = type_1 ∧ matchAlts = matchAlts_1)
|
Std.DTreeMap.Internal.Const.RoiSliceData.noConfusionType
|
Std.Data.DTreeMap.Internal.Zipper
|
Sort u_1 →
{α : Type u} →
{β : Type v} →
[inst : Ord α] →
Std.DTreeMap.Internal.Const.RoiSliceData α β →
{α' : Type u} → {β' : Type v} → [inst' : Ord α'] → Std.DTreeMap.Internal.Const.RoiSliceData α' β' → Sort u_1
|
Set.insert_diff_subset
|
Mathlib.Order.BooleanAlgebra.Set
|
∀ {α : Type u_1} {s t : Set α} {a : α}, insert a s \ t ⊆ insert a (s \ t)
|
MulRingSeminormClass
|
Mathlib.Algebra.Order.Hom.Basic
|
(F : Type u_7) →
(α : outParam (Type u_8)) →
(β : outParam (Type u_9)) → [NonAssocRing α] → [Semiring β] → [PartialOrder β] → [FunLike F α β] → Prop
|
Std.Iterators.Empty.instIterator
|
Std.Data.Iterators.Producers.Monadic.Empty
|
{m : Type w → Type w'} → {β : Type w} → [Monad m] → Std.Iterators.Iterator (Std.Iterators.Empty m β) m β
|
DFinsupp.liftAddHom_apply_single
|
Mathlib.Data.DFinsupp.BigOperators
|
∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)]
[inst_2 : AddCommMonoid γ] (f : (i : ι) → β i →+ γ) (i : ι) (x : β i),
((DFinsupp.liftAddHom f) fun₀ | i => x) = (f i) x
|
Lean.MessageData.ofWidget.sizeOf_spec
|
Lean.Message
|
∀ (a : Lean.Widget.WidgetInstance) (a_1 : Lean.MessageData),
sizeOf (Lean.MessageData.ofWidget a a_1) = 1 + sizeOf a + sizeOf a_1
|
star_left_conjugate_le_conjugate
|
Mathlib.Algebra.Order.Star.Basic
|
∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{a b : R}, a ≤ b → ∀ (c : R), star c * a * c ≤ star c * b * c
|
CategoryTheory.GrpObj.zpow_comp_assoc
|
Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G H X : C} [inst_2 : CategoryTheory.GrpObj G] [inst_3 : CategoryTheory.GrpObj H] (f : X ⟶ G) (n : ℤ) (g : G ⟶ H)
[CategoryTheory.IsMonHom g] {Z : C} (h : H ⟶ Z),
CategoryTheory.CategoryStruct.comp (f ^ n) (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g ^ n) h
|
_private.Lean.Meta.Constructions.CtorElim.0.Lean.reassocMax.maxArgs._sparseCasesOn_1
|
Lean.Meta.Constructions.CtorElim
|
{motive : Lean.Level → Sort u} →
(t : Lean.Level) → ((a a_1 : Lean.Level) → motive (a.max a_1)) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t
|
_private.Lean.Util.Diff.0.Lean.Diff.Histogram.addLeft.match_1
|
Lean.Util.Diff
|
{α : Type u_1} →
{lsize rsize : ℕ} →
(motive : Option (Lean.Diff.Histogram.Entry α lsize rsize) → Sort u_2) →
(x : Option (Lean.Diff.Histogram.Entry α lsize rsize)) →
(Unit → motive none) → ((x : Lean.Diff.Histogram.Entry α lsize rsize) → motive (some x)) → motive x
|
Cardinal.mk_range_inr
|
Mathlib.SetTheory.Cardinal.Basic
|
∀ {α : Type u} {β : Type v}, Cardinal.mk ↑(Set.range Sum.inr) = Cardinal.lift.{u, v} (Cardinal.mk β)
|
Lean.Parser.Term.set_option.formatter
|
Lean.Parser.Command
|
Lean.PrettyPrinter.Formatter
|
WeakFEPair.f_modif_aux1
|
Mathlib.NumberTheory.LSeries.AbstractFuncEq
|
∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (P : WeakFEPair E),
Set.EqOn (fun x => P.f_modif x - P.f x + P.f₀)
(((Set.Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1)
(Set.Ioi 0)
|
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom.congr_simp
|
Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme
|
∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData} (h : I ≤ J) (U : ↑X.affineOpens),
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom h U =
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom h U
|
SkewMonoidAlgebra.mapDomain_smul
|
Mathlib.Algebra.SkewMonoidAlgebra.Basic
|
∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {G' : Type u_3} {f : G → G'} {v : SkewMonoidAlgebra k G}
{R : Type u_5} [inst_1 : Monoid R] [inst_2 : DistribMulAction R k] {b : R},
(SkewMonoidAlgebra.mapDomain f) (b • v) = b • (SkewMonoidAlgebra.mapDomain f) v
|
MulEquiv.monoidHomCongrLeft.eq_1
|
Mathlib.Algebra.Group.Equiv.Basic
|
∀ {M₁ : Type u_5} {M₂ : Type u_6} {N : Type u_8} [inst : MulOneClass M₁] [inst_1 : MulOneClass M₂]
[inst_2 : CommMonoid N] (e : M₁ ≃* M₂), e.monoidHomCongrLeft = { toEquiv := e.monoidHomCongrLeftEquiv, map_mul' := ⋯ }
|
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.Context.maxCalls
|
Lean.Util.ParamMinimizer
|
{m : Type → Type} → Lean.Util.ParamMinimizer.Context✝ m → ℕ
|
SimpleGraph.Embedding.sumInl
|
Mathlib.Combinatorics.SimpleGraph.Sum
|
{α : Type u_1} → {β : Type u_2} → {G : SimpleGraph α} → {H : SimpleGraph β} → G ↪g G ⊕g H
|
CStarAlgebra.pow_nonneg._auto_1
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order
|
Lean.Syntax
|
MeasureTheory.isTightMeasureSet_iff_exists_isCompact_measure_compl_le
|
Mathlib.MeasureTheory.Measure.Tight
|
∀ {𝓧 : Type u_1} [inst : TopologicalSpace 𝓧] {m𝓧 : MeasurableSpace 𝓧} {S : Set (MeasureTheory.Measure 𝓧)},
MeasureTheory.IsTightMeasureSet S ↔ ∀ (ε : ENNReal), 0 < ε → ∃ K, IsCompact K ∧ ∀ μ ∈ S, μ Kᶜ ≤ ε
|
Set.unbounded_le_iff
|
Mathlib.Order.Bounded
|
∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α], Set.Unbounded (fun x1 x2 => x1 ≤ x2) s ↔ ∀ (a : α), ∃ b ∈ s, a < b
|
Polynomial.monic_X_pow_sub_C
|
Mathlib.Algebra.Polynomial.Monic
|
∀ {R : Type u} [inst : Ring R] (a : R) {n : ℕ}, n ≠ 0 → (Polynomial.X ^ n - Polynomial.C a).Monic
|
CategoryTheory.MorphismProperty.MapFactorizationData.hp
|
Mathlib.CategoryTheory.MorphismProperty.Factorization
|
∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} {X Y : C}
{f : X ⟶ Y} (self : W₁.MapFactorizationData W₂ f), W₂ self.p
|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars.0.Lean.Meta.Grind.Arith.Cutsat.cmp₁
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars
|
Array Lean.Meta.Grind.Arith.Cutsat.VarInfo → Int.Linear.Var → Int.Linear.Var → Ordering
|
Lean.Lsp.instToJsonMarkupContent
|
Lean.Data.Lsp.Basic
|
Lean.ToJson Lean.Lsp.MarkupContent
|
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.Environment.mk.sizeOf_spec
|
Std.Internal.Async.System
|
∀ (toHashMap : Std.HashMap String String), sizeOf { toHashMap := toHashMap } = 1 + sizeOf toHashMap
|
instFloorSemiringNat._proof_1
|
Mathlib.Algebra.Order.Floor.Defs
|
∀ {a n : ℕ}, n ≤ id a ↔ ↑n ≤ a
|
Std.DTreeMap.Raw.inter_eq
|
Std.Data.DTreeMap.Raw.Lemmas
|
∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp}, t₁.inter t₂ = t₁ ∩ t₂
|
Int.neg_clog_inv_eq_log
|
Mathlib.Data.Int.Log
|
∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [inst_3 : FloorSemiring R]
(b : ℕ) (r : R), -Int.clog b r⁻¹ = Int.log b r
|
compl_le_compl
|
Mathlib.Order.Heyting.Basic
|
∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ≤ b → bᶜ ≤ aᶜ
|
CategoryTheory.instQuiverMonad
|
Mathlib.CategoryTheory.Monad.Basic
|
{C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → Quiver (CategoryTheory.Monad C)
|
Array.back_mapIdx
|
Init.Data.Array.MapIdx
|
∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : ℕ → α → β} (h : 0 < (Array.mapIdx f xs).size),
(Array.mapIdx f xs).back h = f (xs.size - 1) (xs.back ⋯)
|
List.getLast!_eq_getLast?_getD
|
Init.Data.List.Lemmas
|
∀ {α : Type u_1} [inst : Inhabited α] {l : List α}, l.getLast! = l.getLast?.getD default
|
MonoidHom.decidableMemRange
|
Mathlib.Algebra.Group.Subgroup.Finite
|
{G : Type u_1} →
[inst : Group G] →
{N : Type u_3} →
[inst_1 : Group N] → (f : G →* N) → [Fintype G] → [DecidableEq N] → DecidablePred fun x => x ∈ f.range
|
AddSubmonoid.addGroupMultiples._proof_4
|
Mathlib.Algebra.Group.Submonoid.Membership
|
∀ {M : Type u_1} [inst : AddMonoid M] {x : M} (a : ↥(AddSubmonoid.multiples x)), a + 0 = a
|
CategoryTheory.Functor.whiskerRight._proof_1
|
Mathlib.CategoryTheory.Whiskering
|
∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} E]
{G H : CategoryTheory.Functor C D} (α : G ⟶ H) (F : CategoryTheory.Functor D E) (X Y : C) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((G.comp F).map f) (F.map (α.app Y)) =
CategoryTheory.CategoryStruct.comp (F.map (α.app X)) ((H.comp F).map f)
|
UInt64.reduceMul._regBuiltin.UInt64.reduceMul.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4002762760._hygCtx._hyg.55
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt
|
IO Unit
|
MultilinearMap.dfinsuppFamily._proof_6
|
Mathlib.LinearAlgebra.Multilinear.DFinsupp
|
∀ {ι : Type u_1} {κ : ι → Type u_2} {R : Type u_5} {M : (i : ι) → κ i → Type u_3} {N : ((i : ι) → κ i) → Type u_4}
[inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : Semiring R]
[inst_3 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)] [inst_4 : (p : (i : ι) → κ i) → AddCommMonoid (N p)]
[inst_5 : (i : ι) → (k : κ i) → Module R (M i k)] [inst_6 : (p : (i : ι) → κ i) → Module R (N p)]
(f : (p : (i : ι) → κ i) → MultilinearMap R (fun i => M i (p i)) (N p)) (x : (i : ι) → Π₀ (j : κ i), M i j)
(s : (i : ι) → { s // ∀ (i_1 : κ i), i_1 ∈ s ∨ (x i).toFun i_1 = 0 }) (p : (i : ι) → κ i),
p ∈ Multiset.map (fun f i => f i ⋯) (Finset.univ.val.pi fun i => ↑(s i)) ∨ ((f p) fun i => (x i) (p i)) = 0
|
Set.tprod.eq_def
|
Mathlib.Data.Prod.TProd
|
∀ {ι : Type u} {α : ι → Type v} (x : List ι) (x_1 : (i : ι) → Set (α i)),
Set.tprod x x_1 =
match x, x_1 with
| [], x => Set.univ
| i :: is, t => t i ×ˢ Set.tprod is t
|
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop._proof_1
|
Init.Data.Array.InsertionSort
|
∀ {α : Type u_1} (j : ℕ) (xs : Array α), j < xs.size → ∀ (j' : ℕ), j = j'.succ → j' < xs.size
|
Std.DHashMap.Internal.toListModel_replicate_nil
|
Std.Data.DHashMap.Internal.WF
|
∀ {α : Type u} {β : α → Type v} {c : ℕ},
Std.DHashMap.Internal.toListModel (Array.replicate c Std.DHashMap.Internal.AssocList.nil) = []
|
HomogeneousIdeal.toIdeal_inf
|
Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal
|
∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), (I ⊓ J).toIdeal = I.toIdeal ⊓ J.toIdeal
|
HasStrictFDerivAt.const_cpow
|
Mathlib.Analysis.SpecialFunctions.Pow.Deriv
|
∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {f' : StrongDual ℂ E} {x : E}
{c : ℂ},
HasStrictFDerivAt f f' x → c ≠ 0 ∨ f x ≠ 0 → HasStrictFDerivAt (fun x => c ^ f x) ((c ^ f x * Complex.log c) • f') x
|
CategoryTheory.Abelian.LeftResolution.chainComplexXIso
|
Mathlib.Algebra.Homology.LeftResolution.Basic
|
{A : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] →
{ι : CategoryTheory.Functor C A} →
(Λ : CategoryTheory.Abelian.LeftResolution ι) →
(X : A) →
[inst_2 : ι.Full] →
[inst_3 : ι.Faithful] →
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_5 : CategoryTheory.Abelian A] →
(n : ℕ) →
(Λ.chainComplex X).X (n + 2) ≅
Λ.F.obj (CategoryTheory.Limits.kernel (ι.map ((Λ.chainComplex X).d (n + 1) n)))
|
RpcEncodablePacket.mk.«_@».ImportGraph.Meta.1578893111._hygCtx._hyg.1.noConfusion
|
ImportGraph.Meta
|
{P : Sort u} →
{modName modName' : Lean.Json} → { modName := modName } = { modName := modName' } → (modName = modName' → P) → P
|
_private.Mathlib.Probability.Independence.ZeroOne.0.ProbabilityTheory.Kernel.indep_limsup_atTop_self._simp_1_2
|
Mathlib.Probability.Independence.ZeroOne
|
∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s)
|
Monoid.CoprodI.NeWord.last.eq_def
|
Mathlib.GroupTheory.CoprodI
|
∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (x x_1 : ι) (x_2 : Monoid.CoprodI.NeWord M x x_1),
x_2.last =
match x, x_1, x_2 with
| x, .(x), Monoid.CoprodI.NeWord.singleton x_3 _hne1 => x_3
| x, x_3, _w₁.append _hne w₂ => w₂.last
|
Finset.disjoint_val._simp_1
|
Mathlib.Data.Finset.Disjoint
|
∀ {α : Type u_1} {s t : Finset α}, Disjoint s.val t.val = Disjoint s t
|
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comap_isBasis_iff._simp_1_2
|
Mathlib.Combinatorics.Matroid.Map
|
∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y
|
Lean.Expr.hasNonSyntheticSorry
|
Lean.Util.Sorry
|
Lean.Expr → Bool
|
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Solvers.mergeTerms.go.match_3._arg_pusher
|
Lean.Meta.Tactic.Grind.Types
|
∀ (motive : Lean.Meta.Grind.SolverTerms → Lean.Meta.Grind.SolverTerms → Sort u_1) (α : Sort u✝) (β : α → Sort v✝)
(f : (x : α) → β x) (rel : Lean.Meta.Grind.SolverTerms → Lean.Meta.Grind.SolverTerms → α → Prop)
(rhsTerms lhsTerms : Lean.Meta.Grind.SolverTerms)
(h_1 :
Unit →
((y : α) → rel Lean.Meta.Grind.SolverTerms.nil Lean.Meta.Grind.SolverTerms.nil y → β y) →
motive Lean.Meta.Grind.SolverTerms.nil Lean.Meta.Grind.SolverTerms.nil)
(h_2 :
(solverId : ℕ) →
(e : Lean.Expr) →
(rest : Lean.Meta.Grind.SolverTerms) →
((y : α) → rel Lean.Meta.Grind.SolverTerms.nil (Lean.Meta.Grind.SolverTerms.next solverId e rest) y → β y) →
motive Lean.Meta.Grind.SolverTerms.nil (Lean.Meta.Grind.SolverTerms.next solverId e rest))
(h_3 :
(solverId : ℕ) →
(e : Lean.Expr) →
(rest : Lean.Meta.Grind.SolverTerms) →
((y : α) → rel (Lean.Meta.Grind.SolverTerms.next solverId e rest) Lean.Meta.Grind.SolverTerms.nil y → β y) →
motive (Lean.Meta.Grind.SolverTerms.next solverId e rest) Lean.Meta.Grind.SolverTerms.nil)
(h_4 :
(id₁ : ℕ) →
(rhs : Lean.Expr) →
(rhsTerms : Lean.Meta.Grind.SolverTerms) →
(id₂ : ℕ) →
(lhs : Lean.Expr) →
(lhsTerms : Lean.Meta.Grind.SolverTerms) →
((y : α) →
rel (Lean.Meta.Grind.SolverTerms.next id₁ rhs rhsTerms)
(Lean.Meta.Grind.SolverTerms.next id₂ lhs lhsTerms) y →
β y) →
motive (Lean.Meta.Grind.SolverTerms.next id₁ rhs rhsTerms)
(Lean.Meta.Grind.SolverTerms.next id₂ lhs lhsTerms)),
((match (motive :=
(rhsTerms lhsTerms : Lean.Meta.Grind.SolverTerms) →
((y : α) → rel rhsTerms lhsTerms y → β y) → motive rhsTerms lhsTerms)
rhsTerms, lhsTerms with
| Lean.Meta.Grind.SolverTerms.nil, Lean.Meta.Grind.SolverTerms.nil => fun x => h_1 a x
| Lean.Meta.Grind.SolverTerms.nil, Lean.Meta.Grind.SolverTerms.next solverId e rest => fun x =>
h_2 solverId e rest x
| Lean.Meta.Grind.SolverTerms.next solverId e rest, Lean.Meta.Grind.SolverTerms.nil => fun x =>
h_3 solverId e rest x
| Lean.Meta.Grind.SolverTerms.next id₁ rhs rhsTerms, Lean.Meta.Grind.SolverTerms.next id₂ lhs lhsTerms => fun x =>
h_4 id₁ rhs rhsTerms id₂ lhs lhsTerms x)
fun y h => f y) =
match rhsTerms, lhsTerms with
| Lean.Meta.Grind.SolverTerms.nil, Lean.Meta.Grind.SolverTerms.nil => h_1 a fun y h => f y
| Lean.Meta.Grind.SolverTerms.nil, Lean.Meta.Grind.SolverTerms.next solverId e rest =>
h_2 solverId e rest fun y h => f y
| Lean.Meta.Grind.SolverTerms.next solverId e rest, Lean.Meta.Grind.SolverTerms.nil =>
h_3 solverId e rest fun y h => f y
| Lean.Meta.Grind.SolverTerms.next id₁ rhs rhsTerms, Lean.Meta.Grind.SolverTerms.next id₂ lhs lhsTerms =>
h_4 id₁ rhs rhsTerms id₂ lhs lhsTerms fun y h => f y
|
CategoryTheory.Join.instUniqueHomLeftRight
|
Mathlib.CategoryTheory.Join.Basic
|
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{X : C} → {Y : D} → Unique (CategoryTheory.Join.left X ⟶ CategoryTheory.Join.right Y)
|
MemHolder.nsmul
|
Mathlib.Topology.MetricSpace.HolderNorm
|
∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : NormedAddCommGroup Y] {r : NNReal} {f : X → Y}
[NormedSpace ℝ Y] (n : ℕ), MemHolder r f → MemHolder r (n • f)
|
Fin.val_sub_one_of_ne_zero
|
Mathlib.Data.Fin.Basic
|
∀ {n : ℕ} [inst : NeZero n] {i : Fin n}, i ≠ 0 → ↑(i - 1) = ↑i - 1
|
_private.Mathlib.Data.EReal.Basic.0.EReal.exists_rat_btwn_of_lt.match_1_3
|
Mathlib.Data.EReal.Basic
|
∀ (a : ℝ) (motive : (∃ q, ↑q < a) → Prop) (x : ∃ q, ↑q < a), (∀ (b : ℚ) (hab : ↑b < a), motive ⋯) → motive x
|
CategoryTheory.Limits.IsLimit.liftConeMorphism
|
Mathlib.CategoryTheory.Limits.IsLimit
|
{J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit t → (s : CategoryTheory.Limits.Cone F) → s ⟶ t
|
Equiv.sumIsRight_apply
|
Mathlib.Logic.Equiv.Defs
|
∀ {α : Type u_1} {β : Type u_2} (x : { x // x.isRight = true }), Equiv.sumIsRight x = (↑x).getRight ⋯
|
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_10
|
Mathlib.Data.List.Cycle
|
∀ {α : Type u_1} {l : List α} (hl : l ≠ []), ¬[l.getLast ⋯].isEmpty = true → ¬[l.getLast ⋯] = []
|
CategoryTheory.Limits.pushoutPushoutRightIsPushout._proof_3
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X₁ X₂ X₃ Z₁ Z₂ : C} (g₁ : Z₁ ⟶ X₁) (g₂ : Z₁ ⟶ X₂)
(g₃ : Z₂ ⟶ X₂) (g₄ : Z₂ ⟶ X₃) [CategoryTheory.Limits.HasPushout g₁ g₂]
[inst_2 : CategoryTheory.Limits.HasPushout g₃ g₄]
[inst_3 :
CategoryTheory.Limits.HasPushout g₁
(CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄))],
CategoryTheory.CategoryStruct.comp g₁
(CategoryTheory.Limits.pushout.inl g₁
(CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄))) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄))
(CategoryTheory.Limits.pushout.inr g₁
(CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄)))
|
CliffordAlgebra.reverse_involutive._simp_1
|
Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation
|
∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M}, Function.Involutive ⇑CliffordAlgebra.reverse = True
|
Lean.Parser.numLitFn
|
Lean.Parser.Basic
|
Lean.Parser.ParserFn
|
StarAlgebra.elemental.characterSpaceToSpectrum._proof_4
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic
|
∀ {A : Type u_1} [inst : CStarAlgebra A], SubringClass (StarSubalgebra ℂ A) A
|
Algebra.normalizedTrace_algebraMap_apply
|
Mathlib.FieldTheory.NormalizedTrace
|
∀ (F : Type u_3) (E : Type u_4) (K : Type u_5) [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra E K] [inst_5 : Algebra F K] [IsScalarTower F E K]
[inst_7 : Algebra.IsIntegral F E] [inst_8 : Algebra.IsIntegral F K] [inst_9 : CharZero F] (a : E),
(Algebra.normalizedTrace F K) ((algebraMap E K) a) = (Algebra.normalizedTrace F E) a
|
sup_left_right_swap
|
Mathlib.Order.Lattice
|
∀ {α : Type u} [inst : SemilatticeSup α] (a b c : α), a ⊔ b ⊔ c = c ⊔ b ⊔ a
|
pythagoreanTriple_comm
|
Mathlib.NumberTheory.PythagoreanTriples
|
∀ {x y z : ℤ}, PythagoreanTriple x y z ↔ PythagoreanTriple y x z
|
AlgebraicGeometry.IsOpenImmersion.ΓIsoTop._proof_1
|
Mathlib.AlgebraicGeometry.OpenImmersion
|
∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f],
AlgebraicGeometry.Scheme.Hom.opensRange f = (AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj ⊤
|
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_rotateLeft_of_lt._proof_1_2
|
Init.Data.BitVec.Lemmas
|
∀ {r n : ℕ} (w : ℕ), r < w + 1 → n < w + 1 - r → ¬n < w + 1 → False
|
CategoryTheory.MorphismProperty.IsLocalAtSource.rec
|
Mathlib.CategoryTheory.MorphismProperty.Local
|
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{P : CategoryTheory.MorphismProperty C} →
{K : CategoryTheory.Precoverage C} →
{motive : P.IsLocalAtSource K → Sort u_1} →
([toRespects : P.Respects (CategoryTheory.MorphismProperty.isomorphisms C)] →
(comp :
∀ {X Y : C} {f : X ⟶ Y} (𝒰 : K.ZeroHypercover X) (i : 𝒰.I₀),
P f → P (CategoryTheory.CategoryStruct.comp (𝒰.f i) f)) →
(of_zeroHypercover :
∀ {X Y : C} {f : X ⟶ Y} (𝒰 : K.ZeroHypercover X),
(∀ (i : 𝒰.I₀), P (CategoryTheory.CategoryStruct.comp (𝒰.f i) f)) → P f) →
motive ⋯) →
(t : P.IsLocalAtSource K) → motive t
|
CategoryTheory.Functor.LaxMonoidal.right_unitality
|
Mathlib.CategoryTheory.Monoidal.Functor
|
∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {D : Type u₂}
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} {inst_3 : CategoryTheory.MonoidalCategory D}
(F : CategoryTheory.Functor C D) [self : F.LaxMonoidal] (X : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (F.obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) (CategoryTheory.Functor.LaxMonoidal.ε F))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.μ F X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
(F.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom))
|
_private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.logb_prod._simp_1_1
|
Mathlib.Analysis.SpecialFunctions.Log.Base
|
∀ {ι : Type u_1} {M₀ : Type u_4} [inst : CommMonoidWithZero M₀] {f : ι → M₀} {s : Finset ι} [Nontrivial M₀]
[NoZeroDivisors M₀], (∏ x ∈ s, f x ≠ 0) = ∀ a ∈ s, f a ≠ 0
|
CategoryTheory.FreeMonoidalCategory.Hom.ρ_hom.elim
|
Mathlib.CategoryTheory.Monoidal.Free.Basic
|
{C : Type u} →
{motive : (a a_1 : CategoryTheory.FreeMonoidalCategory C) → a.Hom a_1 → Sort u_1} →
{a a_1 : CategoryTheory.FreeMonoidalCategory C} →
(t : a.Hom a_1) →
t.ctorIdx = 5 →
((X : CategoryTheory.FreeMonoidalCategory C) →
motive (X.tensor CategoryTheory.FreeMonoidalCategory.unit) X
(CategoryTheory.FreeMonoidalCategory.Hom.ρ_hom X)) →
motive a a_1 t
|
UpperHalfPlane.dist_triangle
|
Mathlib.Analysis.Complex.UpperHalfPlane.Metric
|
∀ (a b c : UpperHalfPlane), dist a c ≤ dist a b + dist b c
|
_private.Mathlib.Combinatorics.Pigeonhole.0.Fintype.exists_card_fiber_lt_of_card_lt_nsmul.match_1_1
|
Mathlib.Combinatorics.Pigeonhole
|
∀ {α : Type u_3} {β : Type u_1} {M : Type u_2} [inst : DecidableEq β] [inst_1 : Fintype α] [inst_2 : Fintype β]
(f : α → β) {b : M} [inst_3 : CommSemiring M] [inst_4 : LinearOrder M]
(motive : (∃ y ∈ Finset.univ, ↑{x | f x = y}.card < b) → Prop) (x : ∃ y ∈ Finset.univ, ↑{x | f x = y}.card < b),
(∀ (y : β) (left : y ∈ Finset.univ) (h : ↑{x | f x = y}.card < b), motive ⋯) → motive x
|
MeasureTheory.average_const
|
Mathlib.MeasureTheory.Integral.Average
|
∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[CompleteSpace E] (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ] [h : NeZero μ] (c : E),
⨍ (_x : α), c ∂μ = c
|
Batteries.UnionFind.link
|
Batteries.Data.UnionFind.Basic
|
(self : Batteries.UnionFind) → Fin self.size → (y : Fin self.size) → self.parent ↑y = ↑y → Batteries.UnionFind
|
CategoryTheory.Iso.self_symm_conj
|
Mathlib.CategoryTheory.Conj
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.End Y),
α.conj (α.symm.conj f) = f
|
EmbeddingLike.comp_injective._simp_1
|
Mathlib.Data.FunLike.Embedding
|
∀ {α : Sort u_2} {β : Sort u_3} {γ : Sort u_4} {F : Sort u_5} [inst : FunLike F β γ] [EmbeddingLike F β γ] (f : α → β)
(e : F), Function.Injective (⇑e ∘ f) = Function.Injective f
|
_private.Mathlib.Order.OrderIsoNat.0.exists_covBy_seq_of_wellFoundedLT_wellFoundedGT_of_le._simp_1_2
|
Mathlib.Order.OrderIsoNat
|
∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.