name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Limits.createsLimitsOfShapeOfCreatesEqualizersAndProducts._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{K : CategoryTheory.Functor J C},
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete J) C →
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) C →
CategoryTheory.Limits.HasEqualizers C → CategoryTheory.Limits.HasLimit K |
CommAlgCat.algEquivOfIso_apply | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {A B : CommAlgCat R} (i : A ≅ B) (a : ↑A),
(CommAlgCat.algEquivOfIso i) a = (CategoryTheory.ConcreteCategory.hom i.hom) a |
Aesop.TreeRef.rec | Aesop.Tree.Traversal | {motive : Aesop.TreeRef → Sort u} →
((gref : Aesop.GoalRef) → motive (Aesop.TreeRef.goal gref)) →
((rref : Aesop.RappRef) → motive (Aesop.TreeRef.rapp rref)) →
((cref : Aesop.MVarClusterRef) → motive (Aesop.TreeRef.mvarCluster cref)) → (t : Aesop.TreeRef) → motive t |
div_ne_one | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a / b ≠ 1 ↔ a ≠ b |
ENat.instUniqueUnits | Mathlib.Data.ENat.Basic | Unique ℕ∞ˣ |
ContinuousMultilinearMap.linearDeriv.congr_simp | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
(f f_1 : ContinuousMultilinearMap R M₁ M₂),
f = f_1 →
∀ [inst_7 : ContinuousAdd M₂] [inst_8 : DecidableEq ι] [inst_9 : Fintype ι] (x x_1 : (i : ι) → M₁ i),
x = x_1 → f.linearDeriv x = f_1.linearDeriv x_1 |
Subsemigroup.op._proof_1 | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_1} [inst : Mul M] (x : Subsemigroup M) {a b : Mᵐᵒᵖ},
a ∈ MulOpposite.unop ⁻¹' ↑x → b ∈ MulOpposite.unop ⁻¹' ↑x → MulOpposite.unop b * MulOpposite.unop a ∈ x |
FirstOrder.Language.presburger.funMap_one | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | ∀ {M : Type u_2} [inst : Zero M] [inst_1 : One M] [inst_2 : Add M] {v : Fin 0 → M},
FirstOrder.Language.Structure.funMap FirstOrder.presburgerFunc.one v = 1 |
CategoryTheory.Bicategory.Prod.sectL._proof_8 | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u_2) [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C] (c : C)
{a b c_1 : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c_1),
CategoryTheory.Prod.mkHom (CategoryTheory.Bicategory.whiskerRight η h)
(CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id c)) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Iso.refl (CategoryTheory.CategoryStruct.comp f h)).prod
(CategoryTheory.Bicategory.leftUnitor (h, CategoryTheory.CategoryStruct.id c).2).symm).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight
(CategoryTheory.Prod.mkHom η (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id c)))
(CategoryTheory.Prod.mkHom h (CategoryTheory.CategoryStruct.id c)))
((CategoryTheory.Iso.refl (CategoryTheory.CategoryStruct.comp g h)).prod
(CategoryTheory.Bicategory.leftUnitor (h, CategoryTheory.CategoryStruct.id c).2).symm).inv) |
TopologicalSpace.prod_mono | Mathlib.Topology.Constructions.SumProd | ∀ {α : Type u_5} {β : Type u_6} {σ₁ σ₂ : TopologicalSpace α} {τ₁ τ₂ : TopologicalSpace β},
σ₁ ≤ σ₂ → τ₁ ≤ τ₂ → instTopologicalSpaceProd ≤ instTopologicalSpaceProd |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.mk.sizeOf_spec | Batteries.Data.MLList.Basic | ∀ {m : Type u → Type u} [inst : (a : Type u) → SizeOf (m a)] (listM : Type u → Type u) (nil : {α : Type u} → listM α)
(cons : {α : Type u} → α → listM α → listM α) (thunk : {α : Type u} → (Unit → listM α) → listM α)
(squash : {α : Type u} → (Unit → m (listM α)) → listM α)
(uncons : {α : Type u} → [Monad m] → listM α → m (Option (α × listM α)))
(uncons? : {α : Type u} → listM α → Option (Option (α × listM α))),
sizeOf
{ listM := listM, nil := nil, cons := cons, thunk := thunk, squash := squash, uncons := uncons,
uncons? := uncons? } =
1 |
coe_iterateFrobeniusEquiv | Mathlib.FieldTheory.Perfect | ∀ (R : Type u_1) (p n : ℕ) [inst : CommSemiring R] [inst_1 : ExpChar R p] [inst_2 : PerfectRing R p],
⇑(iterateFrobeniusEquiv R p n) = ⇑(iterateFrobenius R p n) |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.incMod | Std.Sync.Channel | ℕ → ℕ → ℕ |
Flow.cont' | Mathlib.Dynamics.Flow | ∀ {τ : Type u_1} [inst : TopologicalSpace τ] [inst_1 : AddMonoid τ] [inst_2 : ContinuousAdd τ] {α : Type u_2}
[inst_3 : TopologicalSpace α] (self : Flow τ α), Continuous (Function.uncurry self.toFun) |
Turing.Dir.ofNat_ctorIdx | Mathlib.Computability.Tape | ∀ (x : Turing.Dir), Turing.Dir.ofNat x.ctorIdx = x |
_private.Mathlib.FieldTheory.Differential.Basic.0.Differential.logDeriv_div._simp_1_7 | Mathlib.FieldTheory.Differential.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1.else_eq | Lean.Elab.Tactic.Try | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1✝ t some «else» = «else» h |
Filter.prod_map_map_eq' | Mathlib.Order.Filter.Prod | ∀ {α₁ : Type u_6} {α₂ : Type u_7} {β₁ : Type u_8} {β₂ : Type u_9} (f : α₁ → α₂) (g : β₁ → β₂) (F : Filter α₁)
(G : Filter β₁), Filter.map f F ×ˢ Filter.map g G = Filter.map (Prod.map f g) (F ×ˢ G) |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Finsupp.iInf_ker_lapply_le_bot._simp_1_4 | Mathlib.LinearAlgebra.Finsupp.Span | ∀ (R : Type u_1) {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
(x ∈ ⊥) = (x = 0) |
Submonoid.mk_inv_mul_mk_eq_one | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units),
⟨(Units.coeHom M) x⁻¹, ⋯⟩ * ⟨(Units.coeHom M) x, ⋯⟩ = 1 |
Lean.Server.Test.Runner.Client.HighlightedMsgEmbed.goal.elim | Lean.Server.Test.Runner | {motive_1 : Lean.Server.Test.Runner.Client.HighlightedMsgEmbed → Sort u} →
(t : Lean.Server.Test.Runner.Client.HighlightedMsgEmbed) →
t.ctorIdx = 1 →
((a : Lean.Server.Test.Runner.Client.InteractiveGoal) →
motive_1 (Lean.Server.Test.Runner.Client.HighlightedMsgEmbed.goal a)) →
motive_1 t |
Lean.Elab.Term.LetRecDeclView.mk.inj | Lean.Elab.LetRec | ∀ {ref : Lean.Syntax} {attrs : Array Lean.Elab.Attribute} {shortDeclName declName : Lean.Name}
{parentName? : Option Lean.Name} {binderIds : Array Lean.Syntax} {binders : Lean.Syntax} {type mvar : Lean.Expr}
{valStx : Lean.Syntax} {termination : Lean.Elab.TerminationHints}
{docString? : Option (Lean.TSyntax `Lean.Parser.Command.docComment × Bool)} {ref_1 : Lean.Syntax}
{attrs_1 : Array Lean.Elab.Attribute} {shortDeclName_1 declName_1 : Lean.Name} {parentName?_1 : Option Lean.Name}
{binderIds_1 : Array Lean.Syntax} {binders_1 : Lean.Syntax} {type_1 mvar_1 : Lean.Expr} {valStx_1 : Lean.Syntax}
{termination_1 : Lean.Elab.TerminationHints}
{docString?_1 : Option (Lean.TSyntax `Lean.Parser.Command.docComment × Bool)},
{ ref := ref, attrs := attrs, shortDeclName := shortDeclName, declName := declName, parentName? := parentName?,
binderIds := binderIds, binders := binders, type := type, mvar := mvar, valStx := valStx,
termination := termination, docString? := docString? } =
{ ref := ref_1, attrs := attrs_1, shortDeclName := shortDeclName_1, declName := declName_1,
parentName? := parentName?_1, binderIds := binderIds_1, binders := binders_1, type := type_1, mvar := mvar_1,
valStx := valStx_1, termination := termination_1, docString? := docString?_1 } →
ref = ref_1 ∧
attrs = attrs_1 ∧
shortDeclName = shortDeclName_1 ∧
declName = declName_1 ∧
parentName? = parentName?_1 ∧
binderIds = binderIds_1 ∧
binders = binders_1 ∧
type = type_1 ∧
mvar = mvar_1 ∧ valStx = valStx_1 ∧ termination = termination_1 ∧ docString? = docString?_1 |
_aux_Mathlib_Combinatorics_Quiver_Basic___unexpand_Quiver_Hom_1 | Mathlib.Combinatorics.Quiver.Basic | Lean.PrettyPrinter.Unexpander |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.normalizationMonoidOfMonoidHomRightInverse._simp_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) |
AlgebraicGeometry.Scheme.Modules.pushforwardId | Mathlib.AlgebraicGeometry.Modules.Sheaf | (X : AlgebraicGeometry.Scheme) →
AlgebraicGeometry.Scheme.Modules.pushforward (CategoryTheory.CategoryStruct.id X) ≅
CategoryTheory.Functor.id X.Modules |
Ideal.quotientToQuotientRangePowQuotSucc | Mathlib.NumberTheory.RamificationInertia.Basic | {R : Type u} →
[inst : CommRing R] →
{S : Type v} →
[inst_1 : CommRing S] →
(p : Ideal R) →
(P : Ideal S) →
[inst_2 : Algebra R S] →
[hfp : NeZero (Ideal.ramificationIdx (algebraMap R S) p P)] →
{i : ℕ} →
{a : S} →
a ∈ P ^ i →
S ⧸ P →ₗ[R ⧸ p]
↥(Ideal.map (Ideal.Quotient.mk (P ^ Ideal.ramificationIdx (algebraMap R S) p P)) (P ^ i)) ⧸
(p.powQuotSuccInclusion P i).range |
CategoryTheory.MonoidalLinear.whiskerLeft_smul | Mathlib.CategoryTheory.Monoidal.Linear | ∀ {R : Type u_1} {inst : Semiring R} {C : Type u_2} {inst_1 : CategoryTheory.Category.{v_1, u_2} C}
{inst_2 : CategoryTheory.Preadditive C} {inst_3 : CategoryTheory.Linear R C}
{inst_4 : CategoryTheory.MonoidalCategory C} {inst_5 : CategoryTheory.MonoidalPreadditive C}
[self : CategoryTheory.MonoidalLinear R C] (X : C) {Y Z : C} (r : R) (f : Y ⟶ Z),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (r • f) =
r • CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f |
EReal.sub_le_iff_le_add | Mathlib.Data.EReal.Operations | ∀ {a b c : EReal}, b ≠ ⊥ ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ ⊥ → (a - b ≤ c ↔ a ≤ c + b) |
CategoryTheory.Subobject.ofMkLE | Mathlib.CategoryTheory.Subobject.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{B A : C} →
(f : A ⟶ B) →
[inst_1 : CategoryTheory.Mono f] →
(X : CategoryTheory.Subobject B) →
CategoryTheory.Subobject.mk f ≤ X → (A ⟶ CategoryTheory.Subobject.underlying.obj X) |
ContinuousAffineMap.const_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] [inst_9 : TopologicalSpace V]
[inst_10 : IsTopologicalAddTorsor P] [inst_11 : TopologicalSpace W] [inst_12 : IsTopologicalAddTorsor Q] (q : Q),
(ContinuousAffineMap.const R P q).contLinear = 0 |
CategoryTheory.ObjectProperty.Is.rec | Mathlib.CategoryTheory.ObjectProperty.Basic | {C : Type u} →
[inst : CategoryTheory.CategoryStruct.{v, u} C] →
{P : CategoryTheory.ObjectProperty C} →
{X : C} → {motive : P.Is X → Sort u_1} → ((prop : P X) → motive ⋯) → (t : P.Is X) → motive t |
Std.ExtTreeSet.mem_inter_iff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
k ∈ t₁ ∩ t₂ ↔ k ∈ t₁ ∧ k ∈ t₂ |
HeytAlg.ext_iff | Mathlib.Order.Category.HeytAlg | ∀ {X Y : HeytAlg} {f g : X ⟶ Y},
f = g ↔ ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x |
convexHull_neg | Mathlib.Analysis.Convex.Hull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] (s : Set E), (convexHull 𝕜) (-s) = -(convexHull 𝕜) s |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData_i | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {π : kf.pt ⟶ H} {ι : H ⟶ cc.pt}
(fac :
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι kf) (CategoryTheory.Limits.Cofork.π cc) =
CategoryTheory.CategoryStruct.comp π ι)
[inst_2 : CategoryTheory.Epi π] [inst_3 : CategoryTheory.Mono ι],
(CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData S hkf hcc fac).i =
CategoryTheory.Limits.Fork.ι kf |
Lean.Elab.MonadParentDecl.casesOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadParentDecl m → Sort u} →
(t : Lean.Elab.MonadParentDecl m) →
((getParentDeclName? : m (Option Lean.Name)) → motive { getParentDeclName? := getParentDeclName? }) → motive t |
_private.Lean.Parser.Basic.0.Lean.Parser.rawStrLitFnAux.errorUnterminated | Lean.Parser.Basic | String.Pos.Raw → Lean.Parser.ParserState → Lean.Parser.ParserState |
RingEquiv.piOptionEquivProd | Mathlib.Algebra.Ring.Equiv | {ι : Type u_7} →
{R : Option ι → Type u_8} →
[inst : (i : Option ι) → NonUnitalNonAssocSemiring (R i)] →
((i : Option ι) → R i) ≃+* R none × ((i : ι) → R (some i)) |
_private.Mathlib.Analysis.Analytic.Composition.0.HasFPowerSeriesWithinAt.comp._simp_1_1 | Mathlib.Analysis.Analytic.Composition | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < min b c) = (a < b ∧ a < c) |
instSubsingleton | Init.Core | ∀ (p : Prop), Subsingleton p |
Complex.isAlgebraic_sin_rat_mul_pi | Mathlib.NumberTheory.Niven | ∀ (q : ℚ), IsAlgebraic ℤ (Complex.sin (↑q * ↑Real.pi)) |
Lean.Parser.Command.recommended_spelling._regBuiltin.Lean.Parser.Command.recommended_spelling.formatter_7 | Lean.Parser.Command | IO Unit |
Pi.evalNonUnitalRingHom._proof_2 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_2} (f : I → Type u_1) [inst : (i : I) → NonUnitalNonAssocSemiring (f i)] (i : I) (x y : (i : I) → f i),
(↑(Pi.evalAddMonoidHom f i)).toFun (x + y) =
(↑(Pi.evalAddMonoidHom f i)).toFun x + (↑(Pi.evalAddMonoidHom f i)).toFun y |
CategoryTheory.Cokleisli.mk._flat_ctor | Mathlib.CategoryTheory.Monad.Kleisli | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {U : CategoryTheory.Comonad C} → C → CategoryTheory.Cokleisli U |
ContDiffBump.rOut | Mathlib.Analysis.Calculus.BumpFunction.Basic | {E : Type u_1} → {c : E} → ContDiffBump c → ℝ |
NormedAddCommGroup.ofCoreReplaceTopology._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] [inst_3 : Norm E]
[T : TopologicalSpace E] (core : NormedSpace.Core 𝕜 E) (H : T = PseudoEMetricSpace.toUniformSpace.toTopologicalSpace)
{x y : E}, dist x y = 0 → x = y |
ContinuousLinearEquiv.summable | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {ι : Type u_5} {R : Type u_7} {R₂ : Type u_8} {M : Type u_9} {M₂ : Type u_10} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid M₂]
[inst_5 : Module R₂ M₂] [inst_6 : TopologicalSpace M] [inst_7 : TopologicalSpace M₂] {σ : R →+* R₂} {σ' : R₂ →+* R}
[inst_8 : RingHomInvPair σ σ'] [inst_9 : RingHomInvPair σ' σ] {L : SummationFilter ι} {f : ι → M} (e : M ≃SL[σ] M₂),
Summable (fun b => e (f b)) L ↔ Summable f L |
Std.HashSet.Raw.Equiv.of_forall_contains_eq | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [LawfulBEq α],
m₁.WF → m₂.WF → (∀ (k : α), m₁.contains k = m₂.contains k) → m₁.Equiv m₂ |
Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.74134663._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) |
FreeAddMonoid.casesOn_zero | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (h0 : C 0)
(ih : (x : α) → (xs : FreeAddMonoid α) → C (FreeAddMonoid.of x + xs)), FreeAddMonoid.casesOn 0 h0 ih = h0 |
ContinuousMap.coeFnRingHom_apply | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Semiring β]
[inst_3 : IsTopologicalSemiring β] (f : C(α, β)) (a : α), ContinuousMap.coeFnRingHom f a = f a |
_private.Std.Sync.Broadcast.0.Std.Bounded.State.size | Std.Sync.Broadcast | {α : Type} → Std.Bounded.State✝ α → ℕ |
Vector.findFinIdx?_subtype | Init.Data.Vector.Find | ∀ {α : Type u_1} {n : ℕ} {p : α → Prop} {xs : Vector { x // p x } n} {f : { x // p x } → Bool} {g : α → Bool},
(∀ (x : α) (h : p x), f ⟨x, h⟩ = g x) → Vector.findFinIdx? f xs = Vector.findFinIdx? g xs.unattach |
AffineIsometryEquiv._sizeOf_1 | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_5} →
{P : Type u_10} →
{P₂ : Type u_11} →
{inst : NormedField 𝕜} →
{inst_1 : SeminormedAddCommGroup V} →
{inst_2 : NormedSpace 𝕜 V} →
{inst_3 : PseudoMetricSpace P} →
{inst_4 : NormedAddTorsor V P} →
{inst_5 : SeminormedAddCommGroup V₂} →
{inst_6 : NormedSpace 𝕜 V₂} →
{inst_7 : PseudoMetricSpace P₂} →
{inst_8 : NormedAddTorsor V₂ P₂} →
[SizeOf 𝕜] → [SizeOf V] → [SizeOf V₂] → [SizeOf P] → [SizeOf P₂] → (P ≃ᵃⁱ[𝕜] P₂) → ℕ |
Lean.Lsp.DocumentFilter.rec | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.DocumentFilter → Sort u} →
((language? scheme? pattern? : Option String) →
motive { language? := language?, scheme? := scheme?, pattern? := pattern? }) →
(t : Lean.Lsp.DocumentFilter) → motive t |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_right_ne._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x |
Inner.noConfusionType | Mathlib.Analysis.InnerProductSpace.Defs | Sort u → {𝕜 : Type u_4} → {E : Type u_5} → Inner 𝕜 E → {𝕜' : Type u_4} → {E' : Type u_5} → Inner 𝕜' E' → Sort u |
PUnit.mulActionWithZero._proof_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : MonoidWithZero R] (a : R), a • 0 = 0 |
RestrictedProduct.mapAlong_continuous | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι₁ : Type u_3} {ι₂ : Type u_4} (R₁ : ι₁ → Type u_5) (R₂ : ι₂ → Type u_6) [inst : (i : ι₁) → TopologicalSpace (R₁ i)]
[inst_1 : (i : ι₂) → TopologicalSpace (R₂ i)] {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} {A₁ : (i : ι₁) → Set (R₁ i)}
{A₂ : (i : ι₂) → Set (R₂ i)} (f : ι₂ → ι₁) (hf : Filter.Tendsto f 𝓕₂ 𝓕₁) (φ : (j : ι₂) → R₁ (f j) → R₂ j)
(hφ : ∀ᶠ (j : ι₂) in 𝓕₂, Set.MapsTo (φ j) (A₁ (f j)) (A₂ j)),
(∀ (j : ι₂), Continuous (φ j)) → Continuous (RestrictedProduct.mapAlong R₁ R₂ f hf φ hφ) |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.Ici_nsmul_eq.match_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (x : 1 ≠ 0), motive 1 x) → (∀ (n : ℕ) (x : n + 2 ≠ 0), motive n.succ.succ x) → motive x x_1 |
Int8.shiftLeft | Init.Data.SInt.Basic | Int8 → Int8 → Int8 |
_private.Mathlib.Analysis.Analytic.CPolynomialDef.0.HasFiniteFPowerSeriesOnBall.eq_partialSum._simp_1_1 | Mathlib.Analysis.Analytic.CPolynomialDef | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) |
Quiver.zigzagSetoid.match_1 | Mathlib.Combinatorics.Quiver.ConnectedComponent | ∀ (V : Type u_1) [inst : Quiver V] {x y : V} (motive : Nonempty (Quiver.Path x y) → Prop)
(x_1 : Nonempty (Quiver.Path x y)), (∀ (p : Quiver.Path x y), motive ⋯) → motive x_1 |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.rcases.match_8 | Lean.Elab.Tactic.RCases | (motive : Option Lean.Ident × Lean.Syntax → Sort u_1) →
(x : Option Lean.Ident × Lean.Syntax) →
((hName? : Option Lean.Ident) → (tgt : Lean.Syntax) → motive (hName?, tgt)) → motive x |
MeasureTheory.withDensityᵥ_add | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] {f g : α → E},
MeasureTheory.Integrable f μ →
MeasureTheory.Integrable g μ → μ.withDensityᵥ (f + g) = μ.withDensityᵥ f + μ.withDensityᵥ g |
Set.fintypeOfFintypeImage | Mathlib.Data.Set.Finite.Basic | {α : Type u} →
{β : Type v} →
(s : Set α) → {f : α → β} → {g : β → Option α} → Function.IsPartialInv f g → [Fintype ↑(f '' s)] → Fintype ↑s |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mpullbackWithin_mlieBracketWithin_aux | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSpace H']
{E' : Type u_6} [inst_7 : NormedAddCommGroup E'] [inst_8 : NormedSpace 𝕜 E'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] [IsManifold I 2 M]
[inst_12 : IsManifold I' 2 M'] [CompleteSpace E] [CompleteSpace E'] {f : M → M'} {V W : (x : M') → TangentSpace I' x}
{x₀ : M} {s : Set M} {t : Set M'},
MDifferentiableWithinAt I' I'.tangent (fun x => { proj := x, snd := V x }) t (f x₀) →
MDifferentiableWithinAt I' I'.tangent (fun x => { proj := x, snd := W x }) t (f x₀) →
UniqueMDiffOn I s →
ContMDiffOn I I' 2 f s →
x₀ ∈ s →
t ⊆ (extChartAt I' (f x₀)).source →
Set.MapsTo f s t →
IsSymmSndFDerivWithinAt 𝕜 (↑(extChartAt I' (f x₀)) ∘ f ∘ ↑(extChartAt I x₀).symm)
(↑(extChartAt I x₀).symm ⁻¹' s ∩ Set.range ↑I) (↑(extChartAt I x₀) x₀) →
VectorField.mpullbackWithin I I' f (VectorField.mlieBracketWithin I' V W t) s x₀ =
VectorField.mlieBracketWithin I (VectorField.mpullbackWithin I I' f V s)
(VectorField.mpullbackWithin I I' f W s) s x₀ |
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence_inverse_map_hom | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat))
(ι : Type u_1) [inst_1 : Unique ι] {X S : C} (f : X ⟶ S)
{X_1 Y : (CategoryTheory.Adjunction.ofCat (F.map f.op.toLoc).adj).toComonad.Coalgebra} (φ : X_1 ⟶ Y) (i : ι),
((CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence F ι f).inverse.map φ).hom i = φ.f |
AlgebraicGeometry.Scheme.range_fromSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | ∀ {X : AlgebraicGeometry.Scheme} (x : ↥X), Set.range ⇑(X.fromSpecResidueField x) = {x} |
MonoidAlgebra.mapDomainRingEquiv_apply | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_2} {M : Type u_5} {N : Type u_6} [inst : Semiring R] [inst_1 : Monoid M] [inst_2 : Monoid N] (e : M ≃* N)
(x : MonoidAlgebra R M) (n : N), ((MonoidAlgebra.mapDomainRingEquiv R e) x) n = x (e.symm n) |
Filter.Germ.coeRingHom | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {R : Type u_5} → [inst : Semiring R] → (l : Filter α) → (α → R) →+* l.Germ R |
LSeries.logMul | Mathlib.NumberTheory.LSeries.Deriv | (ℕ → ℂ) → ℕ → ℂ |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.eq_zero_of_comapDomain_eq_zero._simp_1_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ |
intervalIntegral.intervalIntegral_pos_of_pos_on | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {f : ℝ → ℝ} {a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b → (∀ x ∈ Set.Ioo a b, 0 < f x) → a < b → 0 < ∫ (x : ℝ) in a..b, f x |
Std.instCoeDepAnyAsyncStreamOfAsyncStream | Std.Sync.StreamMap | {t α : Type} → {x : t} → [Std.Internal.Async.IO.AsyncStream t α] → CoeDep t x (Std.AnyAsyncStream α) |
List.forall₂_nil_left_iff._simp_1 | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l : List β}, List.Forall₂ R [] l = (l = []) |
AddMonoidAlgebra.nonAssocSemiring.eq_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddZeroClass M],
AddMonoidAlgebra.nonAssocSemiring =
{ toNonUnitalNonAssocSemiring := AddMonoidAlgebra.nonUnitalNonAssocSemiring, toOne := AddMonoidAlgebra.zero,
one_mul := ⋯, mul_one := ⋯, natCast := fun n => AddMonoidAlgebra.single 0 ↑n, natCast_zero := ⋯,
natCast_succ := ⋯ } |
_private.Mathlib.Data.List.Lattice.0.List.bagInter_sublist_left._proof_1_4 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l₁ l₂ : List α),
(l₁.bagInter (l₂.erase a)).Sublist l₁ → (a :: l₁.bagInter (l₂.erase a)).Sublist (a :: l₁) |
CategoryTheory.ShortComplex.SnakeInput.mono_L₀_f | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C) [CategoryTheory.Mono S.L₁.f], CategoryTheory.Mono S.L₀.f |
Localization.mk_eq_monoidOf_mk' | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M}, Localization.mk = (Localization.monoidOf S).mk' |
lt_add_iff_pos_left._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α] [AddRightStrictMono α] [AddRightReflectLT α] (a : α) {b : α},
(a < b + a) = (0 < b) |
ContinuousMapZero.nonUnitalStarAlgHom_postcomp._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ (X : Type u_2) {M : Type u_4} {R : Type u_3} {S : Type u_1} [inst : Zero X] [inst_1 : CommSemiring M]
[inst_2 : TopologicalSpace X] [inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace S] [inst_5 : CommSemiring R]
[inst_6 : StarRing R] [inst_7 : IsTopologicalSemiring R] [inst_8 : CommSemiring S] [inst_9 : StarRing S]
[inst_10 : IsTopologicalSemiring S] [inst_11 : Module M R] [inst_12 : Module M S] [inst_13 : ContinuousConstSMul M R]
[inst_14 : ContinuousConstSMul M S] (φ : R →⋆ₙₐ[M] S) (hφ : Continuous ⇑φ) (r : M) (f : ContinuousMapZero X R)
(x : X),
({ toFun := ⇑φ, continuous_toFun := hφ, map_zero' := ⋯ }.comp (r • f)) x =
((MonoidHom.id M) r • { toFun := ⇑φ, continuous_toFun := hφ, map_zero' := ⋯ }.comp f) x |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.singleton_le_singleton._simp_1_1 | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Finset α} {a : α},
(toColex s ≤ toColex {a}) = ∀ b ∈ s, b ≤ a ∧ (a ∈ s → b = a) |
CategoryTheory.mono_iff_isIso_fst | Mathlib.CategoryTheory.Limits.EpiMono | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} {f : X ⟶ Y}
{c : CategoryTheory.Limits.PullbackCone f f} (hc : CategoryTheory.Limits.IsLimit c),
CategoryTheory.Mono f ↔ CategoryTheory.IsIso c.fst |
TwoUniqueProds.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_2} (G : ι → Type u_1) [inst : (i : ι) → Mul (G i)] [∀ (i : ι), TwoUniqueProds (G i)],
TwoUniqueProds ((i : ι) → G i) |
Std.HashMap.Raw.mem_of_mem_filterMap | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → Option γ} {k : α}, m.WF → k ∈ Std.HashMap.Raw.filterMap f m → k ∈ m |
CategoryTheory.InducedWideCategory.congr_simp | Mathlib.CategoryTheory.Widesubcategory | ∀ {C : Type u₁} (D : Type u₂) [inst : CategoryTheory.Category.{v₁, u₂} D] (_F _F_1 : C → D),
_F = _F_1 →
∀ (_P _P_1 : CategoryTheory.MorphismProperty D) (e__P : _P = _P_1) [inst_1 : _P.IsMultiplicative],
CategoryTheory.InducedWideCategory D _F _P = CategoryTheory.InducedWideCategory D _F_1 _P_1 |
Lean.Meta.Grind.Arith.Linear.geAvoiding._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.Search | ℚ → Array (ℚ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → ℚ |
Std.HashMap.Raw.getElem?_insert | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k a : α} {v : β}, (m.insert k v)[a]? = if (k == a) = true then some v else m[a]? |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.recv.match_1 | Std.Sync.Channel | {α : Type} →
(motive : Option α → Sort u_1) →
(__do_lift : Option α) → ((val : α) → motive (some val)) → ((x : Option α) → motive x) → motive __do_lift |
_private.Mathlib.Data.DFinsupp.Multiset.0.DFinsupp.toMultiset_le_toMultiset._simp_1_1 | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, (s ≤ t) = (Multiset.toDFinsupp s ≤ Multiset.toDFinsupp t) |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit.eq_def | Lean.Elab.DeclNameGen | ∀ (e : Lean.Expr) (omitTopForall : optParam Bool false),
Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝ e omitTopForall = do
let __do_lift ← get
if Std.HashSet.contains (Lean.Elab.Command.NameGen.MkNameState.seen✝ __do_lift) e = true then pure ""
else do
let s ← Lean.Elab.Command.NameGen.mkBaseNameCore.visit'✝ e omitTopForall
modify fun st =>
{ seen := Std.HashSet.insert (Lean.Elab.Command.NameGen.MkNameState.seen✝¹ st) e,
consts := Lean.Elab.Command.NameGen.MkNameState.consts✝ st }
pure s |
_private.Mathlib.Data.DFinsupp.Lex.0.DFinsupp.lt_trichotomy_rec._proof_2 | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : LinearOrder ι]
[inst_2 : (i : ι) → LinearOrder (α i)] (f g : Π₀ (i : ι), α i), (f.neLocus g).min = ⊤ → toLex f = toLex g |
Set.Definable.image_comp_equiv | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {β : Type u_1}
{s : Set (β → M)}, A.Definable L s → ∀ (f : α ≃ β), A.Definable L ((fun g => g ∘ ⇑f) '' s) |
Std.ExtDTreeMap.Const.mem_toList_iff_get?_eq_some | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {k : α} {v : β},
(k, v) ∈ Std.ExtDTreeMap.Const.toList t ↔ Std.ExtDTreeMap.Const.get? t k = some v |
Lean.Meta.SolveByElim.saturateSymm | Lean.Meta.Tactic.SolveByElim | Bool → List Lean.Expr → Lean.MetaM (List Lean.Expr) |
ConvexCone.mem_mk | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : SMul R M] {s : Set M} {x : M} {h₁ : ∀ ⦃c : R⦄, 0 < c → ∀ ⦃x : M⦄, x ∈ s → c • x ∈ s}
{h₂ : ∀ ⦃x : M⦄, x ∈ s → ∀ ⦃y : M⦄, y ∈ s → x + y ∈ s}, x ∈ { carrier := s, smul_mem' := h₁, add_mem' := h₂ } ↔ x ∈ s |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.FunBinders.elabFunBinderViews | Lean.Elab.Binders | Array Lean.Elab.Term.BinderView →
ℕ → Lean.Elab.Term.FunBinders.State → Lean.Elab.TermElabM Lean.Elab.Term.FunBinders.State |
Nat.one_lt_succ_succ | Init.Data.Nat.Lemmas | ∀ (n : ℕ), 1 < n.succ.succ |
_private.Qq.Commands.0.Qq.mkLetFVarsFromValues | Qq.Commands | Array Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.