name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
AlgebraicGeometry.instCanonicallyOverSpecStalkCommRingCatPresheaf | Mathlib.AlgebraicGeometry.Stalk | (X : AlgebraicGeometry.Scheme) → (x : ↥X) → (AlgebraicGeometry.Spec (X.presheaf.stalk x)).CanonicallyOver X |
String.Slice.Pos.not_endPos_lt._simp_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p : s.Pos}, (s.endPos < p) = False |
CategoryTheory.Functor.Elements.isInitialElementsMkShrinkYonedaObjObjEquivId._proof_1 | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
(X : C) (u : (CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.flip.obj (Opposite.op X)).Elements),
(CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.flip.obj (Opposite.op X)).map
(CategoryTheory.shrinkYonedaObjObjEquiv u.snd)
((CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.flip.obj (Opposite.op X)).elementsMk X
(CategoryTheory.shrinkYonedaObjObjEquiv.symm (CategoryTheory.CategoryStruct.id X))).snd =
u.snd |
Subfield.comap_top | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] (f : K →+* L), Subfield.comap f ⊤ = ⊤ |
Lean.Compiler.LCNF.compile | Lean.Compiler.LCNF.Main | Array Lean.Name → Lean.CoreM (Array (Array Lean.IR.Decl)) |
Mathlib.Tactic.Order.orderCoreImp | Mathlib.Tactic.Order | Bool → Array Lean.Expr → Lean.Expr → Lean.MVarId → Mathlib.Tactic.AtomM Unit |
CategoryTheory.MonoidalCategory.DayConvolution.braidingInvCorepresenting._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.Braided | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {V : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.BraidedCategory C] [inst_4 : CategoryTheory.MonoidalCategory V]
[inst_5 : CategoryTheory.BraidedCategory V] (F G : CategoryTheory.Functor C V)
[inst_6 : CategoryTheory.MonoidalCategory.DayConvolution F G] {x y : C × C} (f : x ⟶ y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.externalProduct G F).map f)
(CategoryTheory.CategoryStruct.comp (β_ ((G, F).2.obj y.2) ((G, F).1.obj y.1)).inv
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.DayConvolution.unit F G).app (y.2, y.1))
((CategoryTheory.MonoidalCategory.DayConvolution.convolution F G).map (β_ (y.2, y.1).2 (y.2, y.1).1).inv))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (β_ ((G, F).2.obj x.2) ((G, F).1.obj x.1)).inv
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.DayConvolution.unit F G).app (x.2, x.1))
((CategoryTheory.MonoidalCategory.DayConvolution.convolution F G).map (β_ (x.2, x.1).2 (x.2, x.1).1).inv)))
(((CategoryTheory.MonoidalCategory.tensor C).comp
(CategoryTheory.MonoidalCategory.DayConvolution.convolution F G)).map
f) |
SSet.OneTruncation₂.ofNerve₂ | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | (C : Type u) →
[inst : CategoryTheory.Category.{u, u} C] →
CategoryTheory.ReflQuiv.of (SSet.OneTruncation₂ ((SSet.truncation 2).obj (CategoryTheory.nerve C))) ≅
CategoryTheory.ReflQuiv.of C |
Set.pairwise_univ | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {r : α → α → Prop}, Set.univ.Pairwise r ↔ Pairwise r |
StarSubalgebra.mem_top | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] {x : A}, x ∈ ⊤ |
neg_iff_pos_of_mul_neg | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [ExistsAddOfLE R] [PosMulMono R] [MulPosMono R]
[AddRightMono R] [AddRightReflectLE R], a * b < 0 → (a < 0 ↔ 0 < b) |
FirstOrder.Language.Substructure.instInhabited_fg | Mathlib.ModelTheory.FinitelyGenerated | {L : FirstOrder.Language} → {M : Type u_1} → [inst : L.Structure M] → Inhabited { S // S.FG } |
LatticeCon.mk | Mathlib.Order.Lattice.Congruence | {α : Type u_2} →
[inst : Lattice α] →
(toSetoid : Setoid α) →
(∀ {w x y z : α}, toSetoid w x → toSetoid y z → toSetoid (w ⊓ y) (x ⊓ z)) →
(∀ {w x y z : α}, toSetoid w x → toSetoid y z → toSetoid (w ⊔ y) (x ⊔ z)) → LatticeCon α |
Nat.gcd_sub_self_right | Init.Data.Nat.Gcd | ∀ {m n : ℕ}, m ≤ n → m.gcd (n - m) = m.gcd n |
_private.Lean.Compiler.LCNF.PullLetDecls.0.Lean.Compiler.LCNF.Decl.pullInstances._sparseCasesOn_1 | Lean.Compiler.LCNF.PullLetDecls | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((declName : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.LetValue.const declName us args h)) →
(Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t |
Lean.Meta.Simp.NormCastConfig.singlePass._inherited_default | Init.MetaTypes | Bool |
NonUnitalAlgebra.range_id | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A], NonUnitalAlgHom.range (NonUnitalAlgHom.id R A) = ⊤ |
Filter.Tendsto.finCons | Mathlib.Topology.Constructions | ∀ {Y : Type v} {n : ℕ} {A : Fin (n + 1) → Type u_9} [inst : (i : Fin (n + 1)) → TopologicalSpace (A i)] {f : Y → A 0}
{g : Y → (j : Fin n) → A j.succ} {l : Filter Y} {x : A 0} {y : (j : Fin n) → A j.succ},
Filter.Tendsto f l (nhds x) →
Filter.Tendsto g l (nhds y) → Filter.Tendsto (fun a => Fin.cons (f a) (g a)) l (nhds (Fin.cons x y)) |
WithTop.untop.congr_simp | Mathlib.Order.WithBot | ∀ {α : Type u_1} (x x_1 : WithTop α) (e_x : x = x_1) (a : x ≠ ⊤), x.untop a = x_1.untop ⋯ |
CategoryTheory.ComonadicLeftAdjoint.R | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
(L : CategoryTheory.Functor C D) → [self : CategoryTheory.ComonadicLeftAdjoint L] → CategoryTheory.Functor D C |
RootPairing.rootForm_symmetric | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [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) [inst_5 : Fintype ι],
LinearMap.IsSymm P.RootForm |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations.0.RootPairing.GeckConstruction.lie_h_e._simp_1_6 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations | ∀ {M : Type u_4} [inst : AddMonoid M] [IsRightCancelAdd M] {a b : M}, (b = a + b) = (a = 0) |
Fin.cast_eq_cast | Mathlib.Data.Fin.SuccPred | ∀ {n m : ℕ} (h : n = m), Fin.cast h = cast ⋯ |
Submodule.lTensorOne'._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u_2} {S : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S]
(N : Submodule R S), ((Subalgebra.toSubmodule ⊥).mulMap N).range = N |
CategoryTheory.CostructuredArrow.toOver_obj_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor D T) (X : T)
(X_1 : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)),
((CategoryTheory.CostructuredArrow.toOver F X).obj X_1).left = F.obj X_1.left |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.WalkDecomp.0.SimpleGraph.Walk.notMem_support_takeUntil_support_takeUntil_subset._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.WalkDecomp | ∀ {V : Type u_1} {G : SimpleGraph V} {v u : V} [inst : DecidableEq V] {p : G.Walk u v} {w x : V} (hw : w ∈ p.support)
(hx : x ∈ (p.takeUntil w hw).support), w ∈ ((p.takeUntil w hw).takeUntil x hx).support → w ∈ p.support |
uniformContinuous_of_const | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {c : α → β},
(∀ (a b : α), c a = c b) → UniformContinuous c |
Lean.Lsp.TextDocumentIdentifier.uri | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentIdentifier → Lean.Lsp.DocumentUri |
CategoryTheory.Functor.mapCommGrpNatTrans_app_hom_hom_hom | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F F' : CategoryTheory.Functor C D} [inst_6 : F.Braided] [inst_7 : F'.Braided] (f : F ⟶ F')
(X : CategoryTheory.CommGrp C), ((CategoryTheory.Functor.mapCommGrpNatTrans f).app X).hom.hom.hom = f.app X.X |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.andFlatteningPass.processFVar._sparseCasesOn_1 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.coneBack._proof_9 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
{X_1 Y Z : CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K)} (f : X_1 ⟶ Y) (g : Y ⟶ Z)
(j : J),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Over.homMk (CategoryTheory.CategoryStruct.comp f g).hom ⋯)
({ pt := CategoryTheory.Over.mk (Z.π.app CategoryTheory.WithTerminal.star),
π :=
{
app := fun a =>
{ left := Z.π.app (CategoryTheory.WithTerminal.of a),
right :=
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Functor.const J).obj
(CategoryTheory.Over.mk (Z.π.app CategoryTheory.WithTerminal.star))).obj
a).right,
w := ⋯ },
naturality := ⋯ } }.π.app
j) =
{ pt := CategoryTheory.Over.mk (X_1.π.app CategoryTheory.WithTerminal.star),
π :=
{
app := fun a =>
{ left := X_1.π.app (CategoryTheory.WithTerminal.of a),
right :=
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Functor.const J).obj
(CategoryTheory.Over.mk (X_1.π.app CategoryTheory.WithTerminal.star))).obj
a).right,
w := ⋯ },
naturality := ⋯ } }.π.app
j |
Aesop.BuilderName.constructors.sizeOf_spec | Aesop.Rule.Name | sizeOf Aesop.BuilderName.constructors = 1 |
Nat.testBit_two_pow_sub_one | Init.Data.Nat.Bitwise.Lemmas | ∀ (n i : ℕ), (2 ^ n - 1).testBit i = decide (i < n) |
CategoryTheory.MorphismProperty.regularMono.respectsIso | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C], (CategoryTheory.MorphismProperty.regularMono C).RespectsIso |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDense.0.HasCompactSupport.exists_simpleFunc_approx_of_prod.match_1_1 | Mathlib.MeasureTheory.Function.SimpleFuncDense | ∀ {X : Type u_1} {Y : Type u_2} {α : Type u_3} [inst : MeasurableSpace X] [inst_1 : MeasurableSpace Y]
[inst_2 : PseudoMetricSpace α] {f : X × Y → α} {ε : ℝ} ⦃t' : Set (X × Y)⦄
(motive : (∃ g s, MeasurableSet s ∧ t' ⊆ s ∧ ∀ x ∈ s, dist (f x) (g x) < ε) → Prop)
(h : ∃ g s, MeasurableSet s ∧ t' ⊆ s ∧ ∀ x ∈ s, dist (f x) (g x) < ε),
(∀ (g : MeasureTheory.SimpleFunc (X × Y) α) (s : Set (X × Y)) (s_meas : MeasurableSet s) (ts : t' ⊆ s)
(hg : ∀ x ∈ s, dist (f x) (g x) < ε), motive ⋯) →
motive h |
Nat.lcm.eq_1 | Mathlib.Algebra.Order.Antidiag.Nat | ∀ (m n : ℕ), m.lcm n = m * n / m.gcd n |
WithZero.exp_add | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {M : Type u_4} [inst : AddMonoid M] (a b : M), WithZero.exp (a + b) = WithZero.exp a * WithZero.exp b |
PresheafOfModules.isColimitFreeYonedaCoproductsCokernelCofork._proof_6 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Generator | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R),
CategoryTheory.Epi
{ X₁ := (CategoryTheory.Limits.kernel M.fromFreeYonedaCoproduct).freeYonedaCoproduct, X₂ := M.freeYonedaCoproduct,
X₃ := M, f := M.toFreeYonedaCoproduct, g := M.fromFreeYonedaCoproduct, zero := ⋯ }.X₃.fromFreeYonedaCoproduct |
nonZeroDivisors.associated_coe._simp_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a b : ↥(nonZeroDivisors M₀)}, Associated ↑a ↑b = Associated a b |
CompHaus.toCondensed | Mathlib.Condensed.Functors | CompHaus → CondensedSet |
IsCauSeq.cauchy₃ | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [IsAbsoluteValue abv] {f : ℕ → β},
IsCauSeq abv f → ∀ {ε : α}, 0 < ε → ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (f k - f j) < ε |
Std.DHashMap.getKeyD_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {k fallback : α}, k ∉ m₂ → (m₁ ∪ m₂).getKeyD k fallback = m₁.getKeyD k fallback |
Lean.Parser.Term.macroArg | Lean.Parser.Term | Lean.Parser.Parser |
Std.TreeSet.Raw.get?_eq_some_get | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α} (h' : a ∈ t), t.get? a = some (t.get a h') |
_private.Lean.Meta.Injective.0.Lean.Meta.mkInjectiveTheoremValue | Lean.Meta.Injective | Lean.Name → Lean.Expr → Lean.MetaM Lean.Expr |
Lean.Lsp.SignatureHelpParams.context? | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureHelpParams → Option Lean.Lsp.SignatureHelpContext |
Lean.IR.Expr.ctor.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) →
t.ctorIdx = 0 → ((i : Lean.IR.CtorInfo) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.ctor i ys)) → motive t |
USize.not_inj | Init.Data.UInt.Bitwise | ∀ {a b : USize}, ~~~a = ~~~b ↔ a = b |
_private.Mathlib.Data.Seq.Computation.0.Computation.LiftRelAux.match_1.splitter | Mathlib.Data.Seq.Computation | {α : Type u_1} →
{β : Type u_2} →
(motive : α ⊕ Computation α → β ⊕ Computation β → Sort u_3) →
(x : α ⊕ Computation α) →
(x_1 : β ⊕ Computation β) →
((a : α) → (b : β) → motive (Sum.inl a) (Sum.inl b)) →
((a : α) → (cb : Computation β) → motive (Sum.inl a) (Sum.inr cb)) →
((ca : Computation α) → (b : β) → motive (Sum.inr ca) (Sum.inl b)) →
((ca : Computation α) → (cb : Computation β) → motive (Sum.inr ca) (Sum.inr cb)) → motive x x_1 |
FreeAlgebra.star_ι | Mathlib.Algebra.Star.Free | ∀ {R : Type u_1} [inst : CommSemiring R] {X : Type u_2} (x : X), star (FreeAlgebra.ι R x) = FreeAlgebra.ι R x |
UniformSpace.ball | Mathlib.Topology.UniformSpace.Defs | {β : Type ub} → β → Set (β × β) → Set β |
CategoryTheory.MonoidalCategory.DayConvolutionUnit.rightUnitorCorepresentingIso_inv_app_app | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
(F X : CategoryTheory.Functor C V)
(a :
(CategoryTheory.coyoneda.obj
(Opposite.op
(F, CategoryTheory.Functor.fromPUnit (CategoryTheory.MonoidalCategoryStruct.tensorUnit V)).1)).obj
X)
(X_1 : C × CategoryTheory.Discrete PUnit.{1}),
((CategoryTheory.MonoidalCategory.DayConvolutionUnit.rightUnitorCorepresentingIso F).inv.app X a).app X_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor (F.obj X_1.1)).hom
(CategoryTheory.CategoryStruct.comp (a.app X_1.1)
(CategoryTheory.CategoryStruct.comp (X.map ((CategoryTheory.prod.rightUnitorEquivalence C).unit.app X_1).1)
(CategoryTheory.CategoryStruct.comp (X.map ((CategoryTheory.prod.rightUnitorEquivalence C).unitInv.app X_1).1)
(X.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X_1.1).inv)))) |
CategoryTheory.Precoverage.Saturate.below.pullback | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.Precoverage C}
{motive : (X : C) → (a : CategoryTheory.Sieve X) → J.Saturate X a → Prop} (X : C) (S : CategoryTheory.Sieve X)
(a : J.Saturate X S) (Y : C) (f : Y ⟶ X),
CategoryTheory.Precoverage.Saturate.below a → motive X S a → CategoryTheory.Precoverage.Saturate.below ⋯ |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_6 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2}, Std.DTreeMap.Internal.Impl.leaf.size ≤ Std.DTreeMap.Internal.Impl.leaf.size + 1 |
Std.DTreeMap.Raw.containsThenInsertIfNew_snd | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k}, (t.containsThenInsertIfNew k v).2 = t.insertIfNew k v |
CategoryTheory.Under.pushout._proof_2 | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushoutsAlong f] (x : CategoryTheory.Under X) {x' : CategoryTheory.Under X}
{u : x ⟶ x'},
CategoryTheory.CategoryStruct.comp x.hom
(CategoryTheory.CategoryStruct.comp u.right (CategoryTheory.Limits.pushout.inl x'.hom f)) =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.pushout.inr x'.hom f) |
SimplicialObject.Splitting.πSummand_comp_cofan_inj_id_comp_PInfty_eq_PInfty | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C}
(s : SimplicialObject.Splitting X) [inst_1 : CategoryTheory.Preadditive C] (n : ℕ),
CategoryTheory.CategoryStruct.comp
(s.πSummand (SimplicialObject.Splitting.IndexSet.id (Opposite.op (SimplexCategory.mk n))))
(CategoryTheory.CategoryStruct.comp
((s.cofan (Opposite.op (SimplexCategory.mk n))).inj
(SimplicialObject.Splitting.IndexSet.id (Opposite.op (SimplexCategory.mk n))))
(AlgebraicTopology.DoldKan.PInfty.f n)) =
AlgebraicTopology.DoldKan.PInfty.f n |
Aesop.handleNonfatalError | Aesop.Search.Main | {Q : Type} → [inst : Aesop.Queue Q] → Lean.MessageData → Aesop.SearchM Q (Array Lean.MVarId) |
Std.Rxo.IsAlwaysFinite.mk | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α],
(∀ (init hi : α), ∃ n, (Std.PRange.succMany? n init).elim True fun x => ¬x < hi) → Std.Rxo.IsAlwaysFinite α |
Std.DHashMap.Internal.Raw₀.find?_toList_eq_some_iff_get?_eq_some | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α],
(↑m).WF → ∀ {k : α} {v : β k}, List.find? (fun x => x.fst == k) (↑m).toList = some ⟨k, v⟩ ↔ m.get? k = some v |
PartitionOfUnity.exists_finset_nhds | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] (ρ : PartitionOfUnity ι X) (x₀ : X),
∃ I, ∀ᶠ (x : X) in nhds x₀, ∑ i ∈ I, (ρ i) x = 1 ∧ (Function.support fun x_1 => (ρ x_1) x) ⊆ ↑I |
SeparationQuotient.liftNormedAddGroupHomEquiv._proof_1 | Mathlib.Analysis.Normed.Group.SeparationQuotient | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] {N : Type u_2} [inst_1 : SeminormedAddCommGroup N]
(g : NormedAddGroupHom (SeparationQuotient M) N) (x : M), ‖x‖ = 0 → (g.comp SeparationQuotient.normedMk) x = 0 |
CategoryTheory.BraidedCategory.ofBifunctor | Mathlib.CategoryTheory.Monoidal.Braided.Multifunctor | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
(β : CategoryTheory.MonoidalCategory.curriedTensor C ≅ (CategoryTheory.MonoidalCategory.curriedTensor C).flip) →
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso C).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.BraidedCategory.ofBifunctor.Forward.firstMap₂ β)
(CategoryTheory.BraidedCategory.ofBifunctor.Forward.firstMap₃ C)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.BraidedCategory.ofBifunctor.Forward.secondMap₁ β)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.BraidedCategory.ofBifunctor.Forward.secondMap₂ C)
(CategoryTheory.BraidedCategory.ofBifunctor.Forward.secondMap₃ β)) →
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso C).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.BraidedCategory.ofBifunctor.Reverse.firstMap₂ β)
(CategoryTheory.BraidedCategory.ofBifunctor.Reverse.firstMap₃ C)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.BraidedCategory.ofBifunctor.Reverse.secondMap₁ β)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.BraidedCategory.ofBifunctor.Reverse.secondMap₂ C)
(CategoryTheory.BraidedCategory.ofBifunctor.Reverse.secondMap₃ β)) →
CategoryTheory.BraidedCategory C |
ArchimedeanClass.mk.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (a : M),
ArchimedeanClass.mk a = toAntisymmetrization (fun x1 x2 => x1 ≤ x2) (ArchimedeanOrder.of a) |
Std.ExtDTreeMap.forIn.congr_simp | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {δ : Type w} {m : Type w → Type w₂} [inst : Monad m]
[inst_1 : LawfulMonad m] [inst_2 : Std.TransCmp cmp] (f f_1 : (a : α) → β a → δ → m (ForInStep δ)),
f = f_1 →
∀ (init init_1 : δ),
init = init_1 →
∀ (t t_1 : Std.ExtDTreeMap α β cmp),
t = t_1 → Std.ExtDTreeMap.forIn f init t = Std.ExtDTreeMap.forIn f_1 init_1 t_1 |
isConjRoot_algHom_iff | Mathlib.FieldTheory.Minpoly.IsConjRoot | ∀ {R : Type u_1} {B : Type u_6} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B] {A : Type u_7}
[inst_3 : DivisionRing A] [inst_4 : Algebra R A] [Nontrivial B] {x y : A} (f : A →ₐ[R] B),
IsConjRoot R (f x) (f y) ↔ IsConjRoot R x y |
Nat.instMeasurableSingletonClass | Mathlib.MeasureTheory.MeasurableSpace.Instances | MeasurableSingletonClass ℕ |
_private.Mathlib.Analysis.Convex.Deriv.0.StrictMonoOn.exists_slope_lt_deriv._simp_1_1 | Mathlib.Analysis.Convex.Deriv | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [MulPosReflectLT G₀] {a b c : G₀},
0 < c → (b / c < a) = (b < a * c) |
List.findM?'.match_1 | Mathlib.Data.List.Defs | (motive : ULift.{u_1, 0} Bool → Sort u_2) →
(__discr : ULift.{u_1, 0} Bool) → ((px : Bool) → motive { down := px }) → motive __discr |
SeqCompactSpace.tendsto_subseq | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] [SeqCompactSpace X] (x : ℕ → X),
∃ a φ, StrictMono φ ∧ Filter.Tendsto (x ∘ φ) Filter.atTop (nhds a) |
Lean.Grind.Field.IsOrdered.mul_lt_mul_iff_of_pos_left | Init.Grind.Ordered.Field | ∀ {R : Type u} [inst : Lean.Grind.Field R] [inst_1 : LE R] [inst_2 : LT R] [Std.LawfulOrderLT R]
[inst_4 : Std.IsLinearOrder R] [Lean.Grind.OrderedRing R] {a b c : R}, 0 < c → (c * a < c * b ↔ a < b) |
Substring.Raw.ValidFor.atEnd | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {p : ℕ} {s : Substring.Raw},
Substring.Raw.ValidFor l m r s → (s.atEnd { byteIdx := p } = true ↔ p = String.utf8Len m) |
_private.Mathlib.GroupTheory.OrderOfElement.0.isMulTorsionFree_iff_not_isOfFinOrder._simp_1_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α) (n : ℕ), a ^ n / b ^ n = (a / b) ^ n |
List.Vector.scanl.eq_1 | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} {β : Type u_6} (f : β → α → β) (b : β) (v : List.Vector α n),
List.Vector.scanl f b v = ⟨List.scanl f b v.toList, ⋯⟩ |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.X_eq_of_equiv._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 1 = u ^ 3 * P 1 |
instSelfSliceSubarrayDataSubarray | Init.Data.Array.Subarray | ∀ {α : Type u}, Std.Slice.Self (Std.Slice (Std.Slice.Internal.SubarrayData α)) (Subarray α) |
norm_div | Mathlib.Analysis.Normed.Field.Basic | ∀ {α : Type u_2} [inst : NormedDivisionRing α] (a b : α), ‖a / b‖ = ‖a‖ / ‖b‖ |
TietzeExtension.of_homeo | Mathlib.Topology.TietzeExtension | ∀ {Y : Type v} {Z : Type w} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace Z] [TietzeExtension Z] (e : Y ≃ₜ Z),
TietzeExtension Y |
CategoryTheory.Limits.Cotrident.mkHom._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J]
{s t : CategoryTheory.Limits.Cotrident f} (k : s.pt ⟶ t.pt),
CategoryTheory.CategoryStruct.comp s.π k = t.π →
∀ (j : CategoryTheory.Limits.WalkingParallelFamily J), CategoryTheory.CategoryStruct.comp (s.ι.app j) k = t.ι.app j |
CategoryTheory.Comonad.ComonadicityInternal.main_pair_coreflexive | Mathlib.CategoryTheory.Monad.Comonadicity | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (A : adj.toComonad.Coalgebra),
CategoryTheory.IsCoreflexivePair (G.map A.a) (adj.unit.app (G.obj A.A)) |
Batteries.Tactic.Lint.LintVerbosity.low.elim | Batteries.Tactic.Lint.Frontend | {motive : Batteries.Tactic.Lint.LintVerbosity → Sort u} →
(t : Batteries.Tactic.Lint.LintVerbosity) → t.ctorIdx = 0 → motive Batteries.Tactic.Lint.LintVerbosity.low → motive t |
TopologicalSpace.Opens.openPartialHomeomorphSubtypeCoe._proof_1 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : TopologicalSpace.Opens X), Topology.IsOpenEmbedding Subtype.val |
Equiv.Perm.sigmaCongrRightHom | Mathlib.Algebra.Group.End | {α : Type u_7} → (β : α → Type u_8) → ((a : α) → Equiv.Perm (β a)) →* Equiv.Perm ((a : α) × β a) |
ContMDiffMap.coeFnAlgHom._proof_7 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_5} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {N : Type u_2}
[inst_4 : TopologicalSpace N] [inst_5 : ChartedSpace H N] {n : WithTop ℕ∞} {A : Type u_1} [inst_6 : NormedRing A]
[inst_7 : NormedAlgebra 𝕜 A] [inst_8 : ContMDiffRing (modelWithCornersSelf 𝕜 A) n A] (x : 𝕜),
⇑((algebraMap 𝕜 (ContMDiffMap I (modelWithCornersSelf 𝕜 A) N A n)) x) =
⇑((algebraMap 𝕜 (ContMDiffMap I (modelWithCornersSelf 𝕜 A) N A n)) x) |
Lean.Lsp.CodeActionTriggerKind | Lean.Data.Lsp.CodeActions | Type |
_private.Lean.Meta.UnificationHint.0.Lean.Meta.tryUnificationHints.tryCandidate.match_3 | Lean.Meta.UnificationHint | (motive : Lean.LOption Lean.Expr → Sort u_1) →
(__do_lift : Lean.LOption Lean.Expr) →
((val : Lean.Expr) → motive (Lean.LOption.some val)) → ((x : Lean.LOption Lean.Expr) → motive x) → motive __do_lift |
StrictAntiOn.antitoneOn | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
StrictAntiOn f s → AntitoneOn f s |
Lean.Server.Watchdog.ServerContext.noConfusionType | Lean.Server.Watchdog | Sort u → Lean.Server.Watchdog.ServerContext → Lean.Server.Watchdog.ServerContext → Sort u |
Submodule.map_iInf | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] {ι : Sort u_9} [Nonempty ι] {p : ι → Submodule R M} (f : M →ₛₗ[σ₁₂] M₂),
Function.Injective ⇑f → Submodule.map f (⨅ i, p i) = ⨅ i, Submodule.map f (p i) |
StarSubalgebra.subtype._proof_6 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A) (x : ↥S),
↑(star x) = ↑(star x) |
Matrix.toSquareBlockProp | Mathlib.Data.Matrix.Block | {m : Type u_2} → {α : Type u_12} → Matrix m m α → (p : m → Prop) → Matrix { a // p a } { a // p a } α |
AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | CategoryTheory.Functor AlgebraicGeometry.LocallyRingedSpace (AlgebraicGeometry.SheafedSpace CommRingCat) |
Lean.Elab.Do.ControlStack.restoreCont | Lean.Elab.Do.Control | Lean.Elab.Do.ControlStack → Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont |
instAssociativeMax_mathlib | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α], Std.Associative fun x1 x2 => x1 ⊔ x2 |
Lean.Parser.Command.declModifiers | Lean.Parser.Command | Bool → Lean.Parser.Parser |
_private.Mathlib.CategoryTheory.Bicategory.Free.0.CategoryTheory.FreeBicategory.«_aux_Mathlib_CategoryTheory_Bicategory_Free___macroRules__private_Mathlib_CategoryTheory_Bicategory_Free_0_CategoryTheory_FreeBicategory_termλ__1» | Mathlib.CategoryTheory.Bicategory.Free | Lean.Macro |
_private.Mathlib.Data.Finset.Sum.0.Finset.disjSum_subset._simp_1_1 | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ |
CategoryTheory.CategoryOfElements.toStructuredArrow._proof_1 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor C (Type u_1))
{X Y : F.Elements} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.mk fun x => X.snd).hom (F.map ↑f) =
(CategoryTheory.StructuredArrow.mk fun x => Y.snd).hom |
CategoryTheory.Functor.splitMonoEquiv._proof_4 | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
[inst_2 : F.Full] [inst_3 : F.Faithful],
Function.LeftInverse (fun s => { retraction := F.preimage s.retraction, id := ⋯ }) fun f_1 => f_1.map F |
AddCommGroup.modEq_iff_toIcoDiv_eq_toIocDiv_add_one | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) {a b : α}, a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b + 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.