name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.checkDefaultSplitStatus | Lean.Meta.Tactic.Grind.Split | Lean.Expr → Lean.Meta.Grind.GoalM Lean.Meta.Grind.SplitStatus | true |
QuasiErgodic.mk._flat_ctor | Mathlib.Dynamics.Ergodic.Ergodic | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → α} {μ : autoParam (MeasureTheory.Measure α) QuasiErgodic._auto_1},
Measurable f →
(MeasureTheory.Measure.map f μ).AbsolutelyContinuous μ →
(∀ ⦃s : Set α⦄, MeasurableSet s → f ⁻¹' s = s → Filter.EventuallyConst s (MeasureTheory.ae μ)) → QuasiErgodic f μ | false |
CategoryTheory.ShortComplex.exact_of_g_is_cokernel | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C)
(hS : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯)) [S.HasHomology], S.Exact | true |
CategoryTheory.IsCofiltered.cofilteredClosure.below | Mathlib.CategoryTheory.Filtered.Small | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.IsCofilteredOrEmpty C] →
{α : Type w} →
{f : α → C} →
{motive : (a : C) → CategoryTheory.IsCofiltered.cofilteredClosure f a → Prop} →
{a : C} → CategoryTheory.IsCofiltered.cofilteredClosure f a → Prop | true |
Decidable.em | Init.Core | ∀ (p : Prop) [Decidable p], p ∨ ¬p | true |
CategoryTheory.equivEssImageOfReflective._proof_2 | Mathlib.CategoryTheory.Adjunction.Reflective | ∀ {C : Type u_4} {D : Type u_3} [inst : CategoryTheory.Category.{u_2, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] {i : CategoryTheory.Functor D C}
[inst_2 : CategoryTheory.Reflective i] {X Y : i.EssImageSubcategory} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((((i.essImage.ι.comp (CategoryTheory.reflector i)).comp i.toEssImage).comp i.essImage.ι).map f)
((fun X => (CategoryTheory.asIso ((CategoryTheory.reflectorAdjunction i).unit.app X.obj)).symm) Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X => (CategoryTheory.asIso ((CategoryTheory.reflectorAdjunction i).unit.app X.obj)).symm) X).hom
(((CategoryTheory.Functor.id i.EssImageSubcategory).comp i.essImage.ι).map f) | false |
Nat.dfold_add._proof_10 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, ∀ i < n + m, i + 1 ≤ n + m | false |
CategoryTheory.EnrichedCategory.mk | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
(Hom : C → C → V) →
(id : (X : C) → CategoryTheory.MonoidalCategoryStruct.tensorUnit V ⟶ Hom X X) →
(comp : (X Y Z : C) → CategoryTheory.MonoidalCategoryStruct.tensorObj (Hom X Y) (Hom Y Z) ⟶ Hom X Z) →
autoParam
(∀ (X Y : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor (Hom X Y)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (id X) (Hom X Y)) (comp X X Y)) =
CategoryTheory.CategoryStruct.id (Hom X Y))
CategoryTheory.EnrichedCategory.id_comp._autoParam →
autoParam
(∀ (X Y : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (Hom X Y)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (Hom X Y) (id Y)) (comp X Y Y)) =
CategoryTheory.CategoryStruct.id (Hom X Y))
CategoryTheory.EnrichedCategory.comp_id._autoParam →
autoParam
(∀ (W X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (Hom W X) (Hom X Y) (Hom Y Z)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (comp W X Y) (Hom Y Z))
(comp W Y Z)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (Hom W X) (comp X Y Z)) (comp W X Z))
CategoryTheory.EnrichedCategory.assoc._autoParam →
CategoryTheory.EnrichedCategory V C | true |
CategoryTheory.OppositeShift.adjunction_counit | Mathlib.CategoryTheory.Shift.Opposite | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (adj : F ⊣ G),
(CategoryTheory.OppositeShift.adjunction A adj).counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.OppositeShift.natIsoComp A F G).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.OppositeShift.natTrans A adj.unit)
(CategoryTheory.NatTrans.OppositeShift.natIsoId C A).inv) | true |
Lean.Elab.instInhabitedDecreasingBy | Lean.Elab.PreDefinition.TerminationHint | Inhabited Lean.Elab.DecreasingBy | true |
ContinuousLinearMap.HasLeftInverse.of_comp | Mathlib.Analysis.Normed.Module.ContinuousInverse | ∀ {R : Type u_1} [inst : Semiring R] {E : Type u_2} {F : Type u_4} {G : Type u_6} [inst_1 : TopologicalSpace E]
[inst_2 : AddCommMonoid E] [inst_3 : Module R E] [inst_4 : TopologicalSpace F] [inst_5 : AddCommMonoid F]
[inst_6 : Module R F] {f : E →L[R] F} [inst_7 : TopologicalSpace G] [inst_8 : AddCommMonoid G] [inst_9 : Module R G]
{g : F →L[R] G}, (g.comp f).HasLeftInverse → f.HasLeftInverse | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices.0.SSet.S.existsUnique_n._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} {n : ℕ} (x : X.obj (Opposite.op (SimplexCategory.mk n))) (A : X.Subcomplex),
(SSet.Subcomplex.ofSimplex x ≤ A) = (x ∈ A.obj (Opposite.op (SimplexCategory.mk n))) | false |
vadd_closedBall_zero | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x : E), x +ᵥ Metric.closedBall 0 δ = Metric.closedBall x δ | true |
Std.Rci.getElem_toList_eq | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rci α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxi.IsAlwaysFinite α] {i : ℕ} {h : i < r.toList.length},
r.toList[i] = (Std.PRange.succMany? i r.lower).get ⋯ | true |
CategoryTheory.Functor.PreservesRightKanExtension.mk | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] {G : CategoryTheory.Functor B D} {F : CategoryTheory.Functor A B}
{L : CategoryTheory.Functor A C},
(∀ (F' : CategoryTheory.Functor C B) (α : L.comp F' ⟶ F) [F'.IsRightKanExtension α],
(F'.comp G).IsRightKanExtension
(CategoryTheory.CategoryStruct.comp (L.associator F' G).inv (CategoryTheory.Functor.whiskerRight α G))) →
G.PreservesRightKanExtension F L | true |
OpenNormalAddSubgroup.instSemilatticeInfOpenNormalAddSubgroup._proof_2 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] {x y : OpenNormalAddSubgroup G}, ↑y ≤ ↑x ↔ ↑y ≤ ↑x | false |
Set.neg_mem_Ioc_iff | Mathlib.Algebra.Order.Interval.Set.Group | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] {a c d : α},
-a ∈ Set.Ioc c d ↔ a ∈ Set.Ico (-d) (-c) | true |
CategoryTheory.ShiftMkCore._proof_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ (C : Type u_1) (A : Type u_3) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : AddMonoid A]
(F : A → CategoryTheory.Functor C C) (m₁ m₂ m₃ : A) (X : C), (F (m₁ + m₂ + m₃)).obj X = (F (m₁ + (m₂ + m₃))).obj X | false |
Finset.card_eq_of_equiv_fin | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {s : Finset α} {n : ℕ} (i : ↥s ≃ Fin n), s.card = n | true |
_private.Lean.Compiler.LCNF.PhaseExt.0.Lean.Compiler.LCNF.isDeclTransparent.match_1 | Lean.Compiler.LCNF.PhaseExt | (motive : List Lean.Name × Lean.NameSet → Sort u_1) →
(x : List Lean.Name × Lean.NameSet) → ((fst : List Lean.Name) → (map : Lean.NameSet) → motive (fst, map)) → motive x | false |
CategoryTheory.Square.ctorIdx | Mathlib.CategoryTheory.Square | {C : Type u} → {inst : CategoryTheory.Category.{v, u} C} → CategoryTheory.Square C → ℕ | false |
BoundedOrderHom.cancel_right._simp_1 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [inst_5 : BoundedOrder γ] {g₁ g₂ : BoundedOrderHom β γ}
{f : BoundedOrderHom α β}, Function.Surjective ⇑f → (g₁.comp f = g₂.comp f) = (g₁ = g₂) | false |
Lean.Firefox.FuncTable._sizeOf_1 | Lean.Util.Profiler | Lean.Firefox.FuncTable → ℕ | false |
Besicovitch.SatelliteConfig.mk | Mathlib.MeasureTheory.Covering.Besicovitch | {α : Type u_1} →
[inst : MetricSpace α] →
{N : ℕ} →
{τ : ℝ} →
(c : Fin N.succ → α) →
(r : Fin N.succ → ℝ) →
(∀ (i : Fin N.succ), 0 < r i) →
(Pairwise fun i j => r i ≤ dist (c i) (c j) ∧ r j ≤ τ * r i ∨ r j ≤ dist (c j) (c i) ∧ r i ≤ τ * r j) →
(∀ i < Fin.last N, r i ≤ dist (c i) (c (Fin.last N)) ∧ r (Fin.last N) ≤ τ * r i) →
(∀ i < Fin.last N, dist (c i) (c (Fin.last N)) ≤ r i + r (Fin.last N)) →
Besicovitch.SatelliteConfig α N τ | true |
TendstoUniformlyOn.prodMap | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : UniformSpace β] {F : ι → α → β} {f : α → β} {s : Set α}
{p : Filter ι} {ι' : Type u_5} {α' : Type u_6} {β' : Type u_7} [inst_1 : UniformSpace β'] {F' : ι' → α' → β'}
{f' : α' → β'} {p' : Filter ι'} {s' : Set α'},
TendstoUniformlyOn F f p s →
TendstoUniformlyOn F' f' p' s' →
TendstoUniformlyOn (fun i => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ p') (s ×ˢ s') | true |
padicNormE._proof_5 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ_[p]), Quotient.lift PadicSeq.norm ⋯ q = 0 ↔ q = 0 | false |
Quaternion.linearIsometryEquivTuple._proof_5 | Mathlib.Analysis.Quaternion | ∀ (x y : QuaternionAlgebra ℝ (-1) 0 (-1)),
(↑((QuaternionAlgebra.linearEquivTuple (-1) 0 (-1)).trans (WithLp.linearEquiv 2 ℝ (Fin 4 → ℝ)).symm)).toFun (x + y) =
(↑((QuaternionAlgebra.linearEquivTuple (-1) 0 (-1)).trans (WithLp.linearEquiv 2 ℝ (Fin 4 → ℝ)).symm)).toFun x +
(↑((QuaternionAlgebra.linearEquivTuple (-1) 0 (-1)).trans (WithLp.linearEquiv 2 ℝ (Fin 4 → ℝ)).symm)).toFun y | false |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.Const.size_filter_eq_size_iff._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | false |
AdicCompletion.sumInv | Mathlib.RingTheory.AdicCompletion.Functoriality | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
{ι : Type u_6} →
(M : ι → Type u_7) →
[inst_1 : (i : ι) → AddCommGroup (M i)] →
[inst_2 : (i : ι) → Module R (M i)] →
[Fintype ι] →
AdicCompletion I (DirectSum ι fun j => M j) →ₗ[AdicCompletion I R]
DirectSum ι fun j => AdicCompletion I (M j) | true |
DifferentiableAt.div | Mathlib.Analysis.Calculus.Deriv.Inv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'},
DifferentiableAt 𝕜 c x → DifferentiableAt 𝕜 d x → d x ≠ 0 → DifferentiableAt 𝕜 (c / d) x | true |
Equiv.Set.union_apply_left | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {s t : Set α} [inst : DecidablePred fun x => x ∈ s] (H : Disjoint s t) {a : ↑(s ∪ t)} (ha : ↑a ∈ s),
(Equiv.Set.union H) a = Sum.inl ⟨↑a, ha⟩ | true |
UInt64.and_lt_add_one | Init.Data.UInt.Bitwise | ∀ {b c : UInt64}, c ≠ -1 → b &&& c < c + 1 | true |
SheafOfModules.QuasicoherentData.recOn | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : ∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] →
[inst_2 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat] →
[inst_3 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] →
{M : SheafOfModules R} →
{motive : M.QuasicoherentData → Sort u_1} →
(t : M.QuasicoherentData) →
((I : Type w) →
(X : I → C) →
(coversTop : J.CoversTop X) →
(presentation : (i : I) → (M.over (X i)).Presentation) →
motive { I := I, X := X, coversTop := coversTop, presentation := presentation }) →
motive t | false |
Ordinal.invVeblen₂_le | Mathlib.SetTheory.Ordinal.Veblen | ∀ (x : Ordinal.{u_1}), x.invVeblen₂ ≤ x | true |
_private.Lean.Meta.Sym.Simp.EvalGround.0.Lean.Meta.Sym.Simp.evalBinUInt8 | Lean.Meta.Sym.Simp.EvalGround | (UInt8 → UInt8 → UInt8) → Lean.Expr → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | true |
CategoryTheory.GrothendieckTopology.instPreorderCover._aux_1 | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
(J : CategoryTheory.GrothendieckTopology C) → (X : C) → J.Cover X → J.Cover X → Prop | false |
Lean.Meta.ExtractLets.isExtractableLet | Lean.Meta.Tactic.Lets | List Lean.Expr → Lean.Name → Lean.Expr → Lean.Expr → Lean.Meta.ExtractLets.M (Bool × Lean.Name) | true |
UpperHalfPlane.isOpenMap_re | Mathlib.Analysis.Complex.UpperHalfPlane.Topology | IsOpenMap UpperHalfPlane.re | true |
Lean.Elab.Command.AssertExists.noConfusionType | Lean.Elab.AssertExists | Sort u → Lean.Elab.Command.AssertExists → Lean.Elab.Command.AssertExists → Sort u | false |
AlgebraicGeometry.quasiSeparatedSpace_iff_quasiSeparated | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ (X : AlgebraicGeometry.Scheme),
QuasiSeparatedSpace ↥X ↔ AlgebraicGeometry.QuasiSeparated (CategoryTheory.Limits.terminal.from X) | true |
_private.Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff.0.Matrix.charpoly_monic._proof_1_2 | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {n : Type u_1} [inst : Fintype n], ¬Fintype.card n = 0 → Fintype.card n - 1 < Fintype.card n | false |
LieSubmodule.mem_bot | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), x ∈ ⊥ ↔ x = 0 | true |
SubMulAction.fg_iff | Mathlib.GroupTheory.GroupAction.SubMulAction.Closure | ∀ {R : Type u_1} {M : Type u_2} [inst : SMul R M] {p : SubMulAction R M}, p.FG ↔ ∃ s, p = SubMulAction.closure R ↑s | true |
WeierstrassCurve.c_relation_of_char_three | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [CharP R 3], W.c₄ ^ 3 = W.c₆ ^ 2 | true |
Polynomial.reverse_C_add | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (t : R),
(Polynomial.C t + p).reverse = Polynomial.C t * Polynomial.X ^ p.natDegree + p.reverse | true |
MulEquiv.symmEquiv_symm_apply_symm_apply | Mathlib.Algebra.Group.Equiv.Defs | ∀ (P : Type u_9) (Q : Type u_10) [inst : Mul P] [inst_1 : Mul Q] (h : Q ≃* P) (a : Q),
((MulEquiv.symmEquiv P Q).symm h).symm a = h a | true |
Std.HashMap.toList_emptyWithCapacity | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {c : ℕ}, (Std.HashMap.emptyWithCapacity c).toList = [] | true |
Units.inv_mul_le_one_of_le | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ) {a : M}, a ≤ ↑u → ↑u⁻¹ * a ≤ 1 | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.typeMatchesBaseName._unsafe_rec | Lean.Elab.App | Lean.Expr → Lean.Name → Lean.MetaM Bool | false |
perfectClosure.algEquivOfAlgEquiv._proof_3 | Mathlib.FieldTheory.PurelyInseparable.PerfectClosure | ∀ {F : Type u_1} [inst : Field F] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra F K], IsScalarTower F F K | false |
GaloisConnection.compl | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u} {β : Type v} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] {l : α → β} {u : β → α},
GaloisConnection l u → GaloisConnection (compl ∘ u ∘ compl) (compl ∘ l ∘ compl) | true |
_private.Mathlib.Order.WithBot.0.WithTop.untop.match_1.splitter | Mathlib.Order.WithBot | {α : Type u_1} →
(motive : (x : WithTop α) → x ≠ ⊤ → Sort u_2) →
(x : WithTop α) → (x_1 : x ≠ ⊤) → ((x : α) → (x_2 : ↑x ≠ ⊤) → motive (some x) x_2) → motive x x_1 | true |
CategoryTheory.Limits.reflectsFiniteColimits_of_leftOp | Mathlib.CategoryTheory.Limits.Preserves.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ᵒᵖ) [CategoryTheory.Limits.ReflectsFiniteLimits F.leftOp],
CategoryTheory.Limits.ReflectsFiniteColimits F | true |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.isOpen_forall_imp_mem._simp_1_3 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {s : Set β} {f : α → β}, IsOpen s = IsOpen (f ⁻¹' s) | false |
CategoryTheory.overEquivOfIsInitial._proof_5 | Mathlib.CategoryTheory.Comma.Over.StrictInitial | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasStrictInitialObjects C] (X : C) (h : CategoryTheory.Limits.IsInitial X)
(X_1 : CategoryTheory.Over X),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.star (CategoryTheory.Over X)).map
((CategoryTheory.NatIso.ofComponents (fun A => CategoryTheory.Over.isoMk (CategoryTheory.asIso A.hom) ⋯)
⋯).hom.app
X_1))
((CategoryTheory.Iso.refl
((CategoryTheory.Functor.fromPUnit (CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id X))).comp
(CategoryTheory.Functor.star (CategoryTheory.Over X)))).hom.app
((CategoryTheory.Functor.star (CategoryTheory.Over X)).obj X_1)) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.star (CategoryTheory.Over X)).obj X_1) | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_intMin_of_pos._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {v : ℕ}, ¬1 < 2 → False | false |
CategoryTheory.ShortComplex.instAbelian._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
CategoryTheory.Limits.HasKernels (CategoryTheory.ShortComplex C) | false |
Std.TreeSet.Raw.maxD_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF →
∀ {k fallback : α}, (t.insert k).maxD fallback = t.max?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | true |
Lean.Lsp.SignatureHelpParams.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams}
{toWorkDoneProgressParams : Lean.Lsp.WorkDoneProgressParams} {context? : Option Lean.Lsp.SignatureHelpContext}
{toTextDocumentPositionParams_1 : Lean.Lsp.TextDocumentPositionParams}
{toWorkDoneProgressParams_1 : Lean.Lsp.WorkDoneProgressParams} {context?_1 : Option Lean.Lsp.SignatureHelpContext},
{ toTextDocumentPositionParams := toTextDocumentPositionParams, toWorkDoneProgressParams := toWorkDoneProgressParams,
context? := context? } =
{ toTextDocumentPositionParams := toTextDocumentPositionParams_1,
toWorkDoneProgressParams := toWorkDoneProgressParams_1, context? := context?_1 } →
toTextDocumentPositionParams = toTextDocumentPositionParams_1 ∧
toWorkDoneProgressParams = toWorkDoneProgressParams_1 ∧ context? = context?_1 | true |
_private.Lean.Expr.0.Lean.Expr.updateLet!Impl | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Bool → Lean.Expr | true |
_private.Mathlib.Tactic.CategoryTheory.ToApp.0.Mathlib.Tactic.CategoryTheory.ToApp.toCatExpr.match_1 | Mathlib.Tactic.CategoryTheory.ToApp | (motive : Lean.Name × Array Lean.Expr → Sort u_1) →
(x : Lean.Name × Array Lean.Expr) →
((head head_1 a head_2 : Lean.Expr) → motive (`Quiver.Hom, #[head, head_1, a, head_2])) →
((x : Lean.Name × Array Lean.Expr) → motive x) → motive x | false |
MeasureTheory.NullMeasurableSet.right_of_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {s : Set α} {t : Set β},
MeasureTheory.NullMeasurableSet (s ×ˢ t) (μ.prod ν) → μ s ≠ 0 → MeasureTheory.NullMeasurableSet t ν | true |
HomologicalComplex₂.ι_totalShift₁Iso_inv_f_assoc | Mathlib.Algebra.Homology.TotalComplexShift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (x : ℤ) [inst_2 : K.HasTotal (ComplexShape.up ℤ)]
(a b n : ℤ) (h : a + b = n) (a' n' : ℤ) (ha' : a' + b = n') (hn' : n' = n + x) {Z : C}
(h_1 : (((HomologicalComplex₂.shiftFunctor₁ C x).obj K).total (ComplexShape.up ℤ)).X n ⟶ Z),
CategoryTheory.CategoryStruct.comp (K.ιTotal (ComplexShape.up ℤ) a' b n' ha')
(CategoryTheory.CategoryStruct.comp
(CochainComplex.shiftFunctorObjXIso (K.total (ComplexShape.up ℤ)) x n n' hn').inv
(CategoryTheory.CategoryStruct.comp ((K.totalShift₁Iso x).inv.f n) h_1)) =
CategoryTheory.CategoryStruct.comp (K.shiftFunctor₁XXIso a x a' ⋯ b).inv
(CategoryTheory.CategoryStruct.comp
(((HomologicalComplex₂.shiftFunctor₁ C x).obj K).ιTotal (ComplexShape.up ℤ) a b n h) h_1) | true |
Subsemigroup.op_iInf | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {ι : Sort u_1} {M : Type u_2} [inst : Mul M] (S : ι → Subsemigroup M), (iInf S).op = ⨅ i, (S i).op | true |
Std.Tactic.BVDecide.Gate.casesOn | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | {motive : Std.Tactic.BVDecide.Gate → Sort u} →
(t : Std.Tactic.BVDecide.Gate) →
motive Std.Tactic.BVDecide.Gate.and →
motive Std.Tactic.BVDecide.Gate.xor →
motive Std.Tactic.BVDecide.Gate.beq → motive Std.Tactic.BVDecide.Gate.or → motive t | false |
JordanHolderLattice.second_iso | Mathlib.Order.JordanHolder | ∀ {X : Type u} {inst : Lattice X} [self : JordanHolderLattice X] {x y : X},
JordanHolderLattice.IsMaximal x (x ⊔ y) → JordanHolderLattice.Iso (x, x ⊔ y) (x ⊓ y, y) | true |
_private.Mathlib.CategoryTheory.Sites.Subsheaf.0.CategoryTheory.Subfunctor.to_sheafifyLift._simp_1_1 | Mathlib.CategoryTheory.Sites.Subsheaf | ∀ (α : Type u) (p : α → Prop), (∀ (x : (CategoryTheory.forget (Type u)).obj α), p x) = ∀ (x : α), p x | false |
Plausible.PrintableProp.mk | Plausible.Testable | {p : Prop} → String → Plausible.PrintableProp p | true |
Std.Time.PlainDateTime.subMinutes | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Minute.Offset → Std.Time.PlainDateTime | true |
Lean.Compiler.LCNF.JoinPointCommonArgs.AnalysisCtx.jpScopes._default | Lean.Compiler.LCNF.JoinPoints | Lean.FVarIdMap Lean.FVarIdSet | false |
Path.continuous_trans | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y z : X}, Continuous fun ρ => ρ.1.trans ρ.2 | true |
Nat.Partition.ofSymShapeEquiv | Mathlib.Combinatorics.Enumerative.Partition.Basic | {n : ℕ} →
{σ : Type u_1} →
{τ : Type u_2} →
[inst : DecidableEq σ] →
[inst_1 : DecidableEq τ] →
(μ : n.Partition) → σ ≃ τ → { x // Nat.Partition.ofSym x = μ } ≃ { x // Nat.Partition.ofSym x = μ } | true |
CategoryTheory.NatTrans.hcomp._proof_3 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
{F G : CategoryTheory.Functor C D} {H I : CategoryTheory.Functor D E} (α : G ⟶ F) (β : I ⟶ H),
{ app := fun X => CategoryTheory.CategoryStruct.comp (β.app (G.obj X)) (H.map (α.app X)), naturality := ⋯ } =
CategoryTheory.NatTrans.mk' (fun X => CategoryTheory.CategoryStruct.comp (I.map (α.app X)) (β.app (F.obj X))) ⋯ | false |
CategoryTheory.Functor.mapConeWhisker | Mathlib.CategoryTheory.Limits.Cones | {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] →
{D : Type u₄} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] →
(H : CategoryTheory.Functor C D) →
{F : CategoryTheory.Functor J C} →
{E : CategoryTheory.Functor K J} →
{c : CategoryTheory.Limits.Cone F} →
H.mapCone (CategoryTheory.Limits.Cone.whisker E c) ≅
CategoryTheory.Limits.Cone.whisker E (H.mapCone c) | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_ric_eq_singleton_iff._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k n : ℕ}, ¬(0 = k ∧ n = 0 ↔ n = 0 ∧ 0 = k) → False | false |
_private.Mathlib.Geometry.Manifold.Diffeomorph.0.Diffeomorph.uniqueDiffOn_image._simp_1_1 | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E}, UniqueDiffOn 𝕜 s = UniqueMDiffOn (modelWithCornersSelf 𝕜 E) s | false |
MulEquiv.subsemigroupMap._proof_2 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_2} {N : Type u_1} [inst : Mul M] [inst_1 : Mul N] (e : M ≃* N) (S : Subsemigroup M) (x : ↥S),
↑e ↑x ∈ ⇑↑e '' ↑S | false |
WeierstrassCurve.Affine.Point.some.injEq | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Affine R} (x y : R) (h : W'.Nonsingular x y) (x_1 y_1 : R)
(h_1 : W'.Nonsingular x_1 y_1),
(WeierstrassCurve.Affine.Point.some x y h = WeierstrassCurve.Affine.Point.some x_1 y_1 h_1) = (x = x_1 ∧ y = y_1) | true |
Matroid.instNonemptyElemSetSetOfAndIsFlatSubsetInterE | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X : Set α}, Nonempty ↑{F | M.IsFlat F ∧ X ∩ M.E ⊆ F} | true |
Asymptotics.isBigO_iff_eventually_isBigOWith | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {f : α → E}
{g' : α → F'} {l : Filter α}, f =O[l] g' ↔ ∀ᶠ (c : ℝ) in Filter.atTop, Asymptotics.IsBigOWith c l f g' | true |
Complex.deriv_log_comp_eq_logDeriv | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | ∀ {f : ℂ → ℂ} {x : ℂ}, DifferentiableAt ℂ f x → f x ∈ Complex.slitPlane → deriv (Complex.log ∘ f) x = logDeriv f x | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mul.match_1 | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
(motive : Mathlib.Tactic.FieldSimp.qNF q(«$M») → Mathlib.Tactic.FieldSimp.qNF q(«$M») → Sort u_1) →
(x x_1 : Mathlib.Tactic.FieldSimp.qNF q(«$M»)) →
((l : Mathlib.Tactic.FieldSimp.qNF q(«$M»)) → motive [] l) →
((l : Mathlib.Tactic.FieldSimp.qNF q(«$M»)) → motive l []) →
((a₁ : ℤ) →
(x₁ : Q(«$M»)) →
(k₁ : ℕ) →
(t₁ : List ((ℤ × Q(«$M»)) × ℕ)) →
(a₂ : ℤ) →
(x₂ : Q(«$M»)) →
(k₂ : ℕ) →
(t₂ : List ((ℤ × Q(«$M»)) × ℕ)) → motive (((a₁, x₁), k₁) :: t₁) (((a₂, x₂), k₂) :: t₂)) →
motive x x_1 | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.IsTable.casesOn | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | {b : ByteArray} →
{v : Array ℕ} →
{motive : String.Slice.Pattern.Model.ForwardSliceSearcher.IsTable✝ b v → Sort u} →
(t : String.Slice.Pattern.Model.ForwardSliceSearcher.IsTable✝¹ b v) →
((size_le : v.size ≤ b.size) →
(eq_prefixFunction :
∀ (i : ℕ) (hi : i < v.size),
v[i] = String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ b i ⋯) →
motive ⋯) →
motive t | false |
CategoryTheory.Mon.Hom.rec | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.Mon C} →
{motive : M.Hom N → Sort u} →
((hom : M.X ⟶ N.X) →
[isMonHom_hom : CategoryTheory.IsMonHom hom] → motive { hom := hom, isMonHom_hom := isMonHom_hom }) →
(t : M.Hom N) → motive t | false |
Equiv.sumCompl_symm_apply_of_pos | Mathlib.Logic.Equiv.Sum | ∀ {α : Type u_9} {p : α → Prop} [inst : DecidablePred p] {a : α} (h : p a), (Equiv.sumCompl p).symm a = Sum.inl ⟨a, h⟩ | true |
TopologicalSpace.Opens.toTopCat._proof_1 | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat) (X_1 : TopologicalSpace.Opens ↑X),
TopCat.ofHom { toFun := fun x => ⟨↑x, ⋯⟩, continuous_toFun := ⋯ } = CategoryTheory.CategoryStruct.id (TopCat.of ↥X_1) | false |
_private.Lean.Meta.WHNF.0.Lean.Meta.mkProjFn.match_1 | Lean.Meta.WHNF | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → (Unit → motive none) → ((projFn : Lean.Name) → motive (some projFn)) → motive x | false |
intervalIntegral.integral_comp_mul_deriv_of_deriv_nonpos | Mathlib.MeasureTheory.Integral.IntervalIntegral.IntegrationByParts | ∀ {a b : ℝ} {f f' g : ℝ → ℝ},
ContinuousOn f (Set.uIcc a b) →
(∀ x ∈ Set.Ioo (min a b) (max a b), HasDerivAt f (f' x) x) →
(∀ x ∈ Set.Ioo (min a b) (max a b), f' x ≤ 0) → ∫ (x : ℝ) in a..b, (g ∘ f) x * f' x = ∫ (u : ℝ) in f a..f b, g u | true |
RootPairing.Equiv.toEndUnit._proof_7 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_4} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (f : P.Aut),
(fun f =>
let __src := ↑f;
{ toHom := __src, bijective_weightMap := ⋯, bijective_coweightMap := ⋯ })
((fun f => { val := ↑f, inv := ↑(RootPairing.Equiv.symm P P f), val_inv := ⋯, inv_val := ⋯ }) f) =
f | false |
CategoryTheory.Functor.pushforwardContinuousSheafificationCompatibility | Mathlib.CategoryTheory.Sites.CoverLifting | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(G : CategoryTheory.Functor C D) →
(A : Type w) →
[inst_2 : CategoryTheory.Category.{w', w} A] →
(J : CategoryTheory.GrothendieckTopology C) →
(K : CategoryTheory.GrothendieckTopology D) →
[G.IsCocontinuous J K] →
[∀ (F : CategoryTheory.Functor Cᵒᵖ A), G.op.HasPointwiseRightKanExtension F] →
[inst_5 : CategoryTheory.HasWeakSheafify J A] →
[inst_6 : CategoryTheory.HasWeakSheafify K A] →
[inst_7 : G.IsContinuous J K] →
((CategoryTheory.Functor.whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj G.op).comp
(CategoryTheory.presheafToSheaf J A) ≅
(CategoryTheory.presheafToSheaf K A).comp (G.sheafPushforwardContinuous A J K) | true |
MulOpposite.opAddEquiv_toEquiv | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_2} [inst : Add α], ↑MulOpposite.opAddEquiv = MulOpposite.opEquiv | true |
PSet.ctorIdx | Mathlib.SetTheory.ZFC.PSet | PSet.{u} → ℕ | false |
HasGradientAtFilter.isBigO_sub | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {f' x : F} {L : Filter F},
HasGradientAtFilter f f' x L → (fun x' => f x' - f x) =O[L] fun x' => x' - x | true |
String.Slice.Pattern.Char.instBackwardPatternChar | Init.Data.String.Pattern.Char | {c : Char} → String.Slice.Pattern.BackwardPattern c | true |
Metric.closedEBall_zero | Mathlib.Topology.EMetricSpace.Defs | ∀ {γ : Type w} [inst : EMetricSpace γ] (x : γ), Metric.closedEBall x 0 = {x} | true |
Ordinal.mod_zero | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (a : Ordinal.{u_4}), a % 0 = a | true |
Topology.IsQuotientMap.trivializationOfVAddDisjoint | Mathlib.Topology.Covering.Quotient | {E : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace X] →
{f : E → X} →
{G : Type u_3} →
[inst_2 : AddGroup G] →
[inst_3 : AddAction G E] →
Topology.IsQuotientMap f →
[ContinuousConstVAdd G E] →
(∀ {e₁ e₂ : E}, f e₁ = f e₂ ↔ e₁ ∈ AddAction.orbit G e₂) →
[inst_5 : TopologicalSpace G] →
[DiscreteTopology G] →
(U : Set E) →
IsOpen U →
(∀ (g : G), ((fun x => g +ᵥ x) '' U ∩ U).Nonempty → g = 0) → Bundle.Trivialization G f | true |
ZLattice.module_finite | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_1) [inst : NormedField K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [HasSolidNorm K] [FloorRing K]
{E : Type u_2} [inst_5 : NormedAddCommGroup E] [inst_6 : NormedSpace K E] [FiniteDimensional K E] [ProperSpace E]
(L : Submodule ℤ E) [inst_9 : DiscreteTopology ↥L] [IsZLattice K L], Module.Finite ℤ ↥L | true |
SimpleGraph.Walk.mem_darts_iff_infix_support | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u v u' v' : V} {p : G.Walk u v} (h : G.Adj u' v'),
{ fst := u', snd := v', adj := h } ∈ p.darts ↔ [u', v'] <:+: p.support | true |
_private.Std.Time.Format.Basic.0.Std.Time.Reason._sizeOf_1 | Std.Time.Format.Basic | Std.Time.Reason✝ → ℕ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.