name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AddConstMap._aux_Mathlib_Algebra_AddConstMap_Basic___unexpand_AddConstMap_1 | Mathlib.Algebra.AddConstMap.Basic | Lean.PrettyPrinter.Unexpander | false |
ENNReal.natCast_lt_top | Mathlib.Data.ENNReal.Basic | ∀ (n : ℕ), ↑n < ⊤ | true |
Nat.doubleFactorial.eq_3 | Mathlib.Data.Nat.Factorial.DoubleFactorial | ∀ (k : ℕ), k.succ.succ.doubleFactorial = (k + 2) * k.doubleFactorial | true |
List.next_getLast_eq_head | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α) (h : l ≠ []), l.Nodup → l.next (l.getLast h) ⋯ = l.head h | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.shiftLeft_add._proof_1_2 | Init.Data.UInt.Bitwise | ∀ {b c : UInt32}, b.toNat < 32 → c.toNat < 32 → ¬b.toNat + c.toNat < 4294967296 → False | false |
Algebra.IsAlgebraic.algEquivEquivAlgHom._proof_2 | Mathlib.RingTheory.Algebraic.Basic | ∀ (K : Type u_2) (L : Type u_1) [inst : CommRing K] [inst_1 : IsDomain K] [inst_2 : Field L] [inst_3 : Algebra K L]
[inst_4 : Module.IsTorsionFree K L] [inst_5 : Algebra.IsAlgebraic K L],
Function.RightInverse (fun ϕ => AlgEquiv.ofBijective ϕ ⋯) fun ϕ => ↑ϕ | false |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem.0.MvPolynomial.supDegree_monic_esymm._simp_1_2 | Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | ∀ {α : Type u_1} {M : Type u_8} [inst : AddCommMonoid M] (s : Finset α) (f : α → M),
(∑ x ∈ s, fun₀ | x => f x) = Finsupp.indicator s fun x x_1 => f x | false |
CategoryTheory.HasShift.noConfusion | Mathlib.CategoryTheory.Shift.Basic | {P : Sort u_1} →
{C : Type u} →
{A : Type u_2} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : AddMonoid A} →
{t : CategoryTheory.HasShift C A} →
{C' : Type u} →
{A' : Type u_2} →
{inst' : CategoryTheory.Category.{v, u} C'} →
{inst'_1 : AddMonoid A'} →
{t' : CategoryTheory.HasShift C' A'} →
C = C' →
A = A' →
inst ≍ inst' → inst_1 ≍ inst'_1 → t ≍ t' → CategoryTheory.HasShift.noConfusionType P t t' | false |
StrictConcaveOn.lt_slope_of_hasDerivWithinAt | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x y f' : ℝ},
StrictConcaveOn ℝ S f → x ∈ S → y ∈ S → x < y → HasDerivWithinAt f f' S y → f' < slope f x y | true |
Finsupp.instSemigroupWithZero._proof_1 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : SemigroupWithZero β], Function.Injective fun f => ⇑f | false |
Lean.Meta.Grind.Arith.isNatType | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Bool | true |
Lean.Elab.Term.withoutHeedElabAsElim | Lean.Elab.Term.TermElabM | {m : Type → Type u_1} → {α : Type} → [MonadFunctorT Lean.Elab.TermElabM m] → m α → m α | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.natDegree_coeff_ΨSq_ofNat | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (n : ℕ),
(W.ΨSq ↑n).natDegree ≤ n ^ 2 - 1 ∧ (W.ΨSq ↑n).coeff (n ^ 2 - 1) = ↑(↑n ^ 2) | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₃_eq_some_of_toBitVec._simp_1_9 | Init.Data.String.Decode | ∀ {n : ℕ} {x y : BitVec n}, (x = y) = (x.toNat = y.toNat) | false |
IsAlgClosed.exists_root | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {k : Type u} [inst : Field k] [IsAlgClosed k] (p : Polynomial k), p.degree ≠ 0 → ∃ x, p.IsRoot x | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc.0.CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Assoc___macroRules__private_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Assoc_0_CategoryTheory_Limits_termF₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | Lean.Macro | false |
CategoryTheory.IsHomLift.instIsHomLiftIdObj | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) (a : 𝒳),
p.IsHomLift (CategoryTheory.CategoryStruct.id (p.obj a)) (CategoryTheory.CategoryStruct.id a) | true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.ofDigits_inj_of_len_eq._simp_1_2 | Mathlib.Data.Nat.Digits.Defs | ∀ {G : Type u_1} [inst : Add G] [IsLeftCancelAdd G] (a : G) {b c : G}, (a + b = a + c) = (b = c) | false |
HahnSeries.single_zero_ratCast | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_3} [inst : Zero Γ] [inst_1 : PartialOrder Γ] [inst_2 : Zero R] [inst_3 : RatCast R]
(q : ℚ), (HahnSeries.single 0) ↑q = ↑q | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rio.toList_succ_eq_map._simp_1_10 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α] {a b : α},
Std.PRange.UpwardEnumerable.LT (Std.PRange.succ a) (Std.PRange.succ b) = Std.PRange.UpwardEnumerable.LT a b | false |
Std.Tactic.BVDecide.BVExpr.shiftLeft._override | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {m n : ℕ} → Std.Tactic.BVDecide.BVExpr m → Std.Tactic.BVDecide.BVExpr n → Std.Tactic.BVDecide.BVExpr m | false |
Batteries.Tactic._aux_Batteries_Tactic_Init___macroRules_Batteries_Tactic_tacticSplit_ands_1 | Batteries.Tactic.Init | Lean.Macro | false |
ContinuousAddMonoidHom.instAddCommMonoid.eq_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_2} {E : Type u_6} [inst : AddMonoid A] [inst_1 : TopologicalSpace A] [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E],
ContinuousAddMonoidHom.instAddCommMonoid =
{ add := fun f g => (ContinuousAddMonoidHom.add E).comp (f.prod g), add_assoc := ⋯,
toZero := ContinuousAddMonoidHom.instZero A E, zero_add := ⋯, add_zero := ⋯, nsmul := nsmulRecAuto,
nsmul_zero := ⋯, nsmul_succ := ⋯, add_comm := ⋯ } | true |
CategoryTheory.Arrow.isIso_iff_isIso_of_isIso | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {W X Y Z : T} {f : W ⟶ X} {g : Y ⟶ Z}
(sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) [CategoryTheory.IsIso sq],
CategoryTheory.IsIso f ↔ CategoryTheory.IsIso g | true |
List.dropSlice_eq_dropSliceTR | Batteries.Data.List.Basic | @List.dropSlice = @List.dropSliceTR | true |
Option.forM_map | Init.Data.Option.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} [inst : Monad m] [LawfulMonad m] (o : Option α) (g : α → β)
(f : β → m PUnit.{u_1 + 1}), forM (Option.map g o) f = forM o fun a => f (g a) | true |
_private.Init.System.FilePath.0.System.FilePath.posOfLastSep | Init.System.FilePath | System.FilePath → Option String.Pos.Raw | true |
ModuleCat.CoextendScalars.distribMulAction._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) (M : Type u_3)
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (s : S)
(g h : ↑((ModuleCat.restrictScalars f).obj (ModuleCat.of S S)) →ₗ[R] M), s • (g + h) = s • g + s • h | false |
TopologicalSpace.NonemptyCompacts.instNontrivial | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [Nontrivial α], Nontrivial (TopologicalSpace.NonemptyCompacts α) | true |
Submonoid.LocalizationMap.isCancelMul | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : CommMonoid M] {S : Submonoid M} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N) [IsCancelMul M], IsCancelMul N | true |
Fintype.truncRecEmptyOption | Mathlib.Data.Fintype.Option | {P : Type u → Sort v} →
({α β : Type u} → α ≃ β → P α → P β) →
P PEmpty.{u + 1} →
({α : Type u} → [Fintype α] → [DecidableEq α] → P α → P (Option α)) →
(α : Type u) → [Fintype α] → [DecidableEq α] → Trunc (P α) | true |
Exists.snd | Mathlib.Logic.Basic | ∀ {b : Prop} {p : b → Prop} (h : Exists p), p ⋯ | true |
Lean.Meta.Sym.ApplyResult.ctorElimType | Lean.Meta.Sym.Apply | {motive : Lean.Meta.Sym.ApplyResult → Sort u} → ℕ → Sort (max 1 u) | false |
UniformEquiv.range_coe | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} {β : Type u_1} [inst : UniformSpace α] [inst_1 : UniformSpace β] (h : α ≃ᵤ β), Set.range ⇑h = Set.univ | true |
CategoryTheory.typeEquiv._proof_2 | Mathlib.CategoryTheory.Sites.Types | ∀ (X : Type u_1),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.yoneda'.map
((CategoryTheory.NatIso.ofComponents
(fun _α => { hom := fun x x_1 => x, inv := fun f => f PUnit.unit, hom_inv_id := ⋯, inv_hom_id := ⋯ })
⋯).hom.app
X))
((CategoryTheory.NatIso.ofComponents (fun S => CategoryTheory.equivYoneda' S) ⋯).symm.hom.app
(CategoryTheory.yoneda'.obj X)) =
CategoryTheory.CategoryStruct.id (CategoryTheory.yoneda'.obj X) | false |
Turing.TM0to1.tr.eq_3 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} [inst : Inhabited Λ] (M : Turing.TM0.Machine Γ Λ) (a : Γ) (q : Λ),
Turing.TM0to1.tr M (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.write a) q) =
Turing.TM1.Stmt.write (fun x x_1 => a) (Turing.TM1.Stmt.goto fun x x_1 => Turing.TM0to1.Λ'.normal q) | true |
CategoryTheory.MonoidalCategory._aux_Mathlib_CategoryTheory_Monoidal_Category___unexpand_CategoryTheory_MonoidalCategory_whiskerLeftIso_1 | Mathlib.CategoryTheory.Monoidal.Category | Lean.PrettyPrinter.Unexpander | false |
Std.Time.Duration.addSeconds | Std.Time.Duration | Std.Time.Duration → Std.Time.Second.Offset → Std.Time.Duration | true |
Computation.liftRelAux_inr_inl | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} {R : α → β → Prop} {C : Computation α → Computation β → Prop} {b : β} {ca : Computation α},
Computation.LiftRelAux R C (Sum.inr ca) (Sum.inl b) = ∃ a ∈ ca, R a b | true |
CategoryTheory.Functor.preimageIso._proof_4 | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) {X Y : C} [inst_2 : F.Full]
[F.Faithful] (f : F.obj X ≅ F.obj Y),
CategoryTheory.CategoryStruct.comp (F.preimage f.inv) (F.preimage f.hom) = CategoryTheory.CategoryStruct.id Y | false |
BddAbove.isBounded_inter | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} {s t : Set α} [inst : Bornology α] [inst_1 : Preorder α] [IsOrderBornology α],
BddAbove s → BddBelow t → Bornology.IsBounded (s ∩ t) | true |
CategoryTheory.Triangulated.TStructure.instIsLEObjTruncGE | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} 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) [CategoryTheory.IsTriangulated C] (X : C) (a b : ℤ) [t.IsLE X b],
t.IsLE ((t.truncGE a).obj X) b | true |
AlgHom.cancel_left | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
{g₁ g₂ : A →ₐ[R] B} {f : B →ₐ[R] C}, Function.Injective ⇑f → (f.comp g₁ = f.comp g₂ ↔ g₁ = g₂) | true |
CommAlgCat.hasForgetToCommRingCat._proof_4 | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u_1} [inst : CommRing R],
{ obj := fun A => CommRingCat.of ↑A, map := fun {X Y} f => CommRingCat.ofHom (CommAlgCat.Hom.hom f).toRingHom,
map_id := ⋯, map_comp := ⋯ }.comp
(CategoryTheory.forget CommRingCat) =
CategoryTheory.forget (CommAlgCat R) | false |
CategoryTheory.Comonad.Coalgebra.Hom.ext' | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} (X Y : G.Coalgebra)
(f g : X ⟶ Y), f.f = g.f → f = g | true |
BoundedLatticeHom.mk.congr_simp | Mathlib.Order.Category.BddDistLat | ∀ {α : Type u_6} {β : Type u_7} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder α]
[inst_3 : BoundedOrder β] (toLatticeHom toLatticeHom_1 : LatticeHom α β)
(e_toLatticeHom : toLatticeHom = toLatticeHom_1) (map_top' : toLatticeHom.toFun ⊤ = ⊤)
(map_bot' : toLatticeHom.toFun ⊥ = ⊥),
{ toLatticeHom := toLatticeHom, map_top' := map_top', map_bot' := map_bot' } =
{ toLatticeHom := toLatticeHom_1, map_top' := ⋯, map_bot' := ⋯ } | true |
smulMonoidWithZeroHom._proof_3 | Mathlib.Algebra.GroupWithZero.Action.Basic | ∀ {M₀ : Type u_1} {N₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : MulZeroOneClass N₀]
[inst_2 : MulActionWithZero M₀ N₀] [inst_3 : IsScalarTower M₀ N₀ N₀] [inst_4 : SMulCommClass M₀ N₀ N₀]
(x y : M₀ × N₀), (↑smulMonoidHom).toFun (x * y) = (↑smulMonoidHom).toFun x * (↑smulMonoidHom).toFun y | false |
BddDistLat.Hom.noConfusion | Mathlib.Order.Category.BddDistLat | {P : Sort u_1} →
{X Y : BddDistLat} →
{t : X.Hom Y} →
{X' Y' : BddDistLat} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → BddDistLat.Hom.noConfusionType P t t' | false |
MonoidHom.noncommCoprod_apply' | Mathlib.GroupTheory.NoncommCoprod | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : Monoid P]
(f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n)) (mn : M × N),
(f.noncommCoprod g comm) mn = g mn.2 * f mn.1 | true |
CategoryTheory.ObjectProperty.SerreClassLocalization.inverseImage_monomorphisms | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] (L : CategoryTheory.Functor C D) (P : CategoryTheory.ObjectProperty C)
[inst_3 : P.IsSerreClass] [L.IsLocalization P.isoModSerre] [inst_5 : CategoryTheory.Preadditive D] [L.Additive],
(CategoryTheory.MorphismProperty.monomorphisms D).inverseImage L = P.monoModSerre | true |
DoResultSBC.recOn | Init.Core | {α σ : Type u} →
{motive : DoResultSBC α σ → Sort u_1} →
(t : DoResultSBC α σ) →
((a : α) → (a_1 : σ) → motive (DoResultSBC.pureReturn a a_1)) →
((a : σ) → motive (DoResultSBC.break a)) → ((a : σ) → motive (DoResultSBC.continue a)) → motive t | false |
CategoryTheory.Limits.prod.braiding | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(P Q : C) →
[inst_1 : CategoryTheory.Limits.HasBinaryProduct P Q] →
[inst_2 : CategoryTheory.Limits.HasBinaryProduct Q P] → P ⨯ Q ≅ Q ⨯ P | true |
_private.Init.Data.Vector.Lemmas.0.Vector.sum_reverse._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : Add α] [inst_1 : Zero α] {xs : Vector α n}, xs.sum = xs.toList.sum | false |
Lean.Syntax.Traverser._sizeOf_inst | Lean.Syntax | SizeOf Lean.Syntax.Traverser | false |
HasSubset.Subset.diff_ssubset_of_nonempty | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → s.Nonempty → t \ s ⊂ t | true |
HahnSeries.SummableFamily.smul_apply | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} {α : Type u_5} [inst : PartialOrder Γ]
[inst_1 : PartialOrder Γ'] [inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid R] [inst_4 : SMulWithZero R V]
[inst_5 : VAdd Γ Γ'] [inst_6 : IsOrderedCancelVAdd Γ Γ'] {x : HahnSeries Γ R} {s : HahnSeries.SummableFamily Γ' V α}
{a : α}, (x • s) a = (HahnModule.of R).symm (x • (HahnModule.of R) (s a)) | true |
NormedCommGroup.ofMulDist' | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} →
[inst : Norm E] →
[inst_1 : CommGroup E] →
[inst_2 : MetricSpace E] →
(∀ (x : E), ‖x‖ = dist 1 x) → (∀ (x y z : E), dist (z * x) (z * y) ≤ dist x y) → NormedCommGroup E | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage._proof_1 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Preregular C]
[CategoryTheory.FinitaryExtensive C], CategoryTheory.Precoherent C | false |
CochainComplex.mappingConeCompTriangleh_comm₁_assoc | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ X₃ : CochainComplex C ℤ} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
{Z : HomotopyCategory C (ComplexShape.up ℤ)}
(h :
(HomotopyCategory.quotient C (ComplexShape.up ℤ)).obj
(CochainComplex.mappingCone (CochainComplex.mappingConeCompTriangle f g).mor₁) ⟶
Z),
CategoryTheory.CategoryStruct.comp (CochainComplex.mappingConeCompTriangleh f g).mor₂
(CategoryTheory.CategoryStruct.comp
((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (CochainComplex.mappingConeCompHomotopyEquiv f g).hom)
h) =
CategoryTheory.CategoryStruct.comp
((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map
(CochainComplex.mappingCone.inr (CochainComplex.mappingConeCompTriangle f g).mor₁))
h | true |
FloatSpec.ctorIdx | Init.Data.Float | FloatSpec → ℕ | false |
LeanSearchClient.SearchServer.rec | LeanSearchClient.Syntax | {motive : LeanSearchClient.SearchServer → Sort u} →
((name url cmd : String) →
(query : String → ℕ → Lean.MetaM (Array LeanSearchClient.SearchResult)) →
(queryNum : Lean.CoreM ℕ) →
motive { name := name, url := url, cmd := cmd, query := query, queryNum := queryNum }) →
(t : LeanSearchClient.SearchServer) → motive t | false |
Algebra.IsEffective.of_section | Mathlib.RingTheory.TensorProduct.IncludeLeftSubRight | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : Ring S] [inst_2 : Algebra R S] (g : S →ₐ[R] R),
Algebra.IsEffective R S | true |
CategoryTheory.Limits.DiagramOfCones.conePoints_map | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} (D : CategoryTheory.Limits.DiagramOfCones F) {X Y : J}
(f : X ⟶ Y), D.conePoints.map f = (D.map f).hom | true |
CategoryTheory.DifferentialObject.instHasShift._proof_1 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddCommGroupWithOne S] (C : Type u_2) [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S] (m₁ m₂ m₃ : S)
(X : CategoryTheory.DifferentialObject S C),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.DifferentialObject.shiftFunctorAdd C (m₁ + m₂) m₃).hom.app X)
((CategoryTheory.DifferentialObject.shiftFunctor C m₃).map
((CategoryTheory.DifferentialObject.shiftFunctorAdd C m₁ m₂).hom.app X)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.DifferentialObject.shiftFunctorAdd C m₁ (m₂ + m₃)).hom.app X)
((CategoryTheory.DifferentialObject.shiftFunctorAdd C m₂ m₃).hom.app
((CategoryTheory.DifferentialObject.shiftFunctor C m₁).obj X))) | false |
MonCat.Colimits.instInhabitedColimitType | Mathlib.Algebra.Category.MonCat.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{u, v} J] →
(F : CategoryTheory.Functor J MonCat) → Inhabited (MonCat.Colimits.ColimitType F) | true |
LinearMap.exists_mem_center_apply_eq_smul_of_forall_notLinearIndependent | Mathlib.LinearAlgebra.Center | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [IsDomain R] [StrongRankCondition R] [inst_3 : AddCommGroup V]
[inst_4 : Module R V] [Module.Free R V] {f : V →ₗ[R] V},
Module.finrank R V ≠ 1 → (∀ (v : V), ¬LinearIndependent R ![v, f v]) → ∃ a, f = a • 1 | true |
Polynomial.modByMonic_eq_sub_mul_div | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] (p q : Polynomial R), p %ₘ q = p - q * (p /ₘ q) | true |
Prod.map_comp_map | Init.Data.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {ε : Type u_5} {ζ : Type u_6} (f : α → β) (f' : γ → δ)
(g : β → ε) (g' : δ → ζ), Prod.map g g' ∘ Prod.map f f' = Prod.map (g ∘ f) (g' ∘ f') | true |
CategoryTheory.InjectiveResolution.definition._proof_2._@.Mathlib.CategoryTheory.Abelian.Injective.Resolution.4211954440._hygCtx._hyg.8 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] (Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Injective.ι Z)
((CategoryTheory.InjectiveResolution.ofCocomplex Z).d 0 1) =
0 | false |
Lean.Elab.InlayHintLabel | Lean.Elab.InfoTree.InlayHints | Type | true |
Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.cancelDen.noConfusion | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {P : Sort u} →
{c : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr} →
{val : ℤ} →
{x n : Lean.Grind.Linarith.Var} →
{c' : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr} →
{val' : ℤ} →
{x' n' : Lean.Grind.Linarith.Var} →
Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.cancelDen c val x n =
Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.cancelDen c' val' x' n' →
(c = c' → val = val' → x = x' → n = n' → P) → P | false |
_private.Mathlib.Data.Analysis.Filter.0.Filter.Realizer.bind.match_14 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {β : Type u_3} {m : α → Filter β} (x : Set β) (σ : Type u_2) (F : CFilter (Set α) σ)
(motive :
(∃ t ∈ { sets := {a | ∃ b, F.f b ⊆ a}, univ_sets := ⋯, sets_of_superset := ⋯, inter_sets := ⋯ },
∀ x_1 ∈ t, x ∈ m x_1) →
Prop)
(x_1 :
∃ t ∈ { sets := {a | ∃ b, F.f b ⊆ a}, univ_sets := ⋯, sets_of_superset := ⋯, inter_sets := ⋯ },
∀ x_1 ∈ t, x ∈ m x_1),
(∀ (w : Set α) (s : σ) (h : F.f s ⊆ w) (f : ∀ x_2 ∈ w, x ∈ m x_2), motive ⋯) → motive x_1 | false |
_private.Mathlib.Tactic.Linter.Header.0.Mathlib.Linter.inMathlibRef | Mathlib.Tactic.Linter.Header | IO.Ref (Option Bool) | true |
Nonneg.linearOrderedCommGroupWithZero._proof_2 | Mathlib.Algebra.Order.Nonneg.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α],
autoParam (∀ (a : { x // 0 ≤ x }), CommGroupWithZero.zpow 0 a = 1) DivInvMonoid.zpow_zero'._autoParam | false |
OrthonormalBasis.fromOrthogonalSpanSingleton._proof_1 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(n : ℕ) [Fact (Module.finrank 𝕜 E = n + 1)], FiniteDimensional 𝕜 E | false |
isClosed_le_of_isClosed_nonneg | Mathlib.Analysis.Normed.Order.Lattice | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] [inst_3 : TopologicalSpace G]
[ContinuousSub G], IsClosed {x | 0 ≤ x} → IsClosed {p | p.1 ≤ p.2} | true |
_private.Batteries.Data.RBMap.Depth.0.Batteries.RBNode.depthUB_le.match_1_1 | Batteries.Data.RBMap.Depth | ∀ (motive : Batteries.RBColor → ℕ → Prop) (x : Batteries.RBColor) (x_1 : ℕ),
(∀ (x : ℕ), motive Batteries.RBColor.red x) → (∀ (x : ℕ), motive Batteries.RBColor.black x) → motive x x_1 | false |
CategoryTheory.WideSubcategory.obj | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{_P : CategoryTheory.MorphismProperty C} → [inst_1 : _P.IsMultiplicative] → CategoryTheory.WideSubcategory _P → C | true |
nhdsSet_le_iff._simp_1 | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T1Space X] {s t : Set X}, (nhdsSet s ≤ nhdsSet t) = (s ⊆ t) | false |
Sublattice.mem_mk._simp_1 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {s : Set α} {a : α} (h_sup : SupClosed s) (h_inf : InfClosed s),
(a ∈ { carrier := s, supClosed' := h_sup, infClosed' := h_inf }) = (a ∈ s) | false |
Lean.Lsp.ResolveSupport | Lean.Data.Lsp.Basic | Type | true |
Lean.Server.StatefulRequestHandler.casesOn | Lean.Server.Requests | {motive : Lean.Server.StatefulRequestHandler → Sort u} →
(t : Lean.Server.StatefulRequestHandler) →
((fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri) →
(pureHandle : Lean.Json → Dynamic → Lean.Server.RequestM (Lean.Server.SerializedLspResponse × Dynamic)) →
(handle : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)) →
(pureOnDidChange : Lean.Lsp.DidChangeTextDocumentParams → StateT Dynamic Lean.Server.RequestM Unit) →
(onDidChange : Lean.Lsp.DidChangeTextDocumentParams → Lean.Server.RequestM Unit) →
(lastTaskMutex : Std.Mutex (Lean.Server.ServerTask Unit)) →
(initState : Dynamic) →
(stateRef : IO.Ref Dynamic) →
(completeness : Lean.Server.RequestHandlerCompleteness) →
motive
{ fileSource := fileSource, pureHandle := pureHandle, handle := handle,
pureOnDidChange := pureOnDidChange, onDidChange := onDidChange,
lastTaskMutex := lastTaskMutex, initState := initState, stateRef := stateRef,
completeness := completeness }) →
motive t | false |
intervalIntegral.integral_derivWithin_Icc_of_contDiffOn_Icc | Mathlib.MeasureTheory.Integral.IntervalIntegral.ContDiff | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a b : ℝ} [CompleteSpace E],
ContDiffOn ℝ 1 f (Set.Icc a b) → a ≤ b → ∫ (x : ℝ) in a..b, derivWithin f (Set.Icc a b) x = f b - f a | true |
GroupExtension.Equiv.trans_apply | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : Group N] [inst_1 : Group E] [inst_2 : Group G]
{S : GroupExtension N E G} {E' : Type u_4} [inst_3 : Group E'] {S' : GroupExtension N E' G} (equiv : S.Equiv S')
{E'' : Type u_5} [inst_4 : Group E''] {S'' : GroupExtension N E'' G} (equiv' : S'.Equiv S'') (a : E),
(equiv.trans equiv') a = equiv' (equiv a) | true |
Part.elim_toOption | Mathlib.Data.Part | ∀ {α : Type u_4} {β : Type u_5} (a : Part α) [inst : Decidable a.Dom] (b : β) (f : α → β),
a.toOption.elim b f = if h : a.Dom then f (a.get h) else b | true |
SeminormFamily.basisSets_univ_mem | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {R : Type u_1} {E : Type u_6} {ι : Type u_9} [inst : SeminormedRing R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(p : SeminormFamily R E ι), Set.univ ∈ p.basisSets | true |
EuclideanSpace.nnnorm_single | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] (i : ι) (a : 𝕜),
‖EuclideanSpace.single i a‖₊ = ‖a‖₊ | true |
CategoryTheory.Limits.limitCompYonedaIsoCocone_hom_app | Mathlib.CategoryTheory.Limits.Types.Yoneda | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor J C) (X : C) (a : CategoryTheory.Limits.limit (F.op.comp (CategoryTheory.yoneda.obj X)))
(j : J),
((CategoryTheory.Limits.limitCompYonedaIsoCocone F X).hom a).app j =
↑((CategoryTheory.Limits.Types.limitEquivSections (F.op.comp (CategoryTheory.yoneda.obj X))) a) (Opposite.op j) | true |
Std.ExtHashMap.getKeyD_alter_self | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [Inhabited α] {k fallback : α} {f : Option β → Option β},
(m.alter k f).getKeyD k fallback = if (f m[k]?).isSome = true then k else fallback | true |
SemiNormedGrp.hom_id | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M : SemiNormedGrp}, SemiNormedGrp.Hom.hom (CategoryTheory.CategoryStruct.id M) = NormedAddGroupHom.id M.carrier | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.nCasesProd.match_5 | Lean.Meta.MkIffOfInductiveProp | (motive : Array Lean.Meta.CasesSubgoal → Sort u_1) →
(__discr : Array Lean.Meta.CasesSubgoal) →
((sg : Lean.Meta.CasesSubgoal) → motive #[sg]) → ((x : Array Lean.Meta.CasesSubgoal) → motive x) → motive __discr | false |
MonoidAlgebra.addCommMonoid._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] (a : MonoidAlgebra R M), 0 + a = a | false |
TensorProduct.finsuppRight_symm_apply_single | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {M : Type u_3}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
[inst_7 : AddCommMonoid N] [inst_8 : Module R N] {ι : Type u_5} [inst_9 : DecidableEq ι] (i : ι) (m : M) (n : N),
((TensorProduct.finsuppRight R S M N ι).symm fun₀ | i => m ⊗ₜ[R] n) = m ⊗ₜ[R] fun₀ | i => n | true |
Array.get!Internal | Init.Prelude | {α : Type u} → [Inhabited α] → Array α → ℕ → α | true |
Lean.SourceInfo.ctorIdx | Init.Prelude | Lean.SourceInfo → ℕ | false |
instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._proof_7 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommGroupWithZero α] (n : ℕ) (a : Additive αᵒᵈ),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | false |
EuclideanDomain.lcm | Mathlib.Algebra.EuclideanDomain.Defs | {R : Type u} → [EuclideanDomain R] → [DecidableEq R] → R → R → R | true |
NumberField.IsCMField.starRing | Mathlib.NumberTheory.NumberField.CMField | (K : Type u_1) →
[inst : Field K] → [inst_1 : CharZero K] → [NumberField.IsCMField K] → [Algebra.IsIntegral ℚ K] → StarRing K | true |
Real.iteratedDerivWithin_cos_Ioo | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ (n : ℕ) {a b x : ℝ}, x ∈ Set.Ioo a b → iteratedDerivWithin n Real.cos (Set.Ioo a b) x = iteratedDeriv n Real.cos x | true |
CategoryTheory.PreOneHypercover.inv_hom_h₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (e : E ≅ F)
{i j : F.I₀} (k : F.I₁ i j),
CategoryTheory.CategoryStruct.comp (e.inv.h₁ k) (e.hom.h₁ (e.inv.s₁ k)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso ⋯ ⋯ k).inv
(CategoryTheory.eqToHom ⋯) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.