name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.etaIfUnderApplied
|
Lean.Compiler.LCNF.ToLCNF
|
Lean.Expr → ℕ → Lean.Compiler.LCNF.ToLCNF.M Lean.Compiler.LCNF.Arg → Lean.Compiler.LCNF.ToLCNF.M Lean.Compiler.LCNF.Arg
|
DFinsupp.Lex.addLeftStrictMono
|
Mathlib.Data.DFinsupp.Lex
|
∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → AddMonoid (α i)]
[inst_2 : (i : ι) → LinearOrder (α i)] [∀ (i : ι), AddLeftStrictMono (α i)], AddLeftStrictMono (Lex (Π₀ (i : ι), α i))
|
CategoryTheory.WithInitial.incl.eq_1
|
Mathlib.CategoryTheory.WithTerminal.Basic
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
CategoryTheory.WithInitial.incl =
{ obj := CategoryTheory.WithInitial.of, map := fun {X Y} f => f, map_id := ⋯, map_comp := ⋯ }
|
OrderIso.lowerBounds_image
|
Mathlib.Order.Bounds.OrderIso
|
∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) {s : Set α},
lowerBounds (⇑f '' s) = ⇑f '' lowerBounds s
|
Int8.reduceGT._regBuiltin.Int8.reduceGT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3529513953._hygCtx._hyg.213
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt
|
IO Unit
|
Set.image_op_add
|
Mathlib.Algebra.Group.Pointwise.Set.Basic
|
∀ {α : Type u_2} [inst : Add α] {s t : Set α}, AddOpposite.op '' (s + t) = AddOpposite.op '' t + AddOpposite.op '' s
|
Bool.instCommutativeAnd
|
Init.Data.Bool
|
Std.Commutative fun x1 x2 => x1 && x2
|
Std.Tactic.BVDecide.BVUnOp.rotateLeft.inj
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Basic
|
∀ {n n_1 : ℕ}, Std.Tactic.BVDecide.BVUnOp.rotateLeft n = Std.Tactic.BVDecide.BVUnOp.rotateLeft n_1 → n = n_1
|
instFullPreordCatPreordToCat
|
Mathlib.Order.Category.Preord
|
preordToCat.Full
|
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.map_dual._simp_1_2
|
Mathlib.Combinatorics.Matroid.Map
|
∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β}, (t ⊆ f '' s) = ∃ u ⊆ s, f '' u = t
|
_private.Mathlib.Data.Matrix.Basis.0.Matrix.single_mem_matrix._simp_1_1
|
Mathlib.Data.Matrix.Basis
|
∀ {m : Type u_2} {n : Type u_3} {α : Type v} {S : Set α} {M : Matrix m n α},
(M ∈ S.matrix) = ∀ (i : m) (j : n), M i j ∈ S
|
Mathlib.Tactic.Ring.pow_prod_atom
|
Mathlib.Tactic.Ring.Basic
|
∀ {R : Type u_1} [inst : CommSemiring R] (a : R) (b : ℕ), a ^ b = (a + 0) ^ b * Nat.rawCast 1
|
Lean.Compiler.LCNF.SpecState
|
Lean.Compiler.LCNF.SpecInfo
|
Type
|
inv_gold
|
Mathlib.NumberTheory.Real.GoldenRatio
|
Real.goldenRatio⁻¹ = -Real.goldenConj
|
_private.Init.Data.UInt.Lemmas.0.UInt64.toUInt16_le._simp_1_1
|
Init.Data.UInt.Lemmas
|
∀ {a b : UInt64}, (a ≤ b) = (a.toNat ≤ b.toNat)
|
KaehlerDifferential.submodule_span_range_eq_ideal
|
Mathlib.RingTheory.Kaehler.Basic
|
∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Submodule.span S (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) =
Submodule.restrictScalars S (KaehlerDifferential.ideal R S)
|
TensorAlgebra.equivFreeAlgebra._proof_4
|
Mathlib.LinearAlgebra.TensorAlgebra.Basis
|
∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R)
|
WellFounded.instIsAsymmRel
|
Mathlib.Order.WellFounded
|
∀ {α : Type u_1} [inst : WellFoundedRelation α], IsAsymm α WellFoundedRelation.rel
|
Nat.nth_le_of_strictMonoOn_of_mapsTo
|
Mathlib.Data.Nat.Nth
|
∀ {p : ℕ → Prop} (f : ℕ → ℕ),
Set.MapsTo f {n | ∀ (hf : (setOf p).Finite), n < hf.toFinset.card} (setOf p) →
StrictMonoOn f {n | ∀ (hf : (setOf p).Finite), n < hf.toFinset.card} → ∀ {n : ℕ}, Nat.nth p n ≤ f n
|
FreeAlgebra.Rel.add_assoc
|
Mathlib.Algebra.FreeAlgebra
|
∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] {a b c : FreeAlgebra.Pre R X},
FreeAlgebra.Rel R X (a + b + c) (a + (b + c))
|
Std.DTreeMap.Internal.Impl.Const.maxEntry!._unsafe_rec
|
Std.Data.DTreeMap.Internal.Queries
|
{α : Type u} → {β : Type v} → [Inhabited (α × β)] → (Std.DTreeMap.Internal.Impl α fun x => β) → α × β
|
Lean.Grind.AC.Seq.concat_k.eq_1
|
Init.Grind.AC
|
∀ (s₁ : Lean.Grind.AC.Seq),
s₁.concat_k =
Lean.Grind.AC.Seq.rec (motive := fun x => Lean.Grind.AC.Seq → Lean.Grind.AC.Seq)
(fun x s₂ => Lean.Grind.AC.Seq.cons x s₂) (fun x x_1 ih s₂ => Lean.Grind.AC.Seq.cons x (ih s₂)) s₁
|
_private.Lean.Data.EditDistance.0.Lean.EditDistance.levenshtein._proof_1
|
Lean.Data.EditDistance
|
∀ (str2 : String), ∀ i ∈ [:(Vector.replicate (str2.length + 1) 0).size], i < str2.length + 1
|
AddSubmonoid.mem_map_of_mem
|
Mathlib.Algebra.Group.Submonoid.Operations
|
∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) {S : AddSubmonoid M} {x : M},
x ∈ S → f x ∈ AddSubmonoid.map f S
|
AddMagmaCat.neg_hom_apply
|
Mathlib.Algebra.Category.Semigrp.Basic
|
∀ {M N : AddMagmaCat} (e : M ≅ N) (x : ↑M),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x
|
Aesop.SafeRulesResult.succeeded.inj
|
Aesop.Search.Expansion
|
∀ {newRapps newRapps_1 : Array Aesop.RappRef},
Aesop.SafeRulesResult.succeeded newRapps = Aesop.SafeRulesResult.succeeded newRapps_1 → newRapps = newRapps_1
|
one_leftCoset
|
Mathlib.GroupTheory.Coset.Basic
|
∀ {α : Type u_1} [inst : Monoid α] (s : Set α), 1 • s = s
|
Lean.IR.ToIR.BuilderState.joinPoints._default
|
Lean.Compiler.IR.ToIR
|
Std.HashMap Lean.FVarId Lean.IR.JoinPointId
|
_private.Mathlib.Tactic.CC.0.Mathlib.Tactic.CC.elabCCConfig.match_1
|
Mathlib.Tactic.CC
|
(motive : DoResultPR Mathlib.Tactic.CC.CCConfig Mathlib.Tactic.CC.CCConfig PUnit.{1} → Sort u_1) →
(r : DoResultPR Mathlib.Tactic.CC.CCConfig Mathlib.Tactic.CC.CCConfig PUnit.{1}) →
((a : Mathlib.Tactic.CC.CCConfig) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Mathlib.Tactic.CC.CCConfig) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r
|
_private.Init.Data.List.Nat.Erase.0.List.eraseIdx_set_lt._proof_1_2
|
Init.Data.List.Nat.Erase
|
∀ {α : Type u_1} {l : List α} {i j : ℕ} {a : α}, j < i → ∀ n < j, i - 1 = n → False
|
PowerBasis.map
|
Mathlib.RingTheory.PowerBasis
|
{R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
{S' : Type u_7} →
[inst_3 : CommRing S'] → [inst_4 : Algebra R S'] → PowerBasis R S → (S ≃ₐ[R] S') → PowerBasis R S'
|
_private.Batteries.Data.List.Basic.0.List.forall₂_cons.match_1_1
|
Batteries.Data.List.Basic
|
∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {a : α} {b : β} {l₁ : List α} {l₂ : List β}
(motive : List.Forall₂ R (a :: l₁) (b :: l₂) → Prop) (x : List.Forall₂ R (a :: l₁) (b :: l₂)),
(∀ (h : R a b) (tail : List.Forall₂ R l₁ l₂), motive ⋯) → motive x
|
Lean.Server.RequestError.rec
|
Lean.Server.Requests
|
{motive : Lean.Server.RequestError → Sort u} →
((code : Lean.JsonRpc.ErrorCode) → (message : String) → motive { code := code, message := message }) →
(t : Lean.Server.RequestError) → motive t
|
NonemptyInterval.toDualProd_injective
|
Mathlib.Order.Interval.Basic
|
∀ {α : Type u_1} [inst : LE α], Function.Injective NonemptyInterval.toDualProd
|
_private.Batteries.Data.List.Lemmas.0.List.mem_findIdxs_iff_getElem_sub_pos._proof_1_7
|
Batteries.Data.List.Lemmas
|
∀ {α : Type u_1} {i : ℕ} (head : α) (tail : List α) {s : ℕ},
-1 * ↑i + ↑s ≤ 0 → i - s + 1 ≤ (head :: tail).length → -1 * ↑i + ↑s + 1 ≤ 0 → i - (s + 1) < tail.length
|
CategoryTheory.Equivalence.symmEquivInverse_obj_functor
|
Mathlib.CategoryTheory.Equivalence.Symmetry
|
∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] (D : Type u_2)
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (X : (D ≌ C)ᵒᵖ),
((CategoryTheory.Equivalence.symmEquivInverse C D).obj X).functor = (Opposite.unop X).inverse
|
_private.Mathlib.Data.Finset.SymmDiff.0.Finset.mem_symmDiff._simp_1_1
|
Mathlib.Data.Finset.SymmDiff
|
∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t)
|
Std.DHashMap.Raw.Const.all_keys
|
Std.Data.DHashMap.RawLemmas
|
∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulHashable α]
[EquivBEq α] {p : α → Bool}, m.WF → m.keys.all p = m.all fun a x => p a
|
Int.fmod_fmod
|
Init.Data.Int.DivMod.Lemmas
|
∀ (a b : ℤ), (a.fmod b).fmod b = a.fmod b
|
CategoryTheory.Presieve.FamilyOfElements.isCompatible_map_smul_aux
|
Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify
|
∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ R : CategoryTheory.Functor Cᵒᵖ RingCat} (α : R₀ ⟶ R) [CategoryTheory.Presheaf.IsLocallyInjective J α]
{M₀ : PresheafOfModules R₀} {A : CategoryTheory.Functor Cᵒᵖ AddCommGrpCat} (φ : M₀.presheaf ⟶ A)
[CategoryTheory.Presheaf.IsLocallyInjective J φ],
CategoryTheory.Presheaf.IsSeparated J A →
∀ {X : C} (r : ↑(R.obj (Opposite.op X))) (m : ↑(A.obj (Opposite.op X))) {Y Z : C} (f : Y ⟶ X) (g : Z ⟶ Y)
(r₀ : ↑(R₀.obj (Opposite.op Y))) (r₀' : ↑(R₀.obj (Opposite.op Z))) (m₀ : ↑(M₀.obj (Opposite.op Y)))
(m₀' : ↑(M₀.obj (Opposite.op Z))),
(CategoryTheory.ConcreteCategory.hom (α.app (Opposite.op Y))) r₀ =
(CategoryTheory.ConcreteCategory.hom (R.map f.op)) r →
(CategoryTheory.ConcreteCategory.hom (α.app (Opposite.op Z))) r₀' =
(CategoryTheory.ConcreteCategory.hom (R.map (CategoryTheory.CategoryStruct.comp f.op g.op))) r →
(CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Y))) m₀ =
(CategoryTheory.ConcreteCategory.hom (A.map f.op)) m →
(CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Z))) m₀' =
(CategoryTheory.ConcreteCategory.hom (A.map (CategoryTheory.CategoryStruct.comp f.op g.op))) m →
(CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Z)))
((CategoryTheory.ConcreteCategory.hom (M₀.map g.op)) (r₀ • m₀)) =
(CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Z))) (r₀' • m₀')
|
_private.Mathlib.Computability.Primrec.0.Primrec₂.uncurry.match_1_1
|
Mathlib.Computability.Primrec
|
∀ {α : Type u_1} {β : Type u_2} (motive : α × β → Prop) (x : α × β), (∀ (a : α) (b : β), motive (a, b)) → motive x
|
CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp
|
Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo
|
∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} (self : F.StrongTrans G) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (self.naturality (CategoryTheory.CategoryStruct.comp f g)).hom
(CategoryTheory.Bicategory.whiskerLeft (self.app a) (G.mapComp f g).hom) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapComp f g).hom (self.app c))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (F.map g) (self.app c)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (self.naturality g).hom)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (self.app b) (G.map g)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (self.naturality f).hom (G.map g))
(CategoryTheory.Bicategory.associator (self.app a) (G.map f) (G.map g)).hom))))
|
CategoryTheory.ShortComplex.Splitting.ofIsIsoOfIsZero._proof_4
|
Mathlib.Algebra.Homology.ShortComplex.Exact
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C) (hf : CategoryTheory.IsIso S.f),
CategoryTheory.CategoryStruct.comp (CategoryTheory.inv S.f) S.f + CategoryTheory.CategoryStruct.comp S.g 0 =
CategoryTheory.CategoryStruct.id S.X₂
|
_private.Lean.Compiler.LCNF.StructProjCases.0.Lean.Compiler.LCNF.StructProjCases.findStructCtorInfo?._sparseCasesOn_9
|
Lean.Compiler.LCNF.StructProjCases
|
{motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t
|
CategoryTheory.MorphismProperty.Comma.Hom.ext'
|
Mathlib.CategoryTheory.MorphismProperty.Comma
|
∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory.MorphismProperty A} {W : CategoryTheory.MorphismProperty B} [inst_3 : Q.IsMultiplicative]
[inst_4 : W.IsMultiplicative] {X Y : CategoryTheory.MorphismProperty.Comma L R P Q W} {f g : X ⟶ Y},
CategoryTheory.MorphismProperty.Comma.Hom.hom f = CategoryTheory.MorphismProperty.Comma.Hom.hom g → f = g
|
Finset.filter_le_eq_Ici
|
Mathlib.Order.Interval.Finset.Basic
|
∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] {a : α} [inst_2 : Fintype α]
[inst_3 : DecidablePred fun x => a ≤ x], {x | a ≤ x} = Finset.Ici a
|
SzemerediRegularity.stepBound_mono
|
Mathlib.Combinatorics.SimpleGraph.Regularity.Bound
|
Monotone SzemerediRegularity.stepBound
|
contDiff_id
|
Mathlib.Analysis.Calculus.ContDiff.Basic
|
∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : WithTop ℕ∞}, ContDiff 𝕜 n id
|
_private.Mathlib.Algebra.ContinuedFractions.Computation.Approximations.0.GenContFract.fib_le_of_contsAux_b._proof_1_1
|
Mathlib.Algebra.ContinuedFractions.Computation.Approximations
|
∀ (n : ℕ), ¬n + 2 ≤ 1
|
Std.DTreeMap.getKey!_eq_of_mem
|
Std.Data.DTreeMap.Lemmas
|
∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α] {k : α}, k ∈ t → t.getKey! k = k
|
Subring.copy._proof_4
|
Mathlib.Algebra.Ring.Subring.Defs
|
∀ {R : Type u_1} [inst : Ring R] (S : Subring R) (s : Set R) (hs : s = ↑S), 0 ∈ (S.copy s hs).carrier
|
HNNExtension.toSubgroup_neg_one
|
Mathlib.GroupTheory.HNNExtension
|
∀ {G : Type u_1} [inst : Group G] (A B : Subgroup G), HNNExtension.toSubgroup A B (-1) = B
|
ZMod.val_neg_of_ne_zero
|
Mathlib.Data.ZMod.Basic
|
∀ {n : ℕ} [nz : NeZero n] (a : ZMod n) [na : NeZero a], (-a).val = n - a.val
|
String.ofList_eq_empty_iff
|
Init.Data.String.Basic
|
∀ {l : List Char}, String.ofList l = "" ↔ l = []
|
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.Valid.prevn.match_1_3
|
Batteries.Data.String.Lemmas
|
∀ (x : Substring.Raw) (motive : (∃ l m r, Substring.Raw.ValidFor l m r x) → Prop)
(x_1 : ∃ l m r, Substring.Raw.ValidFor l m r x),
(∀ (l m r : List Char) (h : Substring.Raw.ValidFor l m r x), motive ⋯) → motive x_1
|
Module.End.instDivisionRing._proof_12
|
Mathlib.RingTheory.SimpleModule.Basic
|
∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : Module.End R M),
Semiring.npow 0 x = 1
|
CompleteDistribLattice.toSDiff
|
Mathlib.Order.CompleteBooleanAlgebra
|
{α : Type u_1} → [self : CompleteDistribLattice α] → SDiff α
|
CategoryTheory.Limits.IsLimit.whiskerEquivalence
|
Mathlib.CategoryTheory.Limits.IsLimit
|
{J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{K : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} K] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{s : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit s →
(e : K ≌ J) → CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Cone.whisker e.functor s)
|
Lean.Meta.Grind.AC.EqCnstrProof.core.injEq
|
Lean.Meta.Tactic.Grind.AC.Types
|
∀ (a b : Lean.Expr) (ea eb : Lean.Grind.AC.Expr) (a_1 b_1 : Lean.Expr) (ea_1 eb_1 : Lean.Grind.AC.Expr),
(Lean.Meta.Grind.AC.EqCnstrProof.core a b ea eb = Lean.Meta.Grind.AC.EqCnstrProof.core a_1 b_1 ea_1 eb_1) =
(a = a_1 ∧ b = b_1 ∧ ea = ea_1 ∧ eb = eb_1)
|
instFintypeAddEquivInt._proof_2
|
Mathlib.GroupTheory.ArchimedeanDensely
|
AddEquiv.neg ℤ ∉ {AddEquiv.refl ℤ}
|
ProperSpace.mk._flat_ctor
|
Mathlib.Topology.MetricSpace.ProperSpace
|
∀ {α : Type u} [inst : PseudoMetricSpace α], (∀ (x : α) (r : ℝ), IsCompact (Metric.closedBall x r)) → ProperSpace α
|
isRelLowerSet_self._simp_1
|
Mathlib.Order.UpperLower.Relative
|
∀ {α : Type u_1} {s : Set α} [inst : LE α], (IsRelLowerSet s fun x => x ∈ s) = True
|
Equiv.commSemigroup.eq_1
|
Mathlib.Algebra.Group.TransferInstance
|
∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : CommSemigroup β],
e.commSemigroup = Function.Injective.commSemigroup ⇑e ⋯ ⋯
|
tsum_eq_sum'
|
Mathlib.Topology.Algebra.InfiniteSum.Basic
|
∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β} [L.LeAtTop] {s : Finset β}, Function.support f ⊆ ↑s → ∑'[L] (b : β), f b = ∑ b ∈ s, f b
|
AlgebraicGeometry.Scheme.germToFunctionField._proof_1
|
Mathlib.AlgebraicGeometry.FunctionField
|
∀ (X : AlgebraicGeometry.Scheme) (U : X.Opens) [h : Nonempty ↥↑U], (Set.univ ∩ ↑U).Nonempty
|
Finset.Nonempty.norm_prod_le_sup'_norm
|
Mathlib.Analysis.Normed.Group.Ultra
|
∀ {M : Type u_1} {ι : Type u_2} [inst : SeminormedCommGroup M] [IsUltrametricDist M] {s : Finset ι} (hs : s.Nonempty)
(f : ι → M), ‖∏ i ∈ s, f i‖ ≤ s.sup' hs fun x => ‖f x‖
|
Prefunctor.IsCovering.comp
|
Mathlib.Combinatorics.Quiver.Covering
|
∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V) {W : Type u_3} [inst_2 : Quiver W]
(ψ : V ⥤q W), φ.IsCovering → ψ.IsCovering → (φ ⋙q ψ).IsCovering
|
Int.existsUnique_equiv
|
Mathlib.Data.Int.ModEq
|
∀ (a : ℤ) {b : ℤ}, 0 < b → ∃ z, 0 ≤ z ∧ z < b ∧ z ≡ a [ZMOD b]
|
padicNormE._proof_4
|
Mathlib.NumberTheory.Padics.PadicNumbers
|
∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ_[p]), 0 ≤ Quotient.lift PadicSeq.norm ⋯ q
|
CategoryTheory.instDivisionRingEndOfHasKernelsOfSimple.congr_simp
|
Mathlib.CategoryTheory.Preadditive.Schur
|
∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasKernels C] {X : C} [inst_3 : CategoryTheory.Simple X],
CategoryTheory.instDivisionRingEndOfHasKernelsOfSimple = CategoryTheory.instDivisionRingEndOfHasKernelsOfSimple
|
enorm_pos'._simp_4
|
Mathlib.Analysis.Normed.Group.Basic
|
∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ENormedAddMonoid E] {a : E}, (0 < ‖a‖ₑ) = (a ≠ 0)
|
List.head?_range'
|
Init.Data.List.Range
|
∀ {s n : ℕ}, (List.range' s n).head? = if n = 0 then none else some s
|
RCLike.nnnorm_nsmul
|
Mathlib.Analysis.RCLike.Basic
|
∀ (K : Type u_1) {E : Type u_2} [inst : RCLike K] [inst_1 : NormedAddCommGroup E] [NormedSpace K E] (n : ℕ) (x : E),
‖n • x‖₊ = n • ‖x‖₊
|
HomologicalComplex.mapBifunctor₁₂.ι_D₂_assoc
|
Mathlib.Algebra.Homology.BifunctorAssociator
|
∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_5, u_3} C₁₂] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms C₁]
[inst_6 : CategoryTheory.Limits.HasZeroMorphisms C₂] [inst_7 : CategoryTheory.Limits.HasZeroMorphisms C₃]
[inst_8 : CategoryTheory.Preadditive C₁₂] [inst_9 : CategoryTheory.Preadditive C₄]
(F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂))
(G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) [inst_10 : F₁₂.PreservesZeroMorphisms]
[inst_11 : ∀ (X₁ : C₁), (F₁₂.obj X₁).PreservesZeroMorphisms] [inst_12 : G.Additive]
[inst_13 : ∀ (X₁₂ : C₁₂), (G.obj X₁₂).PreservesZeroMorphisms] {ι₁ : Type u_7} {ι₂ : Type u_8} {ι₃ : Type u_9}
{ι₁₂ : Type u_10} {ι₄ : Type u_12} [inst_14 : DecidableEq ι₄] {c₁ : ComplexShape ι₁} {c₂ : ComplexShape ι₂}
{c₃ : ComplexShape ι₃} (K₁ : HomologicalComplex C₁ c₁) (K₂ : HomologicalComplex C₂ c₂) (K₃ : HomologicalComplex C₃ c₃)
(c₁₂ : ComplexShape ι₁₂) (c₄ : ComplexShape ι₄) [inst_15 : TotalComplexShape c₁ c₂ c₁₂]
[inst_16 : TotalComplexShape c₁₂ c₃ c₄] [inst_17 : K₁.HasMapBifunctor K₂ F₁₂ c₁₂] [inst_18 : DecidableEq ι₁₂]
[inst_19 : (K₁.mapBifunctor K₂ F₁₂ c₁₂).HasMapBifunctor K₃ G c₄] (i₁ : ι₁) (i₂ : ι₂) (i₃ : ι₃) (j j' : ι₄)
(h : c₁.r c₂ c₃ c₁₂ c₄ (i₁, i₂, i₃) = j) [inst_20 : HomologicalComplex.HasGoodTrifunctor₁₂Obj F₁₂ G K₁ K₂ K₃ c₁₂ c₄]
{Z : C₄} (h_1 : (⋯.mapBifunctor K₃ G c₄).X j' ⟶ Z),
CategoryTheory.CategoryStruct.comp (HomologicalComplex.mapBifunctor₁₂.ι F₁₂ G K₁ K₂ K₃ c₁₂ c₄ i₁ i₂ i₃ j h)
(CategoryTheory.CategoryStruct.comp ⋯ h_1) =
CategoryTheory.CategoryStruct.comp (HomologicalComplex.mapBifunctor₁₂.d₂ F₁₂ G K₁ K₂ K₃ c₁₂ c₄ i₁ i₂ i₃ j') h_1
|
Batteries.UnionFind.FindAux.mk.congr_simp
|
Batteries.Data.UnionFind.Basic
|
∀ {n : ℕ} (s s_1 : Array Batteries.UFNode) (e_s : s = s_1) (root root_1 : Fin n),
root = root_1 →
∀ (size_eq : s.size = n), { s := s, root := root, size_eq := size_eq } = { s := s_1, root := root_1, size_eq := ⋯ }
|
UniformOnFun.hasBasis_uniformity_of_basis_aux₁
|
Mathlib.Topology.UniformSpace.UniformConvergenceTopology
|
∀ (α : Type u_1) (β : Type u_2) {ι : Type u_4} [inst : UniformSpace β] (𝔖 : Set (Set α)) {p : ι → Prop}
{s : ι → Set (β × β)},
(uniformity β).HasBasis p s →
∀ (S : Set α), (uniformity (UniformOnFun α β 𝔖)).HasBasis p fun i => UniformOnFun.gen 𝔖 S (s i)
|
_private.Mathlib.Topology.DerivedSet.0.isClosed_derivedSet._simp_1_1
|
Mathlib.Topology.DerivedSet
|
∀ {X : Type u_1} [inst : TopologicalSpace X] (A : Set X), (derivedSet A ⊆ A) = IsClosed A
|
Complement.rec
|
Init.Prelude
|
{α : Type u} →
{motive : Complement α → Sort u_1} →
((complement : α → α) → motive { complement := complement }) → (t : Complement α) → motive t
|
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.fold.eq_1
|
Std.Data.DHashMap.Internal.WF
|
∀ {α : Type u} {β : α → Type v} {δ : Type w} (f : δ → (a : α) → β a → δ) (init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.fold f init b = (Std.DHashMap.Raw.foldM (fun x1 x2 x3 => pure (f x1 x2 x3)) init b).run
|
CategoryTheory.Limits.Sigma.π
|
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms
|
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroMorphisms C] →
{β : Type w} →
[DecidableEq β] → (f : β → C) → [inst_3 : CategoryTheory.Limits.HasCoproduct f] → (b : β) → ∐ f ⟶ f b
|
LowerSet.Iic_sup_erase
|
Mathlib.Order.UpperLower.Closure
|
∀ {α : Type u_1} [inst : Preorder α] {s : LowerSet α} {a : α},
a ∈ s → (∀ b ∈ s, a ≤ b → b = a) → LowerSet.Iic a ⊔ s.erase a = s
|
Mathlib.Tactic.BicategoryCoherence.LiftHom₂.casesOn
|
Mathlib.Tactic.CategoryTheory.BicategoryCoherence
|
{B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f g : a ⟶ b} →
[inst_1 : Mathlib.Tactic.BicategoryCoherence.LiftHom f] →
[inst_2 : Mathlib.Tactic.BicategoryCoherence.LiftHom g] →
{η : f ⟶ g} →
{motive : Mathlib.Tactic.BicategoryCoherence.LiftHom₂ η → Sort u_1} →
(t : Mathlib.Tactic.BicategoryCoherence.LiftHom₂ η) →
((lift :
Mathlib.Tactic.BicategoryCoherence.LiftHom.lift f ⟶
Mathlib.Tactic.BicategoryCoherence.LiftHom.lift g) →
motive { lift := lift }) →
motive t
|
instIsTransOfIsWellOrder
|
Mathlib.Order.RelClasses
|
∀ {α : Type u_1} (r : α → α → Prop) [IsWellOrder α r], IsTrans α r
|
Path.add_apply
|
Mathlib.Topology.Path
|
∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : Add X] [inst_2 : ContinuousAdd X] {a₁ b₁ a₂ b₂ : X}
(γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) (a : ↑unitInterval), (γ₁.add γ₂) a = γ₁ a + γ₂ a
|
QuadraticAlgebra.instMul
|
Mathlib.Algebra.QuadraticAlgebra.Defs
|
{R : Type u_1} → {a b : R} → [Mul R] → [Add R] → Mul (QuadraticAlgebra R a b)
|
AddConstEquiv._sizeOf_inst
|
Mathlib.Algebra.AddConstMap.Equiv
|
(G : Type u_1) →
(H : Type u_2) →
{inst : Add G} → {inst_1 : Add H} → (a : G) → (b : H) → [SizeOf G] → [SizeOf H] → SizeOf (AddConstEquiv G H a b)
|
MeasureTheory.uniformIntegrable_average
|
Mathlib.MeasureTheory.Function.UniformIntegrable
|
∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p : ENNReal} {E : Type u_4}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E],
1 ≤ p →
∀ {f : ℕ → α → E},
MeasureTheory.UniformIntegrable f p μ →
MeasureTheory.UniformIntegrable (fun n => (↑n)⁻¹ • ∑ i ∈ Finset.range n, f i) p μ
|
MonoidHom.mker_inr
|
Mathlib.Algebra.Group.Submonoid.Operations
|
∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N], MonoidHom.mker (MonoidHom.inr M N) = ⊥
|
_private.Mathlib.Algebra.TrivSqZeroExt.0.TrivSqZeroExt.isUnit_inr_iff._simp_1_3
|
Mathlib.Algebra.TrivSqZeroExt
|
∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀], IsUnit 0 = (0 = 1)
|
_private.Init.Data.BitVec.Bitblast.0.BitVec.saddOverflow_eq._simp_1_3
|
Init.Data.BitVec.Bitblast
|
∀ (p q : Prop) [dpq : Decidable (p ∧ q)] [dp : Decidable p] [dq : Decidable q], (decide p && decide q) = decide (p ∧ q)
|
PFunctor.Approx.AllAgree
|
Mathlib.Data.PFunctor.Univariate.M
|
{F : PFunctor.{uA, uB}} → ((n : ℕ) → PFunctor.Approx.CofixA F n) → Prop
|
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpConfig.match_1
|
Lean.Elab.Tactic.Simp
|
(motive : Lean.Elab.Tactic.SimpKind → Sort u_1) →
(kind : Lean.Elab.Tactic.SimpKind) →
(Unit → motive Lean.Elab.Tactic.SimpKind.simp) →
(Unit → motive Lean.Elab.Tactic.SimpKind.simpAll) → (Unit → motive Lean.Elab.Tactic.SimpKind.dsimp) → motive kind
|
_private.Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage.0.circleAverage_log_norm_sub_const₂._simp_1_1
|
Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage
|
∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε)
|
CategoryTheory.Functor.instIsEquivalenceOppositeOp
|
Mathlib.CategoryTheory.Opposites
|
∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} [F.IsEquivalence], F.op.IsEquivalence
|
Std.Sat.AIG.relabel
|
Std.Sat.AIG.Relabel
|
{α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{β : Type} → [inst_2 : Hashable β] → [inst_3 : DecidableEq β] → (α → β) → Std.Sat.AIG α → Std.Sat.AIG β
|
Std.Iterators.TaskIterator._sizeOf_1
|
Lean.Elab.Parallel
|
{α : Type w} → [SizeOf α] → Std.Iterators.TaskIterator α → ℕ
|
CoalgCat.instMonoidalCategoryStruct._proof_1
|
Mathlib.Algebra.Category.CoalgCat.Monoidal
|
∀ (R : Type u_1) [inst : CommRing R] (X : CoalgCat R), IsScalarTower R R ↑X.toModuleCat
|
Lean.Server.Watchdog.RequestQueueMap.rec
|
Lean.Server.Watchdog
|
{motive : Lean.Server.Watchdog.RequestQueueMap → Sort u} →
((i : ℕ) →
(reqs : Std.TreeMap Lean.JsonRpc.RequestID (ℕ × Lean.JsonRpc.Request Lean.Json) compare) →
(queue : Std.TreeMap ℕ (Lean.JsonRpc.RequestID × Lean.JsonRpc.Request Lean.Json) compare) →
motive { i := i, reqs := reqs, queue := queue }) →
(t : Lean.Server.Watchdog.RequestQueueMap) → motive t
|
HomotopicalAlgebra.fibrations_eq_unop
|
Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations
|
∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C],
HomotopicalAlgebra.fibrations C = (HomotopicalAlgebra.cofibrations Cᵒᵖ).unop
|
isEmpty_fintype._simp_1
|
Mathlib.Data.Fintype.EquivFin
|
∀ {α : Type u_4}, IsEmpty (Fintype α) = Infinite α
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.