name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Sat.AIG.RelabelNat.State.inv2 | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {decls : Array (Std.Sat.AIG.Decl α)} {idx : ℕ}
(self : Std.Sat.AIG.RelabelNat.State α decls idx), Std.Sat.AIG.RelabelNat.State.Inv2 decls idx self.map | true |
CategoryTheory.Discrete.monoidalFunctor_δ | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ {M : Type u} [inst : Monoid M] {N : Type u'} [inst_1 : Monoid N] (F : M →* N) (m₁ m₂ : CategoryTheory.Discrete M),
CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.Discrete.monoidalFunctor F) m₁ m₂ =
CategoryTheory.Discrete.eqToHom ⋯ | true |
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_id._simp_1_2 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_1} [inst : CategoryTheory.EnrichedCategory CategoryTheory.Cat C] {a b : CategoryTheory.CatEnriched C}
{f f' : a ⟶ b} (η : f ⟶ f'),
(CategoryTheory.CatEnriched.hComp η (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id b)) ≍ η) =
True | false |
PerfectClosure.instCommRing._proof_5 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (m : ℕ) (x : K) (n : ℕ)
(y : K) (s : ℕ) (z : K),
Quot.mk (PerfectClosure.R K p) (m, x) *
(Quot.mk (PerfectClosure.R K p) (n, y) + Quot.mk (PerfectClosure.R K p) (s, z)) =
Quot.mk (PerfectClosure.R K p) (m, x) * Quot.mk (PerfectClosure.R K p) (n, y) +
Quot.mk (PerfectClosure.R K p) (m, x) * Quot.mk (PerfectClosure.R K p) (s, z) | false |
CategoryTheory.preadditiveCoyoneda_obj | Mathlib.CategoryTheory.Preadditive.Yoneda.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (X : Cᵒᵖ),
CategoryTheory.preadditiveCoyoneda.obj X =
(CategoryTheory.preadditiveCoyonedaObj (Opposite.unop X)).comp
(CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End (Opposite.unop X))ᵐᵒᵖ) AddCommGrpCat) | true |
Lean.Elab.Term.Do.mkReturn | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Syntax → Lean.Elab.Term.Do.CodeBlock | true |
_private.Mathlib.Analysis.Asymptotics.LinearGrowth.0.LinearGrowth.EReal.eventually_atTop_exists_nat_between.match_1_3 | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {b : EReal} (motive : (a : EReal) → a < b → Prop) (a : EReal) (h : a < b),
(∀ (h : ⊤ < b), motive (some none) h) →
(∀ (h : ⊥ < b), motive none h) → (∀ (a : ℝ) (h : ↑a < b), motive (some (some a)) h) → motive a h | false |
CategoryTheory.Quotient.preadditive._proof_6 | Mathlib.CategoryTheory.Quotient.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (r : HomRel C)
[inst_2 : CategoryTheory.Congruence r]
(hr : ∀ ⦃X Y : C⦄ (f₁ f₂ g₁ g₂ : X ⟶ Y), r f₁ f₂ → r g₁ g₂ → r (f₁ + g₁) (f₂ + g₂)) (P Q : CategoryTheory.Quotient r)
(a b : P ⟶ Q), a - b = a + -b | false |
Lean.Meta.Match.Extension.Entry.name | Lean.Meta.Match.MatcherInfo | Lean.Meta.Match.Extension.Entry → Lean.Name | true |
CategoryTheory.Preadditive.instMonoNegHom | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q : C} {f : P ⟶ Q}
[CategoryTheory.Mono f], CategoryTheory.Mono (-f) | true |
_private.Lean.Environment.0.Lean.Environment.AddConstAsyncResult.allRealizationsPromise | Lean.Environment | Lean.Environment.AddConstAsyncResult → IO.Promise (Lean.NameMap Lean.AsyncConst✝) | true |
ModuleCat.HasColimit.coconePointSMul._proof_12 | Mathlib.Algebra.Category.ModuleCat.Colimits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} J]
(F : CategoryTheory.Functor J (ModuleCat R)) (r s : R) (x x_1 : J) (x_2 : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat).map (F.map x_2))
((F.obj x_1).smul (r + s)) =
CategoryTheory.CategoryStruct.comp ((F.obj x).smul (r + s))
((CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat).map (F.map x_2)) | false |
GradedTensorProduct.algebraMap_def | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ℬ]
[inst_9 : Module ι (Additive ℤˣ)] (r : R), (algebraMap R (GradedTensorProduct R 𝒜 ℬ)) r = (algebraMap R A) r ᵍ⊗ₜ[R] 1 | true |
Fin.fin_two_eq_of_eq_zero_iff | Init.Data.Fin.Lemmas | ∀ {a b : Fin 2}, (a = 0 ↔ b = 0) → a = b | true |
spectralNorm.nontriviallyNormedField | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | (K : Type u) →
[inst : NontriviallyNormedField K] →
(L : Type v) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
[Algebra.IsAlgebraic K L] → [hu : IsUltrametricDist K] → [CompleteSpace K] → NontriviallyNormedField L | true |
_private.Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas.0.iteratedDeriv_neg._simp_1_1 | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {f : 𝕜 → F}, iteratedDeriv n f = iteratedDerivWithin n f Set.univ | false |
CategoryTheory.Comonad.mk.noConfusion | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{P : Sort u} →
{toFunctor : CategoryTheory.Functor C C} →
{ε : toFunctor ⟶ CategoryTheory.Functor.id C} →
{δ : toFunctor ⟶ toFunctor.comp toFunctor} →
{coassoc :
autoParam
(∀ (X : C),
CategoryTheory.CategoryStruct.comp (δ.app X) (toFunctor.map (δ.app X)) =
CategoryTheory.CategoryStruct.comp (δ.app X) (δ.app (toFunctor.obj X)))
CategoryTheory.Comonad.coassoc._autoParam} →
{left_counit :
autoParam
(∀ (X : C),
CategoryTheory.CategoryStruct.comp (δ.app X) (ε.app (toFunctor.obj X)) =
CategoryTheory.CategoryStruct.id (toFunctor.obj X))
CategoryTheory.Comonad.left_counit._autoParam} →
{right_counit :
autoParam
(∀ (X : C),
CategoryTheory.CategoryStruct.comp (δ.app X) (toFunctor.map (ε.app X)) =
CategoryTheory.CategoryStruct.id (toFunctor.obj X))
CategoryTheory.Comonad.right_counit._autoParam} →
{toFunctor' : CategoryTheory.Functor C C} →
{ε' : toFunctor' ⟶ CategoryTheory.Functor.id C} →
{δ' : toFunctor' ⟶ toFunctor'.comp toFunctor'} →
{coassoc' :
autoParam
(∀ (X : C),
CategoryTheory.CategoryStruct.comp (δ'.app X) (toFunctor'.map (δ'.app X)) =
CategoryTheory.CategoryStruct.comp (δ'.app X) (δ'.app (toFunctor'.obj X)))
CategoryTheory.Comonad.coassoc._autoParam} →
{left_counit' :
autoParam
(∀ (X : C),
CategoryTheory.CategoryStruct.comp (δ'.app X) (ε'.app (toFunctor'.obj X)) =
CategoryTheory.CategoryStruct.id (toFunctor'.obj X))
CategoryTheory.Comonad.left_counit._autoParam} →
{right_counit' :
autoParam
(∀ (X : C),
CategoryTheory.CategoryStruct.comp (δ'.app X) (toFunctor'.map (ε'.app X)) =
CategoryTheory.CategoryStruct.id (toFunctor'.obj X))
CategoryTheory.Comonad.right_counit._autoParam} →
{ toFunctor := toFunctor, ε := ε, δ := δ, coassoc := coassoc, left_counit := left_counit,
right_counit := right_counit } =
{ toFunctor := toFunctor', ε := ε', δ := δ', coassoc := coassoc',
left_counit := left_counit', right_counit := right_counit' } →
(toFunctor ≍ toFunctor' → ε ≍ ε' → δ ≍ δ' → P) → P | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.ExBase.cast.match_1 | Mathlib.Tactic.Ring.Common | {v : Lean.Level} →
{β : Q(Type v)} →
{sβ : Q(CommSemiring «$β»)} →
(motive : (a : Q(«$β»)) × Mathlib.Tactic.Ring.ExSum sβ a → Sort u_1) →
(x : (a : Q(«$β»)) × Mathlib.Tactic.Ring.ExSum sβ a) →
((fst : Q(«$β»)) → (vb : Mathlib.Tactic.Ring.ExSum sβ fst) → motive ⟨fst, vb⟩) → motive x | false |
_private.Init.Data.List.Impl.0.List.replaceTR.go.eq_def | Init.Data.List.Impl | ∀ {α : Type u_1} [inst : BEq α] (l : List α) (b c : α) (x : List α) (x_1 : Array α),
List.replaceTR.go✝ l b c x x_1 =
match x, x_1 with
| [], x => l
| a :: as, acc => bif b == a then acc.toListAppend (c :: as) else List.replaceTR.go✝¹ l b c as (acc.push a) | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.rec_2 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Sort u} →
{motive_6 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof → Sort u} →
{motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u} →
{motive_8 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Sort u} →
{motive_9 : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof → Sort u} →
{motive_10 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Sort u} →
{motive_11 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof → Sort u} →
{motive_12 : Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u} →
{motive_13 : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u} →
{motive_14 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_15 : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u} →
{motive_16 : Array (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → Sort u} →
{motive_17 : List (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u} →
{motive_18 : List (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → Sort u} →
{motive_19 : Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_20 : Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u} →
{motive_21 : ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
((p : Int.Linear.Poly) →
(h : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof) →
motive_2 h → motive_1 { p := p, h := h }) →
((a zero : Lean.Expr) →
motive_2 (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core0 a zero)) →
((a b : Lean.Expr) →
(p₁ p₂ : Int.Linear.Poly) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core a b p₁ p₂)) →
((a b toIntThm : Lean.Expr) →
(lhs rhs : Int.Linear.Expr) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.coreToInt a b
toIntThm lhs rhs)) →
((e : Lean.Expr) →
(p : Int.Linear.Poly) →
motive_2 (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defn e p)) →
((h : Lean.Expr) →
(x : Int.Linear.Var) →
(e' : Int.Linear.Expr) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNat h x
e')) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.norm c)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.divCoeffs
c)) →
((x : Int.Linear.Var) →
(c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c₁ →
motive_1 c₂ →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.subst x
c₁ c₂)) →
((c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) →
motive_8 c₁ →
motive_8 c₂ →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe
c₁ c₂)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.reorder
c)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
(e : Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(p : Lean.Grind.CommRing.Poly) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.commRingNorm
c e p)) →
((e : Lean.Expr) →
(p : Int.Linear.Poly) →
(re : Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(rp : Lean.Grind.CommRing.Poly) →
(p' : Int.Linear.Poly) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnCommRing
e p re rp p')) →
((h : Lean.Expr) →
(x : Int.Linear.Var) →
(e' : Int.Linear.Expr) →
(p : Int.Linear.Poly) →
(re :
Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(rp : Lean.Grind.CommRing.Poly) →
(p' : Int.Linear.Poly) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNatCommRing
h x e' p re rp p')) →
((a? : Option Lean.Expr) →
(cs :
Array
(Lean.Expr ×
ℤ ×
Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
motive_13 cs →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mul
a? cs)) →
((k : ℤ) →
(y? : Option Int.Linear.Var) →
(c :
Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.div
k y? c)) →
((k : ℤ) →
(y? : Option Int.Linear.Var) →
(c :
Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod
k y? c)) →
((ka : ℤ) →
(ca? :
Option
Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
(kb : ℕ) →
(cb? :
Option
Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_14 ca? →
motive_14 cb? →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow
ka ca? kb cb?)) →
((d : ℤ) →
(p : Int.Linear.Poly) →
(h :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) →
motive_7 h →
motive_3
{ d := d, p := p, h := h }) →
((left : Bool) →
(c₁ c₂ :
Lean.Meta.Grind.Arith.Cutsat.LeCnstr) →
(c₃? :
Option
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_8 c₁ →
motive_8 c₂ →
motive_15 c₃? →
motive_4
{ left := left,
c₁ := c₁, c₂ := c₂,
c₃? := c₃? }) →
((pred :
Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred) →
(k : ℕ) →
(h :
Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof) →
motive_4 pred →
motive_6 h →
motive_5
{ pred := pred, k := k,
h := h }) →
((h : Lean.FVarId) →
motive_6
(Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof.dec
h)) →
((hs :
Array
(Lean.FVarId ×
Lean.Meta.Grind.Arith.Cutsat.UnsatProof)) →
(decVars :
Array Lean.FVarId) →
motive_16 hs →
motive_6
(Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof.last
hs decVars)) →
((e : Lean.Expr) →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.core
e)) →
((e thm : Lean.Expr) →
(d : ℕ) →
(a : Int.Linear.Expr) →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.coreOfNat
e thm d a)) →
((c :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_3 c →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.norm
c)) →
((c :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_3 c →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.divCoeffs
c)) →
((c₁ c₂ :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_3 c₁ →
motive_3 c₂ →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.solveCombine
c₁ c₂)) →
((c₁ c₂ :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_3 c₁ →
motive_3 c₂ →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.solveElim
c₁ c₂)) →
((c :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_3 c →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.elim
c)) →
⋯ | false |
AlgebraicGeometry.Scheme.Pullback.t'._proof_1 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(i j k : 𝒰.I₀),
CategoryTheory.Limits.HasPullback (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
(AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i k) | false |
MulEquiv.toMonoidHom._proof_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (h : M ≃* N) (x y : M),
h.toFun (x * y) = h.toFun x * h.toFun y | false |
OpenPartialHomeomorph.singletonChartedSpace_chartAt_eq | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} [inst : TopologicalSpace H] {α : Type u_5} [inst_1 : TopologicalSpace α] (e : OpenPartialHomeomorph α H)
(h : e.source = Set.univ) {x : α}, chartAt H x = e | true |
PresheafOfModules.colimitPresheafOfModules._proof_8 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ)
(x x_1 : ↑(R.obj X)), id (x * x_1) = id (x * x_1) | false |
ModuleCat.hom_add | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R} (f g : M ⟶ N),
ModuleCat.Hom.hom (f + g) = ModuleCat.Hom.hom f + ModuleCat.Hom.hom g | true |
MonadControl.noConfusion | Init.Control.Basic | {P : Sort u_1} →
{m : Type u → Type v} →
{n : Type u → Type w} →
{t : MonadControl m n} →
{m' : Type u → Type v} →
{n' : Type u → Type w} →
{t' : MonadControl m' n'} → m = m' → n = n' → t ≍ t' → MonadControl.noConfusionType P t t' | false |
IsCompact.diff | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsCompact s → IsOpen t → IsCompact (s \ t) | true |
Set.image_insert_eq | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α} {s : Set α}, f '' insert a s = insert (f a) (f '' s) | true |
Complex.not_continuousAt_Gamma_neg_nat | Mathlib.Analysis.SpecialFunctions.Gamma.Deriv | ∀ (n : ℕ), ¬ContinuousAt Complex.Gamma (-↑n) | true |
Associates.mkMonoidHom_apply | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M), Associates.mkMonoidHom a = Associates.mk a | true |
CategoryTheory.Triangulated.TStructure.natTransTruncLEOfLE.congr_simp | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.Triangulated.TStructure C) (a b : ℤ) (h : a ≤ b),
t.natTransTruncLEOfLE a b h = t.natTransTruncLEOfLE a b h | true |
alexandrovDiscrete_coinduced | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {β : Type u_5} {f : α → β}, AlexandrovDiscrete β | true |
DivisibleHull.instIsOrderedCancelAddMonoid | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedCancelAddMonoid M],
IsOrderedCancelAddMonoid (DivisibleHull M) | true |
Monoid.CoprodI.NeWord.inv_last | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : (i : ι) → Group (G i)] {i j : ι} (w : Monoid.CoprodI.NeWord G i j),
w.inv.last = w.head⁻¹ | true |
Lean.Elab.Command.AssertExists.isDecl | Lean.Elab.AssertExists | Lean.Elab.Command.AssertExists → Bool | true |
Lean.PrettyPrinter.Delaborator.OmissionReason.string.noConfusion | Lean.PrettyPrinter.Delaborator.Basic | {P : Sort u} →
{s s' : String} →
Lean.PrettyPrinter.Delaborator.OmissionReason.string s = Lean.PrettyPrinter.Delaborator.OmissionReason.string s' →
(s = s' → P) → P | false |
Vector.get_ofFn | Batteries.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} (f : Fin n → α) (i : Fin n), (Vector.ofFn f).get i = f i | true |
Subgroup.QuotientDiff | Mathlib.GroupTheory.SchurZassenhaus | {G : Type u_1} → [inst : Group G] → (H : Subgroup G) → [IsMulCommutative ↥H] → [H.FiniteIndex] → Type u_1 | true |
EIO.tryCatch | Init.System.IO | {ε α : Type} → EIO ε α → (ε → EIO ε α) → EIO ε α | true |
Interval.mem_pure | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ∈ Interval.pure a ↔ b = a | true |
PositiveLinearMap.instInnerProductSpaceComplexPreGNS | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | {A : Type u_1} →
[inst : NonUnitalCStarAlgebra A] →
[inst_1 : PartialOrder A] → (f : A →ₚ[ℂ] ℂ) → [inst_2 : StarOrderedRing A] → InnerProductSpace ℂ f.PreGNS | true |
Algebra.IsPushout.cancelBaseChangeAux._proof_13 | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_4) (S : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (A : Type u_2)
[inst_3 : CommRing A] [inst_4 : Algebra R A] (M : Type u_1) [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : Module A M] [inst_8 : IsScalarTower R A M],
LinearMap.CompatibleSMul (TensorProduct A (TensorProduct R A S) M) (TensorProduct A M (TensorProduct R A S)) R A | false |
MeasurableEquiv.Set.prod._proof_3 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (s : Set α) (t : Set β),
Measurable fun x => (↑x.1, ↑x.2) | false |
hasSum_of_isGLB_of_nonpos | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α]
[inst_3 : TopologicalSpace α] [OrderTopology α] {f : ι → α} (i : α),
(∀ (i : ι), f i ≤ 0) → IsGLB (Set.range fun s => ∑ i ∈ s, f i) i → HasSum f i | true |
Std.Do.ExceptConds.imp.eq_def | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} (x y : Std.Do.ExceptConds ps),
(x →ₑ y) =
match ps, x, y with
| Std.Do.PostShape.pure, x, y => PUnit.unit
| Std.Do.PostShape.arg σ ps, x, y => x →ₑ y
| Std.Do.PostShape.except ε a, x, y => (fun e => spred(x.1 e → y.1 e), x.2 →ₑ y.2) | true |
isSelfAdjoint_conjugate_iff_of_isUnit' | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {a u : R},
IsUnit u → (IsSelfAdjoint (star u * a * u) ↔ IsSelfAdjoint a) | true |
Pi.list_sum_apply | Mathlib.Algebra.BigOperators.Pi | ∀ {α : Type u_7} {M : α → Type u_8} [inst : (a : α) → AddMonoid (M a)] (a : α) (l : List ((a : α) → M a)),
l.sum a = (List.map (fun f => f a) l).sum | true |
AlgebraicGeometry.«_aux_Mathlib_AlgebraicGeometry_OpenImmersion___delab_app_AlgebraicGeometry_term_''ᵁ__1» | Mathlib.AlgebraicGeometry.OpenImmersion | Lean.PrettyPrinter.Delaborator.Delab | false |
SimpleGraph.Walk.reverse_reverse | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.reverse.reverse = p | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.KInjective.0.CochainComplex.isKInjective_of_injective_aux._proof_1_5 | Mathlib.Algebra.Homology.HomotopyCategory.KInjective | ∀ (n : ℤ), n + 1 = n + 1 | false |
Real.binEntropy_one_sub | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ (p : ℝ), Real.binEntropy (1 - p) = Real.binEntropy p | true |
CategoryTheory.Adjunction.derived._proof_2 | Mathlib.CategoryTheory.Functor.Derived.Adjunction | ∀ {C₁ : Type u_4} {C₂ : Type u_8} {D₁ : Type u_2} {D₂ : Type u_6} [inst : CategoryTheory.Category.{u_3, u_4} C₁]
[inst_1 : CategoryTheory.Category.{u_7, u_8} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} D₁]
[inst_3 : CategoryTheory.Category.{u_5, u_6} D₂] {G : CategoryTheory.Functor C₁ C₂} {F : CategoryTheory.Functor C₂ C₁}
(adj : G ⊣ F) {L₁ : CategoryTheory.Functor C₁ D₁} {L₂ : CategoryTheory.Functor C₂ D₂}
(W₁ : CategoryTheory.MorphismProperty C₁) [inst_4 : L₁.IsLocalization W₁] {G' : CategoryTheory.Functor D₁ D₂}
{F' : CategoryTheory.Functor D₂ D₁} (α : L₁.comp G' ⟶ G.comp L₂) (β : F.comp L₁ ⟶ L₂.comp F')
[inst_5 :
(G'.comp F').IsLeftDerivedFunctor
(CategoryTheory.CategoryStruct.comp (L₁.associator G' F').inv (CategoryTheory.Functor.whiskerRight α F')) W₁]
(X₁ : C₁),
CategoryTheory.CategoryStruct.comp ((adj.derivedη W₁ α β).app (L₁.obj X₁)) (F'.map (α.app X₁)) =
CategoryTheory.CategoryStruct.comp (L₁.map (adj.unit.app X₁)) (β.app (G.obj X₁)) | false |
MonoidAlgebra.mapAlgEquiv_apply | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_1) {A : Type u_4} {B : Type u_5} (M : Type u_7) [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Monoid M] (e : A ≃ₐ[R] B)
(a : MonoidAlgebra A M), (MonoidAlgebra.mapAlgEquiv R M e) a = (↑↑(MonoidAlgebra.mapAlgHom M ↑e).toRingHom).toFun a | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGT?.go.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] (k : α) (best : Option (α × β)) (size : ℕ) (k' : α) (v' : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.getEntryGT?.go k best (Std.DTreeMap.Internal.Impl.inner size k' v' l r) =
match compare k k' with
| Ordering.lt => Std.DTreeMap.Internal.Impl.Const.getEntryGT?.go k (some (k', v')) l
| x => Std.DTreeMap.Internal.Impl.Const.getEntryGT?.go k best r | true |
EReal.recENNReal_coe_ennreal | Mathlib.Data.EReal.Operations | ∀ {motive : EReal → Sort u_1} (coe : (x : ENNReal) → motive ↑x) (neg_coe : (x : ENNReal) → 0 < x → motive (-↑x))
(x : ENNReal), EReal.recENNReal coe neg_coe ↑x = coe x | true |
_private.Lean.Compiler.IR.NormIds.0.Lean.IR.NormalizeIds.normFnBody.match_1 | Lean.Compiler.IR.NormIds | (motive : Array Lean.IR.Param × Lean.IR.FnBody → Sort u_1) →
(__discr : Array Lean.IR.Param × Lean.IR.FnBody) →
((ys : Array Lean.IR.Param) → (v : Lean.IR.FnBody) → motive (ys, v)) → motive __discr | false |
AddEquiv.symm.eq_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} [inst : Add M] [inst_1 : Add N] (h : M ≃+ N),
h.symm = { toEquiv := h.symm, map_add' := ⋯ } | true |
_private.Init.Data.List.TakeDrop.0.List.drop_left.match_1_1 | Init.Data.List.TakeDrop | ∀ {α : Type u_1} (motive : List α → List α → Prop) (x x_1 : List α),
(∀ (x : List α), motive [] x) → (∀ (head : α) (l₁ x : List α), motive (head :: l₁) x) → motive x x_1 | false |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.analyze.go.match_1 | Lean.Elab.Extra | (motive : Lean.Elab.Term.Op.Tree✝ → Sort u_1) →
(t : Lean.Elab.Term.Op.Tree✝¹) →
((macroName : Lean.Name) →
(stx stx' : Lean.Syntax) →
(nested : Lean.Elab.Term.Op.Tree✝²) →
motive (Lean.Elab.Term.Op.Tree.macroExpansion✝ macroName stx stx' nested)) →
((ref : Lean.Syntax) →
(f : Lean.Expr) →
(lhs rhs : Lean.Elab.Term.Op.Tree✝³) →
motive (Lean.Elab.Term.Op.Tree.binop✝ ref Lean.Elab.Term.Op.BinOpKind.leftact✝ f lhs rhs)) →
((ref : Lean.Syntax) →
(f : Lean.Expr) →
(lhs rhs : Lean.Elab.Term.Op.Tree✝⁴) →
motive (Lean.Elab.Term.Op.Tree.binop✝¹ ref Lean.Elab.Term.Op.BinOpKind.rightact✝ f lhs rhs)) →
((ref : Lean.Syntax) →
(kind : Lean.Elab.Term.Op.BinOpKind✝) →
(f : Lean.Expr) →
(lhs rhs : Lean.Elab.Term.Op.Tree✝⁵) → motive (Lean.Elab.Term.Op.Tree.binop✝² ref kind f lhs rhs)) →
((ref : Lean.Syntax) →
(f : Lean.Expr) → (arg : Lean.Elab.Term.Op.Tree✝⁶) → motive (Lean.Elab.Term.Op.Tree.unop✝ ref f arg)) →
((ref : Lean.Syntax) →
(infoTrees : Lean.PersistentArray Lean.Elab.InfoTree) →
(val : Lean.Expr) → motive (Lean.Elab.Term.Op.Tree.term✝ ref infoTrees val)) →
motive t | false |
LieDerivation.SMulBracketCommClass.casesOn | Mathlib.Algebra.Lie.Derivation.Basic | {S : Type u_4} →
{L : Type u_5} →
{α : Type u_6} →
[inst : SMul S α] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup α] →
[inst_3 : LieRingModule L α] →
{motive : LieDerivation.SMulBracketCommClass S L α → Sort u} →
(t : LieDerivation.SMulBracketCommClass S L α) →
((smul_bracket_comm : ∀ (s : S) (l : L) (a : α), s • ⁅l, a⁆ = ⁅l, s • a⁆) → motive ⋯) → motive t | false |
CategoryTheory.PreOneHypercover.Hom.s₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
(self : E.Hom F) → {i j : E.I₀} → E.I₁ i j → F.I₁ (self.s₀ i) (self.s₀ j) | true |
Finset.powersetCard_mono | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} {s t : Finset α}, s ⊆ t → Finset.powersetCard n s ⊆ Finset.powersetCard n t | true |
groupHomology.comp_d₂₁_eq | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
CategoryTheory.CategoryStruct.comp (groupHomology.chainsIso₂ A).hom (groupHomology.d₂₁ A) =
CategoryTheory.CategoryStruct.comp ((groupHomology.inhomogeneousChains A).d 2 1) (groupHomology.chainsIso₁ A).hom | true |
CategoryTheory.Precoverage.ZeroHypercover.Small.Index | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Precoverage C} → {S : C} → (E : J.ZeroHypercover S) → [E.Small] → Type w' | true |
_private.Mathlib.Analysis.Normed.Ring.Units.0.NormedRing.inverse_add_norm._simp_1_2 | Mathlib.Analysis.Normed.Ring.Units | ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -(a * b) = -a * b | false |
Int.mul.eq_2 | Init.Data.Int.Order | ∀ (m_2 n_2 : ℕ), (Int.ofNat m_2).mul (Int.negSucc n_2) = Int.negOfNat (m_2 * n_2.succ) | true |
Filter.Germ.map_const | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (l : Filter α) (a : β) (f : β → γ), Filter.Germ.map f ↑a = ↑(f a) | true |
CategoryTheory.Limits.pullbackConeOfLeftIso_π_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso f],
(CategoryTheory.Limits.pullbackConeOfLeftIso f g).π.app CategoryTheory.Limits.WalkingCospan.left =
CategoryTheory.CategoryStruct.comp g (CategoryTheory.inv f) | true |
Finsupp.mem_rangeSingleton_apply_iff | Mathlib.Data.Finsupp.Interval | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] {f : ι →₀ α} {i : ι} {a : α}, a ∈ f.rangeSingleton i ↔ a = f i | true |
Lean.Elab.Term.MVarErrorInfo.noConfusionType | Lean.Elab.Term.TermElabM | Sort u → Lean.Elab.Term.MVarErrorInfo → Lean.Elab.Term.MVarErrorInfo → Sort u | false |
WeierstrassCurve.Projective.eval_polynomial_of_Z_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P : Fin 3 → F},
P 2 ≠ 0 →
(MvPolynomial.eval P) W.polynomial / P 2 ^ 3 = Polynomial.evalEval (P 0 / P 2) (P 1 / P 2) W.toAffine.polynomial | true |
Matroid.contract_eq_contract_iff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {C₁ C₂ : Set α}, M.contract C₁ = M.contract C₂ ↔ C₁ ∩ M.E = C₂ ∩ M.E | true |
Stream'.WSeq.map | Mathlib.Data.WSeq.Basic | {α : Type u} → {β : Type v} → (α → β) → Stream'.WSeq α → Stream'.WSeq β | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.incCount | Lean.Meta.LetToHave | Lean.Meta.LetToHave.M✝ Unit | true |
Lean.Meta.InductionSubgoal._sizeOf_1 | Lean.Meta.Tactic.Induction | Lean.Meta.InductionSubgoal → ℕ | false |
Finsupp.induction | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddZeroClass M] {motive : (ι →₀ M) → Prop} (f : ι →₀ M),
motive 0 →
(∀ (a : ι) (b : M) (f : ι →₀ M), a ∉ f.support → b ≠ 0 → motive f → motive ((fun₀ | a => b) + f)) → motive f | true |
TopCat.forget_preservesColimitsOfSize | Mathlib.Topology.Category.TopCat.Limits.Basic | CategoryTheory.Limits.PreservesColimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget TopCat) | true |
CategoryTheory.CommGrp.instFullGrpForget₂Grp | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C], (CategoryTheory.CommGrp.forget₂Grp C).Full | true |
SubMulAction.orbitRel_of_subMul | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : Group R] [inst_1 : MulAction R M] (p : SubMulAction R M),
MulAction.orbitRel R ↥p = Setoid.comap Subtype.val (MulAction.orbitRel R M) | true |
ZNum.addMonoidWithOne | Mathlib.Data.Num.ZNum | AddMonoidWithOne ZNum | true |
HasDerivWithinAt.comp_hasDerivAt_of_eq | Mathlib.Analysis.Calculus.Deriv.Comp | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜) {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {h : 𝕜 → 𝕜'} {h₂ : 𝕜' → 𝕜'} {h' h₂' y : 𝕜'} {t : Set 𝕜'},
HasDerivWithinAt h₂ h₂' t y →
HasDerivAt h h' x → (∀ᶠ (x' : 𝕜) in nhds x, h x' ∈ t) → y = h x → HasDerivAt (h₂ ∘ h) (h₂' * h') x | true |
Int.le_add_of_neg_le_sub_left | Init.Data.Int.Order | ∀ {a b c : ℤ}, -a ≤ b - c → c ≤ a + b | true |
InnerProductSpace.ringOfCoalgebra._proof_17 | Mathlib.Analysis.InnerProductSpace.Coalgebra | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] [inst_4 : Coalgebra 𝕜 E] (n : ℕ) (x : E), npowRecAuto (n + 1) x = npowRecAuto n x * x | false |
PartialOrder.ext_lt | Mathlib.Order.Basic | ∀ {α : Type u_2} {A B : PartialOrder α}, (∀ (x y : α), x < y ↔ x < y) → A = B | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.TwoPowShiftTarget.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | Sort u →
{α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.TwoPowShiftTarget aig w →
{α' : Type} →
[inst' : Hashable α'] →
[inst'_1 : DecidableEq α'] →
{aig' : Std.Sat.AIG α'} →
{w' : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.TwoPowShiftTarget aig' w' → Sort u | false |
_private.Lean.Server.Logging.0.Lean.Server.Logging.messageMethod?._sparseCasesOn_4 | Lean.Server.Logging | {motive : Lean.JsonRpc.Message → Sort u} →
(t : Lean.JsonRpc.Message) →
((id : Lean.JsonRpc.RequestID) →
(method : String) →
(params? : Option Lean.Json.Structured) → motive (Lean.JsonRpc.Message.request id method params?)) →
((method : String) →
(params? : Option Lean.Json.Structured) → motive (Lean.JsonRpc.Message.notification method params?)) →
(Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Limits.lim_map | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C] {X Y : CategoryTheory.Functor J C} (α : X ⟶ Y),
CategoryTheory.Limits.lim.map α = CategoryTheory.Limits.limMap α | true |
Lean.Server.RpcEncodable.rec | Lean.Server.Rpc.Basic | {α : Type} →
{motive : Lean.Server.RpcEncodable α → Sort u} →
((rpcEncode : α → StateM Lean.Server.RpcObjectStore Lean.Json) →
(rpcDecode : Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) α) →
motive { rpcEncode := rpcEncode, rpcDecode := rpcDecode }) →
(t : Lean.Server.RpcEncodable α) → motive t | false |
BoxIntegral.Prepartition.distortion_of_const | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) [inst : Fintype ι] {c : NNReal},
π.boxes.Nonempty → (∀ J ∈ π, J.distortion = c) → π.distortion = c | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.uniformSpace_eq_inf_precomp_of_cover._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (s ⊆ f ⁻¹' t) = (f '' s ⊆ t) | false |
CategoryTheory.Functor.cartesianMonoidalCategory._proof_7 | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} J]
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : CategoryTheory.Functor J C),
{ app := fun x => CategoryTheory.SemiCartesianMonoidalCategory.snd (X.obj x) (Y.obj x), naturality := ⋯ } =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Limits.IsTerminal.from
(CategoryTheory.Limits.evaluationJointlyReflectsLimits
(CategoryTheory.Limits.asEmptyCone
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor J C)))
fun x =>
CategoryTheory.Limits.isLimitChangeEmptyCone C
CategoryTheory.SemiCartesianMonoidalCategory.isTerminalTensorUnit
(((CategoryTheory.evaluation J C).obj x).mapCone
(CategoryTheory.Limits.asEmptyCone
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor J C))))
(CategoryTheory.Iso.refl
(CategoryTheory.Limits.asEmptyCone (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).pt))
X)
Y)
(CategoryTheory.MonoidalCategoryStruct.leftUnitor Y).hom | false |
SemigroupAction.noConfusion | Mathlib.Algebra.Group.Action.Defs | {P : Sort u} →
{α : Type u_9} →
{β : Type u_10} →
{inst : Semigroup α} →
{t : SemigroupAction α β} →
{α' : Type u_9} →
{β' : Type u_10} →
{inst' : Semigroup α'} →
{t' : SemigroupAction α' β'} →
α = α' → β = β' → inst ≍ inst' → t ≍ t' → SemigroupAction.noConfusionType P t t' | false |
sSup_range | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : SupSet α] {f : ι → α}, sSup (Set.range f) = iSup f | true |
CategoryTheory.Pi.η_def | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] (i : I),
CategoryTheory.Functor.OplaxMonoidal.η (CategoryTheory.Pi.eval C i) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit (C i)) | true |
IsPrimitiveRoot.IsCyclotomicExtension.ringOfIntegersOfPrimePow | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p k : ℕ} {K : Type u} [inst : Field K] [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[IsCyclotomicExtension {p ^ k} ℚ K], IsCyclotomicExtension {p ^ k} ℤ (NumberField.RingOfIntegers K) | true |
Std.HashSet.Raw.get!_erase | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : Inhabited α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k a : α}, (m.erase k).get! a = if (k == a) = true then default else m.get! a | true |
ValuativeRel.IsNontrivial.rec | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : CommRing R] →
[inst_1 : ValuativeRel R] →
{motive : ValuativeRel.IsNontrivial R → Sort u} →
((condition : ∃ γ, γ ≠ 0 ∧ γ ≠ 1) → motive ⋯) → (t : ValuativeRel.IsNontrivial R) → motive t | false |
norm_iteratedFDeriv_fderiv | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : 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] {f : E → F}
{x : E} {n : ℕ}, ‖iteratedFDeriv 𝕜 n (fderiv 𝕜 f) x‖ = ‖iteratedFDeriv 𝕜 (n + 1) f x‖ | true |
nsmul_add | Mathlib.Algebra.Group.Basic | ∀ {M : Type u_4} [inst : AddCommMonoid M] (a b : M) (n : ℕ), n • (a + b) = n • a + n • b | true |
Lean.Meta.Grind.AC.EqCnstrProof.simp_middle.noConfusion | Lean.Meta.Tactic.Grind.AC.Types | {P : Sort u} →
{lhs : Bool} →
{s₁ s₂ : Lean.Grind.AC.Seq} →
{c₁ c₂ : Lean.Meta.Grind.AC.EqCnstr} →
{lhs' : Bool} →
{s₁' s₂' : Lean.Grind.AC.Seq} →
{c₁' c₂' : Lean.Meta.Grind.AC.EqCnstr} →
Lean.Meta.Grind.AC.EqCnstrProof.simp_middle lhs s₁ s₂ c₁ c₂ =
Lean.Meta.Grind.AC.EqCnstrProof.simp_middle lhs' s₁' s₂' c₁' c₂' →
(lhs = lhs' → s₁ = s₁' → s₂ = s₂' → c₁ = c₁' → c₂ = c₂' → P) → P | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.