name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TopModuleCat.coker._proof_2 | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {M N : TopModuleCat R} (φ : M ⟶ N),
ContinuousAdd (↑N.toModuleCat ⧸ (↑(TopModuleCat.Hom.hom φ)).range) | null | false |
CategoryTheory.GradedObject.cofanMapObjComp._proof_2 | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_3} {J : Type u_1} {K : Type u_2} (p : I → J) (q : J → K) (r : I → K),
(∀ (i : I), q (p i) = r i) → ∀ (k : K) (i : I), r i = k → p i ∈ q ⁻¹' {k} | null | false |
Lean.Elab.Term.PatternElabException.mk | Lean.Elab.Match | Lean.Exception → ℕ → List ℕ → Lean.Elab.Term.PatternElabException | null | true |
_private.Mathlib.ModelTheory.Equivalence.0.FirstOrder.Language.Theory.bot_imp._simp_1_2 | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M},
⊥.Realize v xs = False | null | false |
HomologicalComplex.mapBifunctor₁₂.D₁.eq_1 | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
Ideal.Quotient.algEquivOfEqMap | Mathlib.RingTheory.Ideal.Over | {A : Type u_3} →
{B : Type u_4} →
{C : Type u_5} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : CommRing C] →
[inst_3 : Algebra A B] →
[inst_4 : Algebra A C] →
{P : Ideal B} →
{Q : Ideal C} →
(p : Id... | An `A ⧸ p`-algebra isomorphism between `B ⧸ P` and `C ⧸ Q` induced by an `A`-algebra
isomorphism between `B` and `C`, where `Q = σ P`. | true |
Lean.Doc.MarkdownM.State._sizeOf_1 | Lean.DocString.Markdown | Lean.Doc.MarkdownM.State → ℕ | null | false |
essInf_eq_iInf | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : CompleteLattice β],
(∀ (a : α), μ {a} ≠ 0) → ∀ (f : α → β), essInf f μ = ⨅ i, f i | null | true |
Lean.Elab.Term.CoeExpansionTrace.rec | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.CoeExpansionTrace → Sort u} →
((expandedCoeDecls : List Lean.Name) → motive { expandedCoeDecls := expandedCoeDecls }) →
(t : Lean.Elab.Term.CoeExpansionTrace) → motive t | null | false |
csInf_le_csSup_of_nonempty_inter._auto_3 | Mathlib.Order.ConditionallyCompleteLattice.Basic | Lean.Syntax | null | false |
CategoryTheory.FreeBicategory.liftHom.eq_3 | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u₁} [inst : Quiver B] {C : Type u₂} [inst_1 : CategoryTheory.CategoryStruct.{v₂, u₂} C] (F : B ⥤q C)
(x x_1 : CategoryTheory.FreeBicategory B) (b : B) (f : CategoryTheory.FreeBicategory.Hom x b)
(g : CategoryTheory.FreeBicategory.Hom b x_1),
CategoryTheory.FreeBicategory.liftHom F (f.comp g) =
Cat... | null | true |
Sublattice.coe_eq_univ | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L : Sublattice α}, ↑L = Set.univ ↔ L = ⊤ | null | true |
Lean.Lsp.SemanticTokensLegend.ctorIdx | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SemanticTokensLegend → ℕ | null | false |
Units.rec | Mathlib.Algebra.Group.Units.Defs | {α : Type u} →
[inst : Monoid α] →
{motive : αˣ → Sort u_1} →
((val inv : α) →
(val_inv : val * inv = 1) →
(inv_val : inv * val = 1) → motive { val := val, inv := inv, val_inv := val_inv, inv_val := inv_val }) →
(t : αˣ) → motive t | null | false |
List.isEqv_cons_cons | Init.Data.List.Basic | ∀ {α : Type u_1} {a : α} {as : List α} {b : α} {bs : List α} {eqv : α → α → Bool},
(a :: as).isEqv (b :: bs) eqv = (eqv a b && as.isEqv bs eqv) | null | true |
CategoryTheory.NatTrans.rightDerivedFunctorPlusAddMonoidHom_apply | Mathlib.Algebra.Homology.DerivedCategory.RightDerivedFunctorPlus | ∀ {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.Abelian C]
[inst_3 : CategoryTheory.Abelian D] [inst_4 : HasDerivedCategory C] [inst_5 : HasDerivedCategory D]
[inst_6 : CategoryTheory.EnoughInjectives C] {F₁ F₂ ... | null | true |
Algebra.IsStandardSmoothOfRelativeDimension.mvPolynomial_fin | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {R : Type u} [inst : CommRing R] {n : ℕ}, Algebra.IsStandardSmoothOfRelativeDimension n R (MvPolynomial (Fin n) R) | The polynomial algebra `MvPolynomial (Fin n) R` is standard smooth over `R` of relative
dimension `n`. | true |
NumberField.mixedEmbedding.euclidean.integerLattice.congr_simp | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.mixedEmbedding.euclidean.integerLattice K = NumberField.mixedEmbedding.euclidean.integerLattice K | null | true |
Lean.Elab.SyntaxDeprecationEntry.mk.noConfusion | Lean.Elab.DeprecatedSyntax | {P : Sort u} →
{kind : Lean.SyntaxNodeKind} →
{text? since? : Option String} →
{kind' : Lean.SyntaxNodeKind} →
{text?' since?' : Option String} →
{ kind := kind, text? := text?, since? := since? } = { kind := kind', text? := text?', since? := since?' } →
(kind = kind' → text? =... | null | false |
Submonoid.instIsMulFGSubtypeMemMapMonoidHom | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} {M' : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass M'] {P : Submonoid M} (f : M →* M')
[IsMulFG ↥P], IsMulFG ↥(Submonoid.map f P) | null | true |
Filter.Germ.instInvOneClass.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {G : Type u_6} [inst : InvOneClass G],
Filter.Germ.instInvOneClass = { toOne := Filter.Germ.instOne, toInv := Filter.Germ.instInv, inv_one := ⋯ } | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{w : ℕ} →
{aig : Std.Sat.AIG α} → aig.RefVec w → ℕ → (curr : ℕ) ×' (_ : curr ≤ w) ×' aig.RefVec curr → aig.RefVec w | null | false |
ModularGroup.exists_row_one_eq_and_min_re | Mathlib.NumberTheory.Modular | ∀ (z : UpperHalfPlane) {cd : Fin 2 → ℤ},
IsCoprime (cd 0) (cd 1) →
∃ g, ↑g 1 = cd ∧ ∀ (g' : Matrix.SpecialLinearGroup (Fin 2) ℤ), ↑g 1 = ↑g' 1 → |(g • z).re| ≤ |(g' • z).re| | Given `z : ℍ` and a bottom row `(c,d)`, among the `g : SL(2,ℤ)` with this bottom row, minimize
`|(g•z).re|`. | true |
IsClosed.powerset_hausdorff | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] {F : Set α}, IsClosed F → IsClosed (𝒫 F) | In the Hausdorff uniformity, the powerset of a closed set is closed. | true |
RingEquiv.ext_iff | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] {f g : R ≃+* S},
f = g ↔ ∀ (x : R), f x = g x | null | true |
ContinuousLinearMap.mk_id | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_4} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁], { toLinearMap := LinearMap.id, cont := ⋯ } = ContinuousLinearMap.id R₁ M₁ | null | true |
Nonneg.coeRingHom._proof_2 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : PosMulMono α] (a b : Nonneg α),
↑(a * b) = ↑a * ↑b | null | false |
Finsupp.single_finset_sum | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {ι : Type u_2} {M : Type u_8} [inst : AddCommMonoid M] (s : Finset ι) (f : ι → M) (a : α),
(fun₀ | a => ∑ b ∈ s, f b) = ∑ b ∈ s, fun₀ | a => f b | **Alias** of `Finsupp.single_finsetSum`. | true |
Lean.Doc.instFromDocArgOption | Lean.Elab.DocString | {α : Type} → [Lean.Doc.FromDocArg α] → Lean.Doc.FromDocArg (Option α) | null | true |
FunLike.divisionCommMonoid._proof_5 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : Pow F ℕ] [inst_2 : DivisionCommMonoid β]
[IsPowApply ℕ F α β] (f : F) (n : ℕ), ⇑(f ^ n) = ⇑f ^ n | null | false |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleFoldingRange.addRange | Lean.Server.FileWorker.RequestHandling | Lean.FileMap →
Lean.Lsp.FoldingRangeKind →
Option String.Pos.Raw → Option String.Pos.Raw → StateT (Array Lean.Lsp.FoldingRange) Lean.Server.RequestM Unit | null | true |
Sum.traverse_map | Mathlib.Control.Traversable.Instances | ∀ {σ : Type u} {G : Type u → Type u} [inst : Applicative G] {α β γ : Type u} (g : α → β) (f : β → G γ) (x : σ ⊕ α),
Sum.traverse f (g <$> x) = Sum.traverse (f ∘ g) x | null | true |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.UniqueProds.of_mulOpposite.match_1_1 | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} [inst : Mul G] {A B : Finset G} (f : G ↪ Gᵐᵒᵖ)
(motive : (∃ a0 ∈ Finset.map f B, ∃ b0 ∈ Finset.map f A, UniqueMul (Finset.map f B) (Finset.map f A) a0 b0) → Prop)
(x : ∃ a0 ∈ Finset.map f B, ∃ b0 ∈ Finset.map f A, UniqueMul (Finset.map f B) (Finset.map f A) a0 b0),
(∀ (y : Gᵐᵒᵖ) (yB : y ∈ Finset.... | null | false |
CategoryTheory.Limits.chosenEndFunctor._proof_4 | Mathlib.CategoryTheory.Limits.Chosen.End | ∀ {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} J] [inst_2 : CategoryTheory.Limits.ChosenEndsOfShape J C]
{X Y Z : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Limits.chosenEnd.map (Categ... | null | false |
_private.Init.Data.Int.Gcd.0.Int.lcm_eq_one_iff.match_1_1 | Init.Data.Int.Gcd | ∀ {m n : ℤ} (motive : m ∣ 1 ∧ n ∣ 1 → Prop) (x : m ∣ 1 ∧ n ∣ 1), (∀ (ha : m ∣ 1) (hb : n ∣ 1), motive ⋯) → motive x | null | false |
RingTheory.Sequence.IsRegular.mk._flat_ctor | Mathlib.RingTheory.Regular.RegularSequence | ∀ {R : Type u_1} {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {rs : List R},
(∀ (i : ℕ) (h : i < rs.length), IsSMulRegular (M ⧸ Ideal.ofList (List.take i rs) • ⊤) rs[i]) →
⊤ ≠ Ideal.ofList rs • ⊤ → RingTheory.Sequence.IsRegular M rs | null | false |
Std.Tactic.BVDecide.Normalize.BitVec.shiftLeft_zero' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w w' : ℕ} (n : BitVec w), n <<< 0#w' = n | null | true |
CategoryTheory.CardinalFilteredPoset.exists_mem_propSetWithTop | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | ∀ {κ : Cardinal.{u}} [inst : Fact κ.IsRegular] (J : CategoryTheory.CardinalDirectedPoset κ) (κ' : Cardinal.{u})
[inst_1 : Fact κ'.IsRegular] (a : ↑J.withTop.obj), ∃ S, J.PropSetWithTop κ' S ∧ a ∈ S | **Alias** of `CategoryTheory.CardinalDirectedPoset.exists_mem_propSetWithTop`. | true |
_private.Lean.ScopedEnvExtension.0.Lean.initFn._@.Lean.ScopedEnvExtension.3284267871._hygCtx._hyg.2 | Lean.ScopedEnvExtension | IO (IO.Ref (Array (Lean.ScopedEnvExtension Lean.EnvExtensionEntry Lean.EnvExtensionEntry Lean.EnvExtensionState))) | null | false |
Std.ExtHashSet.get!_diff_of_not_mem_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
[inst_2 : Inhabited α] {k : α}, k ∉ m₁ → (m₁ \ m₂).get! k = default | null | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.match_3.eq_1 | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3)
(h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(sz : ℕ) →
(k : α) →
(v : β k) → (l r : Std.DTreeMap.Internal.Impl α β) → motive (Std.DTreeMap.Internal.Impl.inner sz k v l r)),
(match Std.DTreeM... | null | true |
CategoryTheory.StructuredArrow.hasFiniteLimits | Mathlib.CategoryTheory.Limits.Comma | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {T : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} T]
{X : T} {G : CategoryTheory.Functor A T} [CategoryTheory.Limits.HasFiniteLimits A]
[CategoryTheory.Limits.PreservesFiniteLimits G],
CategoryTheory.Limits.HasFiniteLimits (CategoryTheory.Structur... | null | true |
HomotopyCategory.quasiIso | Mathlib.Algebra.Homology.Localization | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{ι : Type u_2} →
(c : ComplexShape ι) →
[inst_1 : CategoryTheory.Preadditive C] →
[CategoryTheory.CategoryWithHomology C] → CategoryTheory.MorphismProperty (HomotopyCategory C c) | The class of quasi-isomorphisms in the homotopy category. | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.role.bracketed._unsafe_rec | Lean.DocString.Parser | Lean.Doc.Parser.InlineCtxt → Lean.Parser.ParserFn | null | false |
Lean.Parser.Term.structInstFieldDef | Lean.Parser.Term | Lean.Parser.Parser | null | true |
Matrix.isSimplyLaced_iff_of_linearOrder | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | ∀ {ι : Type u_1} [inst : LinearOrder ι] (A : Matrix ι ι ℤ),
A.IsSymm → (A.IsSimplyLaced ↔ ∀ ⦃i j : ι⦄, j < i → A i j = 0 ∨ A i j = -1) | null | true |
CategoryTheory.GrothendieckTopology.uliftYonedaIsoYoneda | Mathlib.CategoryTheory.Sites.Canonical | {C : Type u} →
[inst : CategoryTheory.Category.{max w v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
[inst_1 : J.Subcanonical] → CategoryTheory.GrothendieckTopology.uliftYoneda.{w, max v w, u} J ≅ J.yoneda | If `C` is a category with `[Category.{max w v} C]`, this is the isomorphism
`uliftYoneda.{w} (C := C) ≅ yoneda`. | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.State.cache | Lean.Compiler.LCNF.ToLCNF | Lean.Compiler.LCNF.ToLCNF.State✝ →
Lean.PHashMap Lean.Compiler.LCNF.ToLCNF.CacheKey✝ (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) | Cache from Lean regular expression to LCNF argument. | true |
isDenseInducing_stoneCechUnit | Mathlib.Topology.Separation.CompletelyRegular | ∀ {X : Type u} [inst : TopologicalSpace X] [CompletelyRegularSpace X], IsDenseInducing stoneCechUnit | null | true |
String.Pos.sliceTo_cast._proof_2 | Init.Data.String.Lemmas.Splits | ∀ {s t : String} {hst : s = t} (p : s.Pos), (s.sliceTo p).copy = (t.sliceTo (p.cast hst)).copy | null | false |
DFinsupp.comapDomain' | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{β : ι → Type v} →
{κ : Type u_1} →
[inst : (i : ι) → Zero (β i)] →
(h : κ → ι) → {h' : ι → κ} → Function.LeftInverse h' h → (Π₀ (i : ι), β i) → Π₀ (k : κ), β (h k) | A computable version of `comapDomain` when an explicit left inverse is provided. | true |
Std.DTreeMap.Internal.Impl.filter!_equiv_self_iff | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] {f : (a : α) → β a → Bool},
t.WF →
((Std.DTreeMap.Internal.Impl.filter! f t).Equiv t ↔
∀ (a : α) (h : Std.DTreeMap.Internal.Impl.contains a t = true), f a (t.get a h) = true) | null | true |
MeasureTheory.SimpleFunc.lintegralₗ._proof_6 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {m : MeasurableSpace α} (f g : MeasureTheory.SimpleFunc α ENNReal) (c : ENNReal)
(μ : MeasureTheory.Measure α), (f + g).lintegral (c • μ) = (RingHom.id ENNReal) c • (f + g).lintegral μ | null | false |
Batteries.CodeAction.instanceStub | Batteries.CodeAction.Misc | Lean.CodeAction.HoleCodeAction | Hole code action used to fill in a structure's field when specifying an instance.
In the following:
```lean
instance : Monad Id := _
```
invoking the hole code action "Generate a (minimal) skeleton for the structure under construction."
produces:
```lean
instance : Monad Id where
pure := _
bind := _
```
and invo... | true |
Turing.ToPartrec.Cont.then.eq_def | Mathlib.Computability.TuringMachine.Config | ∀ (x : Turing.ToPartrec.Cont),
x.then =
match (motive := Turing.ToPartrec.Cont → Turing.ToPartrec.Cont → Turing.ToPartrec.Cont) x with
| Turing.ToPartrec.Cont.halt => fun k' => k'
| Turing.ToPartrec.Cont.cons₁ fs as k => fun k' => Turing.ToPartrec.Cont.cons₁ fs as (k.then k')
| Turing.ToPartrec.Cont.c... | null | true |
Set.mem_sdiff_singleton_empty | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s : Set α} {t : Set (Set α)}, s ∈ t \ {∅} ↔ s ∈ t ∧ s.Nonempty | null | true |
Lean.Elab.Command.Scope.casesOn | Lean.Elab.Command.Scope | {motive : Lean.Elab.Command.Scope → Sort u} →
(t : Lean.Elab.Command.Scope) →
((header : String) →
(opts : Lean.Options) →
(currNamespace : Lean.Name) →
(openDecls : List Lean.OpenDecl) →
(levelNames : List Lean.Name) →
(varDecls : Array (Lean.TSyntax `L... | null | false |
ENNReal.continuous_zpow | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ (n : ℤ), Continuous fun x => x ^ n | null | true |
LieModule.range_traceForm_le_span_weight | Mathlib.Algebra.Lie.TraceForm | ∀ (K : Type u_2) (L : Type u_3) (M : Type u_4) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M]
[inst_3 : Field K] [inst_4 : LieAlgebra K L] [inst_5 : Module K M] [inst_6 : LieModule K L M] [FiniteDimensional K M]
[inst_8 : LieRing.IsNilpotent L] [inst_9 : LieModule.LinearWeights K L M] [Li... | null | true |
FreeCommRing.isSupported_mul | Mathlib.RingTheory.FreeCommRing | ∀ {α : Type u} {x y : FreeCommRing α} {s : Set α}, x.IsSupported s → y.IsSupported s → (x * y).IsSupported s | null | true |
Complex.digamma_two_mul | Mathlib.Analysis.SpecialFunctions.Gamma.Digamma | ∀ {s : ℂ}, (∀ (m : ℕ), 2 * s ≠ -↑m) → (2 * s).digamma = 1 / 2 * (s.digamma + (s + 1 / 2).digamma) + Complex.log 2 | **The digamma duplication formula** `ψ(2s) = ½(ψ(s) + ψ(s + ½)) + log 2`, for
`2s ∉ {0, -1, -2, …}`, which is equivalent to `s` and `s + ½` both avoiding the poles of `ψ`.
Proved from Legendre's doubling `Complex.Gamma_mul_Gamma_add_half` by taking logarithmic
derivatives. | true |
_private.Init.Omega.IntList.0.List.mem_cons_self | Init.Omega.IntList | ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ a :: l | null | true |
Lean.PrettyPrinter.Formatter.sepByNoAntiquot.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter | null | true |
Set.mk_preimage_prod_right_eq_if | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {a : α} [inst : DecidablePred fun x => x ∈ s],
Prod.mk a ⁻¹' s ×ˢ t = if a ∈ s then t else ∅ | null | true |
LieSubmodule.nontrivial_iff._simp_1 | 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], Nontrivial (LieSubmodule R L M) = Nontrivial M | null | false |
UniformOnFun.congrLeft._proof_3 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : UniformSpace β] {𝔖 : Set (Set α)} {𝔗 : Set (Set γ)} (e : γ ≃ α),
𝔗 ⊆ Set.image ⇑e ⁻¹' 𝔖 → UniformContinuous fun g => (UniformOnFun.ofFun 𝔗) ((UniformOnFun.toFun 𝔖) g ∘ ⇑e) | null | false |
CategoryTheory.yonedaAddMonObjIsoOfRepresentableBy._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C) (F : CategoryTheory.Functor Cᵒᵖ AddMonCat) (α : (F.comp (CategoryTheory.forget AddMonCat)).RepresentableBy X)
{X_1 Y : Cᵒᵖ} (φ : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheor... | null | false |
MonoidAlgebra.instNoZeroDivisorsOfUniqueProds | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | ∀ {R : Type u_1} {A : Type u_2} [inst : Semiring R] [NoZeroDivisors R] [inst_2 : Mul A] [UniqueProds A],
NoZeroDivisors (MonoidAlgebra R A) | null | true |
Std.Tactic.BVDecide.BVExpr.var._impl | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | UInt64 → {w : ℕ} → ℕ → Std.Tactic.BVDecide.BVExpr._impl w | null | false |
_private.Lean.Level.0.Lean.Level.geq.go._sparseCasesOn_2.else_eq | Lean.Level | ∀ {motive : Lean.Level → Sort u} (t : Lean.Level) (max : (a a_1 : Lean.Level) → motive (a.max a_1))
(imax : (a a_1 : Lean.Level) → motive (a.imax a_1)) (succ : (a : Lean.Level) → motive a.succ)
(«else» : Nat.hasNotBit 14 t.ctorIdx → motive t) (h : Nat.hasNotBit 14 t.ctorIdx),
Lean.Level.geq.go._sparseCasesOn_2✝ t... | null | false |
CategoryTheory.Ind.colimitPresentationCompYoneda | Mathlib.CategoryTheory.Limits.Indization.Category | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(X : CategoryTheory.Ind C) → CategoryTheory.Limits.colimit (X.presentation.F.comp CategoryTheory.Ind.yoneda) ≅ X | An ind-object `X` is the colimit (in `Ind C`!) of the filtered diagram presenting it. | true |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.getKey!_eq_default._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.HandleOverlapState.insertSurrounding.go | Lean.Server.FileWorker.SemanticHighlighting | Lean.Server.FileWorker.AbsoluteLspSemanticToken →
List Lean.Server.FileWorker.AbsoluteLspSemanticToken → List Lean.Server.FileWorker.AbsoluteLspSemanticToken | null | true |
CommRingCat.Colimits.Relation.below.add_2 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
{motive : (a a_1 : CommRingCat.Colimits.Prequotient F) → CommRingCat.Colimits.Relation F a a_1 → Prop}
(x y y' : CommRingCat.Colimits.Prequotient F) (x_1 : CommRingCat.Colimits.Relation F y y'),
CommRingCat.Colimits.... | null | true |
NonUnitalStarAlgHom.range._proof_1 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B] [inst_5 : Module R B] [inst_6 : Star B]
(φ : A →⋆ₙₐ[R] B) {a : B},
a ∈ (NonUnitalAlgHomClass.toNonUnitalAlgHom φ).range.carri... | null | false |
PadicInt.mahlerEquiv | Mathlib.NumberTheory.Padics.MahlerBasis | {p : ℕ} →
[hp : Fact (Nat.Prime p)] →
(E : Type u_1) →
[inst : NormedAddCommGroup E] →
[inst_1 : Module ℤ_[p] E] →
[inst_2 : IsBoundedSMul ℤ_[p] E] →
[IsUltrametricDist E] → [CompleteSpace E] → C(ℤ_[p], E) ≃ₗᵢ[ℤ_[p]] ZeroAtInftyContinuousMap ℕ E | The isometric equivalence from `C(ℤ_[p], E)` to the space of sequences in `E` tending to `0` given
by Mahler's theorem, for `E` a nonarchimedean `ℚ_[p]`-Banach space.
| true |
CategoryTheory.HasCodetector.mk | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C],
(∃ G, CategoryTheory.IsCodetector G) → CategoryTheory.HasCodetector C | null | true |
forall_lt_add_iff_lt_left | Mathlib.Algebra.Order.Monoid.Canonical.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {P : α → Prop} {b c : α} [inst_1 : Add α] [CanonicallyOrderedAdd α]
[AddLeftReflectLT α] [IsLeftCancelAdd α], (∀ a < b + c, P a) ↔ (∀ a < b, P a) ∧ ∀ d < c, P (b + d) | null | true |
DerivedWanted.recOn | Batteries.Util.ProofWanted | {α : Sort u} →
{motive : DerivedWanted α → Sort u_1} → (t : DerivedWanted α) → ((val : α) → motive { val := val }) → motive t | null | false |
_private.Mathlib.Order.Filter.Basic.0.Filter.not_le._simp_1_3 | Mathlib.Order.Filter.Basic | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
PolyEquivTensor.invFun | Mathlib.RingTheory.PolynomialAlgebra | (R : Type u_1) →
(A : Type u_3) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Algebra R A] → Polynomial A → TensorProduct R A (Polynomial R) | (Implementation detail.)
The bare function `A[X] → A ⊗[R] R[X]`.
(We don't need to show that it's an algebra map, thankfully --- just that it's an inverse.)
| true |
USize.toBitVec_ofNatTruncate_of_lt | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < USize.size), (USize.ofNatClamp n).toBitVec = n#'hn | null | true |
SetLike.GradedBracket.rec | Mathlib.Algebra.Lie.Graded | {ι : Type u_1} →
{κ : Type u_2} →
{σ : Type u_3} →
{τ : Type u_4} →
{L : Type u_6} →
{M : Type u_7} →
[inst : SetLike σ L] →
[inst_1 : SetLike τ M] →
[inst_2 : Bracket L M] →
[inst_3 : VAdd ι κ] →
{ℒ : ι → σ} →... | null | false |
MeasureTheory.Measure.hausdorffMeasure.eq_1 | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] (d : ℝ),
MeasureTheory.Measure.hausdorffMeasure d = MeasureTheory.Measure.mkMetric fun r => r ^ d | null | true |
CategoryTheory.CartesianMonoidalCategory.prodComparisonBifunctorNatIso_inv | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₁} [inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D)
[inst_4 : ∀ (A B : C), CategoryTheory.Limits.PreservesLi... | null | true |
CategoryTheory.EnrichedCat.rightUnitor | Mathlib.CategoryTheory.Enriched.EnrichedCat | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
{D : Type u₁} →
[inst_3 : CategoryTheory.EnrichedCategory V D] →
(F : CategoryTheory.EnrichedF... | Composing any `V`-enriched functor with the identity functor is isomorphic to the former
functor. | true |
isPrincipalIdealRing_prod_iff | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {R : Type u} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S],
IsPrincipalIdealRing (R × S) ↔ IsPrincipalIdealRing R ∧ IsPrincipalIdealRing S | null | true |
Std.DHashMap.Equiv.congr_left | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.DHashMap α β},
m₁.Equiv m₂ → (m₁.Equiv m₃ ↔ m₂.Equiv m₃) | null | true |
Complex.abs_arg_inv | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ (x : ℂ), |x⁻¹.arg| = |x.arg| | null | true |
Lean.ScopedEnvExtension.Entry.ctorIdx | Lean.ScopedEnvExtension | {α : Type} → Lean.ScopedEnvExtension.Entry α → ℕ | null | false |
MeasureTheory.Measure.instPartialOrder._proof_4 | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {α : Type u_1} {mα : MeasurableSpace α} (x x_1 : MeasureTheory.Measure α),
(∀ (s : Set α), x s ≤ x_1 s) → (∀ (s : Set α), x_1 s ≤ x s) → x = x_1 | null | false |
ContinuousLinearMap.flip._proof_1 | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_6} {𝕜₂ : Type u_4} {𝕜₃ : Type u_5} {E' : Type u_1} {F' : Type u_3} {G' : Type u_2}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜₂] [inst_2 : NontriviallyNormedField 𝕜₃]
{σ₂₃ : 𝕜₂ →+* 𝕜₃} {σ₁₃ : 𝕜 →+* 𝕜₃} [inst_3 : AddCommGroup E'] [inst_4 : Module 𝕜 E'] [inst_5 : To... | null | false |
_private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.mk_eq_two_iff'._simp_1_2 | Mathlib.SetTheory.Cardinal.Basic | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
Std.Time.Modifier.A.injEq | Std.Time.Format.Modifier | ∀ (presentation presentation_1 : Std.Time.Number),
(Std.Time.Modifier.A presentation = Std.Time.Modifier.A presentation_1) = (presentation = presentation_1) | null | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxi.Iterator.instFinitenessRelation.match_1 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] (it' : Std.IterM Id α)
(motive : it'.IsPlausibleSuccessorOf { internalState := { next := none } } → Prop)
(h : it'.IsPlausibleSuccessorOf { internalState := { next := none } }),
(∀ (step : Std.IterStep (Std.IterM Id α) α) (hs₁ : step.successor = some it')
... | null | false |
_private.Mathlib.Analysis.Normed.Operator.Fredholm.Basic.0.ContinuousLinearMap.isFredholm_congr._simp_1_1 | Mathlib.Analysis.Normed.Operator.Fredholm.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : AddCommGroup F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] [inst_5 : TopologicalSpace E]
[inst_6 : TopologicalSpace F] [CompleteSpace 𝕜] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E]
[IsTo... | null | false |
SymAlg.instNonAssocRingOfInvertibleOfNat._proof_3 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : Ring α] (a b : αˢʸᵐ), a - b = a + -b | null | false |
ContinuousMultilinearMap.bound | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(f : ContinuousMultilinearMap 𝕜 E G), ∃... | null | true |
IsSquare.one | Mathlib.Algebra.Group.Even | ∀ {α : Type u_2} [inst : MulOneClass α], IsSquare 1 | null | true |
ProbabilityTheory.hasDerivAt_iteratedDeriv_complexMGF | Mathlib.Probability.Moments.ComplexMGF | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {z : ℂ},
z.re ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ (n : ℕ),
HasDerivAt (iteratedDeriv n (ProbabilityTheory.complexMGF X μ))
(∫ (x : Ω), (fun ω => ↑(X ω) ^ (n + 1) * Complex.exp (z * ↑(X ω))) x ∂μ) z | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.