name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Set.Icc.instMonoidWithZero._proof_2 | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] (a : ↑(Set.Icc 0 1)),
1 * a = a | null | false |
Function.Injective.divInvMonoid._proof_8 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Inv M₁] [inst_1 : Pow M₁ ℤ] [inst_2 : DivInvMonoid M₂] (f : M₁ → M₂),
Function.Injective f →
(∀ (x : M₁), f x⁻¹ = (f x)⁻¹) →
(∀ (x : M₁) (n : ℤ), f (x ^ n) = f x ^ n) → ∀ (n : ℕ) (x : M₁), x ^ Int.negSucc n = (x ^ ↑n.succ)⁻¹ | null | false |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.visitFunDecl | Lean.Compiler.LCNF.Specialize | Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.Specialize.SpecializeM✝ (Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) | null | true |
Sigma.fst_injective | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_4} [h : ∀ (a : α), Subsingleton (β a)], Function.Injective Sigma.fst | null | true |
cfcₙ_zero | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ (R : Type u_1) {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | null | true |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.getRemainingArgs.match_1 | Lean.Compiler.LCNF.Specialize | (motive : Lean.Compiler.LCNF.SpecParamInfo → Sort u_1) →
(info : Lean.Compiler.LCNF.SpecParamInfo) →
(Unit → motive Lean.Compiler.LCNF.SpecParamInfo.other) →
((x : Lean.Compiler.LCNF.SpecParamInfo) → motive x) → motive info | null | false |
Lean.Grind.GrobnerConfig.noConfusion | Init.Grind.Config | {P : Sort u} → {t t' : Lean.Grind.GrobnerConfig} → t = t' → Lean.Grind.GrobnerConfig.noConfusionType P t t' | null | false |
CategoryTheory.Bimon.mk'X_X | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C) [inst_3 : CategoryTheory.BimonObj X],
(CategoryTheory.Bimon.mk'X X).X = X | null | true |
Lean.Meta.Grind.NormalizePattern.State.bvarsFound | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.NormalizePattern.State → Std.HashSet ℕ | null | true |
_private.Mathlib.LinearAlgebra.Matrix.ToLinearEquiv.0.Matrix.separatingRight_iff_det_ne_zero._proof_1_1 | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {n : Type u_1} [inst : Fintype n] {A : Type u_2} [inst_1 : CommRing A] [IsDomain A] {M : Matrix n n A}
[inst_3 : DecidableEq n], M.SeparatingRight ↔ ¬M.det = 0 | null | false |
_private.Mathlib.RingTheory.Unramified.LocalRing.0.Localization.exists_awayMap_bijective_of_localRingHom_bijective._simp_1_10 | Mathlib.RingTheory.Unramified.LocalRing | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x : A),
(algebraMap R A) r * x = r • x | null | false |
Plausible.TotalFunction.reprAux | Plausible.Functions | {α : Type u} → {β : Type v} → [Repr α] → [Repr β] → List ((_ : α) × β) → String | Implementation of `Repr (TotalFunction α β)`.
Creates a string for a given `Finmap` and output, `x₀ => y₀, .. xₙ => yₙ`
for each of the entries. The brackets are provided by the calling function.
| true |
IsPredArchimedean.findAtom_le._simp_1 | Mathlib.Order.SuccPred.Tree | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] [inst_2 : IsPredArchimedean α] [inst_3 : OrderBot α]
[inst_4 : DecidableEq α] (r : α), (IsPredArchimedean.findAtom r ≤ r) = True | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isDefEqOffset | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.DefEqM✝ Lean.LBool | Structural counterpart of `Meta.isDefEqOffset`: solves `Nat` offset/numeral constraints such as
`8 + 8 =?= 16`, `3 + (1 + 1) =?= 5`, and `?m + 1 =?= 16` using `isNatValue?` and `isOffset?`
instead of general reduction. Constraints of this form reach `isDefEqMain` when `process`
postpones a quasi-offset constraint (see ... | true |
CategoryTheory.OrthogonalReflection.isLocal_reflectionObj | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} (Z : C)
[inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : ∀ (Z : C), CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_3 : ∀ (Z : C), CategoryTheory.Limits.HasCoproduct Categ... | null | true |
Lean.Internal.isStage0 | Init.Meta.Defs | Unit → Bool | null | true |
AdjoinRoot.isAlgebraic_root | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R}, f ≠ 0 → IsAlgebraic R (AdjoinRoot.root f) | null | true |
ProofWidgets.RpcEncodablePacket.mk._flat_ctor._@.ProofWidgets.Component.Basic.2987839534._hygCtx._hyg.1 | ProofWidgets.Component.Basic | Lean.Json → ProofWidgets.RpcEncodablePacket✝ | null | false |
CompactlySupportedContinuousMap.pullback_addMonoidHom | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : TopologicalSpace α] →
[R1Space α] →
[inst_2 : AddGroup α] →
[inst_3 : TopologicalSpace β] →
[R1Space β] →
[inst_5 : AddGroup β] →
[ContinuousAdd β] →
[... | Pull back a continuous compactly supported function `f` on `β` along a closed
embedding `φ : α →+ β` to the continuous compactly supported function `a ↦ f (b + φ a)` on `A`. | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.alter_eq_empty_iff_erase_eq_empty._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u_1} {o : Option α}, (o = none) = (o.isNone = true) | null | false |
Lean.PrettyPrinter.Unexpander | Init.Prelude | Type | Function that tries to reverse macro expansions as a post-processing step of delaboration.
While less general than an arbitrary delaborator, it can be declared without importing `Lean`.
Used by the `[app_unexpander]` attribute.
| true |
lt_mul_iff_one_lt_right' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {b : α} [inst : MulOneClass α] [inst_1 : LT α] [MulLeftStrictMono α] [MulLeftReflectLT α] (a : α),
a < a * b ↔ 1 < b | null | true |
Std.Net.instDecidableEqSocketAddressV6.decEq._proof_4 | Std.Net.Addr | ∀ (a : Std.Net.IPv6Addr) (a_1 : UInt16) (b : Std.Net.IPv6Addr) (b_1 : UInt16),
¬a = b → ¬{ addr := a, port := a_1 } = { addr := b, port := b_1 } | null | false |
Std.TreeSet.Raw.mk.injEq | Std.Data.TreeSet.Raw.Basic | ∀ {α : Type u} {cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw._auto_1}
(inner inner_1 : Std.TreeMap.Raw α Unit cmp), ({ inner := inner } = { inner := inner_1 }) = (inner = inner_1) | null | true |
groupCohomology.cocyclesMap._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k H : Type u_1} [inst : CommRing k] [inst_1 : Group H] {A : Rep.{u_1, u_1, u_1} k H} (n : ℕ),
(HomologicalComplex.sc (groupCohomology.inhomogeneousCochains A) n).HasHomology | null | false |
SimpleGraph.Preconnected | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | {V : Type u} → SimpleGraph V → Prop | A graph is preconnected if every pair of vertices is reachable from one another. | true |
EReal.instPosMulReflectLT | Mathlib.Data.EReal.Inv | PosMulReflectLT EReal | null | true |
RatFunc.mk.congr_simp | Mathlib.FieldTheory.RatFunc.Defs | ∀ {K : Type u_1} [inst : CommRing K] [inst_1 : IsDomain K] (p p_1 : Polynomial K),
p = p_1 → ∀ (q q_1 : Polynomial K), q = q_1 → RatFunc.mk p q = RatFunc.mk p_1 q_1 | null | true |
DifferentiableOn.fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{s : Set E}, DifferentiableOn 𝕜 f s → DifferentiableOn 𝕜 g s → DifferentiableOn 𝕜 (fun i => f i... | Eta-expanded form of `DifferentiableOn.sub` | true |
_private.Std.Tactic.BVDecide.Normalize.BitVec.0.Std.Tactic.BVDecide.Normalize.BitVec.signExtend_elim._proof_1 | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {v w : ℕ}, v ≤ w → ¬w - v + v = w → False | null | false |
AffineEquiv.toAffineMap | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_6} →
{V₂ : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
... | Reinterpret an `AffineEquiv` as an `AffineMap`. | true |
HopfAlgCat.MonoidalCategory.inducingFunctorData._proof_3 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] {X₁ Y₁ X₂ Y₂ : HopfAlgCat R} (x : X₁ ⟶ Y₁) (x_1 : X₂ ⟶ Y₂),
(CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R)).map (CategoryTheory.MonoidalCategoryStruct.tensorHom x x_1) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCa... | null | false |
HomologicalComplex.Hom.mk.noConfusion | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
{inst : CategoryTheory.Category.{v, u} V} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms V} →
{c : ComplexShape ι} →
{A B : HomologicalComplex V c} →
{P : Sort u_2} →
{f : (i : ι) → A.X i ⟶ B.X i} →
{comm' :
... | null | false |
Std.ExtDTreeMap.Const.getThenInsertIfNew?_fst | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {v : β}, (Std.ExtDTreeMap.Const.getThenInsertIfNew? t k v).1 = Std.ExtDTreeMap.Const.get? t k | null | true |
CategoryTheory.CoreSmallCategoryOfSet.functor._proof_1 | Mathlib.CategoryTheory.SmallRepresentatives | ∀ {Ω : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(h : CategoryTheory.CoreSmallCategoryOfSet Ω C) (x : ↑h.smallCategoryOfSet.obj),
h.homEquiv (CategoryTheory.CategoryStruct.id x) = CategoryTheory.CategoryStruct.id (h.objEquiv x) | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.δ_comp_σ_self._simp_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} {a b : Fin n}, (a < b) = (↑a < ↑b) | null | false |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.destruct.match_1.eq_1 | Mathlib.Data.WSeq.Basic | ∀ {α : Type u_1} (motive : Option (Stream'.Seq1 (Option α)) → Sort u_2) (h_1 : Unit → motive none)
(h_2 : (s' : Stream'.Seq (Option α)) → motive (some (none, s')))
(h_3 : (a : α) → (s' : Stream'.Seq (Option α)) → motive (some (some a, s'))),
(match none with
| none => h_1 ()
| some (none, s') => h_2 s'
... | null | true |
MulDistribMulAction | Mathlib.Algebra.Group.Action.Defs | (M : Type u_9) → (N : Type u_10) → [Monoid M] → [Monoid N] → Type (max u_10 u_9) | Typeclass for multiplicative actions on multiplicative structures.
The key axiom here is `smul_mul : g • (x * y) = (g • x) * (g • y)`.
If `G` is a multiplicative group with automorphism group `Γ`, then there is a natural instance of
`MulDistribMulAction Γ G`.
The axiom is also satisfied by a Galois group $Gal(L/K)$ a... | true |
cfcₙL.congr_simp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Integral | ∀ {R : Type u_1} {A : Type u_2} {p p_1 : A → Prop} (e_p : p = p_1) [inst : CommSemiring R] [inst_1 : Nontrivial R]
[inst_2 : StarRing R] [inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R]
[inst_6 : NonUnitalRing A] [inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Mo... | null | true |
_private.Mathlib.Algebra.Lie.Ideal.0.LieHom.isIdealMorphism_iff._simp_1_6 | Mathlib.Algebra.Lie.Ideal | ∀ {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] (p : Submodule R M), (∃ N, ↑N = p) = ∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p | null | false |
CategoryTheory.InducedWideCategory.Hom._sizeOf_inst | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₂} D} →
{F : C → D} →
{P : CategoryTheory.MorphismProperty D} →
{inst_1 : P.IsMultiplicative} →
(X Y : CategoryTheory.InducedWideCategory D F P) →
[SizeOf C] → [SizeOf D] → [⦃X Y : D⦄ → (x : X ⟶... | null | false |
Lean.Compiler.LCNF.Simp.CtorInfo | Lean.Compiler.LCNF.Simp.DiscrM | Type | null | true |
Lean.Elab.Term.exceptionToSorry | Lean.Elab.Term.TermElabM | Lean.Exception → Option Lean.Expr → Lean.Elab.TermElabM Lean.Expr | Log the given exception, and create a synthetic sorry for representing the failed
elaboration step with exception `ex`.
| true |
Complex.UnitClosedDisc.instSMulCommClassCircle | Mathlib.Analysis.Complex.UnitDisc.Basic | SMulCommClass Circle Complex.UnitClosedDisc Complex.UnitClosedDisc | null | true |
FirstOrder.Language.Term.func | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → {l : ℕ} → L.Functions l → (Fin l → L.Term α) → L.Term α | null | true |
Std.DHashMap.Internal.Raw₀.get_insertMany_list_of_contains_eq_false | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α] (h : (↑m).WF) {l : List ((a : α) × β a)} {k : α}
(contains : (List.map Sigma.fst l).contains k = false) {h' : (↑(m.insertMany l)).contains k = true},
(↑(m.insertMany l)).get k h' = m.ge... | null | true |
LinearMap.iterateMapComap_le_succ | Mathlib.Algebra.Module.Submodule.IterateMapComap | ∀ {R : Type u_1} {N : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] (f i : N →ₗ[R] M) (K : Submodule R N),
Submodule.map f K ≤ Submodule.map i K → ∀ (n : ℕ), f.iterateMapComap i n K ≤ f.iterateMapComap i (n + 1) K | If `f(K) ≤ i(K)`, then `LinearMap.iterateMapComap` is not decreasing. | true |
Lean.Lsp.instToJsonLeanModule | Lean.Data.Lsp.Extra | Lean.ToJson Lean.Lsp.LeanModule | null | true |
HomologicalComplex.Acyclic | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{ι : Type u_2} → {c : ComplexShape ι} → HomologicalComplex C c → Prop | A homological complex `K` is acyclic if it is exact at `i` for any `i`. | true |
iInf₂_eq_top | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_6} [inst : CompleteLattice α] {f : (i : ι) → κ i → α},
⨅ i, ⨅ j, f i j = ⊤ ↔ ∀ (i : ι) (j : κ i), f i j = ⊤ | null | true |
HasFPowerSeriesAt.tendsto_partialSum_prod_of_comp | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → G} {q : FormalMultilinearSer... | null | true |
_private.Mathlib.Analysis.Calculus.IteratedDeriv.Defs.0.contDiff_nat_succ_iff_contDiff_one_iteratedDeriv._simp_1_2 | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F}, ContDiff 𝕜 1 f = (Differentiable 𝕜 f ∧ Continuous (deriv f)) | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.id_actionHomLeft_assoc | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {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} {inst_2 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (c : C) (d : D) {Z : D}
(h : CategoryTheory.MonoidalCategory.MonoidalRightActi... | null | true |
Lean.Parser.termParser.parenthesizer | Lean.Parser.Extra | optParam ℕ 0 → Lean.PrettyPrinter.Parenthesizer | null | true |
IsCompact.cofinite_inf_le_codiscreteWithin | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {K : Set X},
IsCompact K → Filter.cofinite ⊓ Filter.principal K ≤ Filter.codiscreteWithin K | null | true |
_private.Mathlib.Data.Finset.Union.0.Finset.coe_disjiUnion._simp_1_1 | Mathlib.Data.Finset.Union | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
_private.Batteries.Tactic.SqueezeScope.0.Batteries.Tactic._aux_Batteries_Tactic_SqueezeScope___elabRules__private_Batteries_Tactic_SqueezeScope_0_Batteries_Tactic_squeezeScopeIn_1._sparseCasesOn_5 | Batteries.Tactic.SqueezeScope | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Lean.Meta.trySubstVar | Lean.Meta.Tactic.Subst | Lean.MVarId → Lean.FVarId → Lean.MetaM Lean.MVarId | null | true |
hasFDerivAt_ringInverse | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {R : Type u_4} [inst_1 : NormedRing R] [HasSummableGeomSeries R]
[inst_3 : NormedAlgebra 𝕜 R] (x : Rˣ),
HasFDerivAt Ring.inverse (-((ContinuousLinearMap.mulLeftRight 𝕜 R) ↑x⁻¹) ↑x⁻¹) ↑x | At an invertible element `x` of a normed algebra `R`, the Fréchet derivative of the inversion
operation is the linear map `fun t ↦ - x⁻¹ * t * x⁻¹`.
TODO (low prio): prove a version without assumption `[HasSummableGeomSeries R]` but within the set
of units. | true |
instT1SpaceCofiniteTopology | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1}, T1Space (CofiniteTopology X) | null | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.mul_dvd_mul_eq._simp_1 | Init.Data.Int.Linear | ∀ {a b c : ℤ}, a ≠ 0 → (a * b ∣ a * c) = (b ∣ c) | null | false |
Lean.Server.RpcProcedure.noConfusionType | Lean.Server.Rpc.RequestHandling | Sort u → Lean.Server.RpcProcedure → Lean.Server.RpcProcedure → Sort u | null | false |
PiTensorProduct.toDualContinuousMultilinearMap._proof_6 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] (F : Type u_2) [inst_1 : SeminormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], SMulCommClass 𝕜 𝕜 F | null | false |
CategoryTheory.Functor.LaxMonoidal.mk.congr_simp | Mathlib.CategoryTheory.Monoidal.Braided.Transport | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D}
(ε ε_1 :
CategoryTheory.MonoidalCategoryStruct.tensorUnit D ⟶ F.obj... | null | true |
CategoryTheory.ProjectiveResolution.extMk._proof_1 | Mathlib.CategoryTheory.Abelian.Projective.Ext | ∀ {n : ℕ}, -↑n + ↑n = 0 | null | false |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.structInstLVal._regBuiltin.Lean.Parser.Term.structInstLVal.parenthesizer_7 | Lean.Parser.Term.Basic | IO Unit | null | false |
AlgebraicGeometry.Scheme.IsLocallyDirected.ι_eq_ι_iff | Mathlib.AlgebraicGeometry.Gluing | ∀ {J : Type w} [inst : CategoryTheory.Category.{v, w} J] (F : CategoryTheory.Functor J AlgebraicGeometry.Scheme)
[inst_1 : ∀ {i j : J} (f : i ⟶ j), AlgebraicGeometry.IsOpenImmersion (F.map f)]
[inst_2 : (F.comp AlgebraicGeometry.Scheme.forget).IsLocallyDirected] [inst_3 : Quiver.IsThin J]
[inst_4 : Small.{u, w} J... | null | true |
AddHomClass.map_add | Mathlib.Algebra.Group.Hom.Defs | ∀ {F : Type u_10} {M : outParam (Type u_11)} {N : outParam (Type u_12)} {inst : Add M} {inst_1 : Add N}
{inst_2 : FunLike F M N} [self : AddHomClass F M N] (f : F) (x y : M), f (x + y) = f x + f y | The proposition that the function preserves addition | true |
_private.Mathlib.Tactic.Widget.Conv.0.Mathlib.Tactic.Conv.Path.ofSubExprPosArray.appT._sparseCasesOn_1 | Mathlib.Tactic.Widget.Conv | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Pseudofunctor.Grothendieck.recOn | Mathlib.CategoryTheory.Bicategory.Grothendieck | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} →
{motive : F.Grothendieck → Sort u} →
(t : F.Grothendieck) →
((base : 𝒮) → (fiber : ↑(F.obj { as := base })) → motive { base := base, ... | null | false |
LinearMap.sq_singularValues_fin | Mathlib.Analysis.InnerProductSpace.SingularValues | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : InnerProductSpace 𝕜 F]
[inst_6 : FiniteDimensional 𝕜 F] (T : E →ₗ[𝕜] F) {n : ℕ} (hn : Module.finrank 𝕜 ... | null | true |
SimpleGraph.egirth_eq_top._simp_1 | Mathlib.Combinatorics.SimpleGraph.Girth | ∀ {α : Type u_1} {G : SimpleGraph α}, (G.egirth = ⊤) = G.IsAcyclic | null | false |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory._proof_3 | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) (J : Type u_1) [inst_1 : CategoryTheory.Category.{u_4, u_1} J]
(x : CategoryTheory.Arrow (CategoryTheory.Functor J C)) (x_1 : J),
W₂ (data.p.app (CategoryTheory.Arr... | null | false |
Int.toNat_add_nat | Init.Data.Int.Order | ∀ {a : ℤ}, 0 ≤ a → ∀ (n : ℕ), (a + ↑n).toNat = a.toNat + n | null | true |
BoundedContinuousFunction.mkOfCompact._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] [CompactSpace α]
(f : C(α, β)), ∃ C, ∀ (x y : α), dist (f.toFun x) (f.toFun y) ≤ C | null | false |
ClosedSubgroup.ext_iff | Mathlib.Topology.Algebra.Group.ClosedSubgroup | ∀ {G : Type u} {inst : Group G} {inst_1 : TopologicalSpace G} {x y : ClosedSubgroup G},
x = y ↔ (↑x).carrier = (↑y).carrier | null | true |
Complex.addGroupWithOne._proof_7 | Mathlib.Basic.Complex.Basic | ∀ (n : ℕ) (a : ℂ), ↑n.succ • a = ↑n • a + a | null | false |
Finsupp.comapDomain_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α → β) (l : β →₀ M)
(hf : Set.InjOn f (f ⁻¹' ↑l.support)) (a : α), (Finsupp.comapDomain f l hf) a = l (f a) | null | true |
Lean.Server.ReferencedObject.noConfusion | Lean.Server.Rpc.Basic | {P : Sort u} → {t t' : Lean.Server.ReferencedObject} → t = t' → Lean.Server.ReferencedObject.noConfusionType P t t' | null | false |
AList.lookupFinsupp_apply | Mathlib.Data.Finsupp.AList | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : DecidableEq α] (l : AList fun _x => M) (a : α),
l.lookupFinsupp a = (AList.lookup a l).getD 0 | null | true |
Lean.Elab.ConfigEval.EvalExpr.instString | Lean.Elab.ConfigEval.Instances | Lean.Elab.ConfigEval.EvalExpr String | null | true |
Prod.instCompleteAtomicBooleanAlgebra._proof_11 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteAtomicBooleanAlgebra α] [inst_1 : CompleteAtomicBooleanAlgebra β]
(x y : α × β), x \ y = x ⊓ yᶜ | null | false |
Mathlib.Tactic.BicategoryLike.MkEvalComp.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {P : Sort u} →
{m : Type → Type} →
{t : Mathlib.Tactic.BicategoryLike.MkEvalComp m} →
{m' : Type → Type} →
{t' : Mathlib.Tactic.BicategoryLike.MkEvalComp m'} →
m = m' → t ≍ t' → Mathlib.Tactic.BicategoryLike.MkEvalComp.noConfusionType P t t' | null | false |
_private.Mathlib.RingTheory.DedekindDomain.Different.0.FractionalIdeal._aux_Mathlib_RingTheory_DedekindDomain_Different___unexpand_Submodule_traceDual_1 | Mathlib.RingTheory.DedekindDomain.Different | Lean.PrettyPrinter.Unexpander | null | false |
_private.Std.Async.System.0.Std.Async.System.instDecidableEqCPUTimes.decEq._proof_6 | Std.Async.System | ∀ (a a_1 a_2 a_3 a_4 b b_1 b_2 b_3 b_4 : Std.Time.Millisecond.Offset),
¬a = b →
{ userTime := a, niceTime := a_1, systemTime := a_2, idleTime := a_3, interruptTime := a_4 } =
{ userTime := b, niceTime := b_1, systemTime := b_2, idleTime := b_3, interruptTime := b_4 } →
False | null | false |
SSet.coherentIso.hom._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.CoherentIso | (CategoryTheory.ConcreteCategory.hom
(((SSet.truncation 2).obj SSet.coherentIso).map
(SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op))
(CategoryTheory.ComposableArrows.mk₁ CategoryTheory.WalkingIso.iso.hom) =
SSet.coherentIso.x₀ | null | false |
_private.Mathlib.Data.Multiset.Fintype.0.Multiset.map_fst_le_of_subset_toEnumFinset._simp_1_1 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, (s ≤ t) = ∀ (a : α), Multiset.count a s ≤ Multiset.count a t | null | false |
Subsemigroup.instInfSet.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M],
Subsemigroup.instInfSet = { sInf := fun s => { carrier := ⋂ t ∈ s, ↑t, mul_mem' := ⋯ } } | null | true |
Set.ofPred_eq_eq_singleton' | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {a : α}, {x | a = x} = {a} | null | true |
Std.TreeMap.Raw.WF.filter | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
{f : α → β → Bool}, t.WF → (Std.TreeMap.Raw.filter f t).WF | null | true |
Associates.dvd_of_mem_factors' | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α} {p : Associates α}
{hp : Irreducible p} {hz : a ≠ 0}, ⟨p, hp⟩ ∈ Associates.factors' a → p ∣ Associates.mk a | null | true |
CategoryTheory.Limits.PullbackCone.eta._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
(t : CategoryTheory.Limits.PullbackCone f g),
t.fst =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl t.pt).hom
(CategoryTheory.Limits.PullbackCone.mk t.fst t.snd ⋯).fst | null | false |
AlgebraicGeometry.UniversallyOpen.instRespectsIsoScheme | Mathlib.AlgebraicGeometry.Morphisms.UniversallyOpen | CategoryTheory.MorphismProperty.RespectsIso @AlgebraicGeometry.UniversallyOpen | null | true |
CategoryTheory.Functor.asEquivalence | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → (F : CategoryTheory.Functor C D) → [F.IsEquivalence] → C ≌ D | Interpret a functor that is an equivalence as an equivalence. | true |
FreeAlgebra.Pre.instInhabited | Mathlib.Algebra.FreeAlgebra | (R : Type u_1) → (X : Type u_2) → [CommSemiring R] → Inhabited (FreeAlgebra.Pre R X) | null | true |
NonUnitalStarSubalgebra.val_inclusion | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : StarRing A]
[inst_3 : Module R A] {S T : NonUnitalStarSubalgebra R A} (h : S ≤ T) (s : ↥S),
↑((NonUnitalStarSubalgebra.inclusion h) s) = ↑s | null | true |
CategoryTheory.ProjectiveResolution.liftFOne | Mathlib.CategoryTheory.Abelian.Projective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{Y Z : C} →
(Y ⟶ Z) →
(P : CategoryTheory.ProjectiveResolution Y) →
(Q : CategoryTheory.ProjectiveResolution Z) → P.complex.X 1 ⟶ Q.complex.X 1 | Auxiliary construction for `lift`. | true |
norm_algebraMap_nnreal | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜' : Type u_2) [inst : SeminormedRing 𝕜'] [NormOneClass 𝕜'] [inst_2 : NormedAlgebra ℝ 𝕜'] (x : NNReal),
‖(algebraMap NNReal 𝕜') x‖ = ↑x | null | true |
_private.Mathlib.Tactic.SetNotationForOrder.0.Mathlib.Meta.SetNotationForOrder.useSetNotationFor | Mathlib.Tactic.SetNotationForOrder | Lean.Expr → Lean.MetaM Bool | Whether to use set notation for the given type or not. | true |
ContinuousAffineEquiv.constVAdd._proof_2 | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ (P₁ : Type u_1) {V₁ : Type u_2} [inst : AddCommGroup V₁] [inst_1 : AddTorsor V₁ P₁] [inst_2 : TopologicalSpace P₁]
[ContinuousConstVAdd V₁ P₁] (v : V₁), Continuous fun x => -v +ᵥ x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.