name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CoxeterSystem.isReflection_conj_iff | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (w t : W),
cs.IsReflection (w * t * w⁻¹) ↔ cs.IsReflection t | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Comon_.0.CategoryTheory.Comon.instIsComonHomHom._proof_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N : CategoryTheory.Comon C} (f : M ⟶ N), CategoryTheory.IsComonHom f.hom | null | false |
Int.units_eq_one_or | Mathlib.Algebra.Ring.Int.Units | ∀ (u : ℤˣ), u = 1 ∨ u = -1 | null | true |
Rat.mul._proof_1 | Init.Data.Rat.Basic | ∀ (a b : ℚ), ↑(a.num.natAbs.gcd b.den) ∣ a.num | null | false |
Submodule.FG.restrictScalars | Mathlib.RingTheory.Finiteness.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {A : Type u_3}
[inst_3 : Semiring A] [inst_4 : Module R A] [inst_5 : Module A M] [inst_6 : IsScalarTower R A M] {S : Submodule A M}
[Module.Finite R A], S.FG → (Submodule.restrictScalars R S).FG | null | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.isCongruentCheck.go.match_1 | Lean.Meta.Tactic.Grind.Internalize | (motive : Lean.Expr → Sort u_1) →
(e₂ : Lean.Expr) → ((g arg : Lean.Expr) → motive (g.app arg)) → ((x : Lean.Expr) → motive x) → motive e₂ | null | false |
_private.Mathlib.Data.Finset.Union.0.Finset.mem_disjiUnion._simp_1_2 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type v} {b : β} {s : Multiset α} {f : α → Multiset β}, (b ∈ s.bind f) = ∃ a ∈ s, b ∈ f a | null | false |
List.append._sunfold | Init.Prelude | {α : Type u_1} → List α → List α → List α | null | false |
Mathlib.MoveAdd.pairUp | Mathlib.Tactic.MoveAdd | List (Lean.Expr × Bool × Lean.Syntax) →
List Lean.Expr → Lean.MetaM (List (Lean.Expr × Bool) × List (Lean.Expr × Bool × Lean.Syntax)) | `pairUp L R` takes two lists `L R : List Expr` as inputs.
It scans the elements of `L`, looking for a corresponding `DefEq` `Expr`ession in `R`.
If it finds one such element `d`, then it sets the element `d : R` aside, removing it from `R`, and
it continues with the matching on the remainder of `L` and on `R.erase d`.
... | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionOfMonoidalFunctorToEndofunctorMop._proof_5 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C (CategoryTheory.Functor D D)ᴹᵒᵖ) (c : C)
(d : D),
(F.map (CategoryTheory.CategoryStruct.id c)).unmop.app d = CategoryTheory.CategoryStruct.id ((F.obj c).unmop... | null | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateOsetImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu →
Lean.FVarId → ℕ → Lean.Compiler.LCNF.Arg pu → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.Code pu | null | true |
ArchimedeanClass.stdPart_neg | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] (x : K),
ArchimedeanClass.stdPart (-x) = -ArchimedeanClass.stdPart x | null | true |
LaurentSeries.instLaurentSeriesComplete | Mathlib.RingTheory.LaurentSeries | ∀ {K : Type u_2} [inst : Field K], CompleteSpace (LaurentSeries K) | Laurent Series with coefficients in a field are complete w.r.t. the `X`-adic valuation | true |
Pi.isAtom_iff_eq_single | Mathlib.Order.Atoms | ∀ {ι : Type u_4} {π : ι → Type u} [inst : DecidableEq ι] [inst_1 : (i : ι) → PartialOrder (π i)]
[inst_2 : (i : ι) → OrderBot (π i)] {f : (i : ι) → π i}, IsAtom f ↔ ∃ i a, IsAtom a ∧ f = Function.update ⊥ i a | null | true |
List.decidableInfix._unsafe_rec | Mathlib.Data.List.Infix | {α : Type u_1} → [DecidableEq α] → (l₁ l₂ : List α) → Decidable (l₁ <:+: l₂) | null | false |
Cardinal.lift_le_aleph_ofNat | Mathlib.SetTheory.Cardinal.Aleph | ∀ {c : Cardinal.{u}} {n : ℕ} [inst : n.AtLeastTwo],
Cardinal.lift.{v, u} c ≤ Cardinal.aleph (OfNat.ofNat n) ↔ c ≤ Cardinal.aleph (OfNat.ofNat n) | null | true |
FiniteDimensional.of_injective | Mathlib.LinearAlgebra.FiniteDimensional.Defs | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {V₂ : Type v'}
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] (f : V →ₗ[K] V₂),
Function.Injective ⇑f → ∀ [FiniteDimensional K V₂], FiniteDimensional K V | If the codomain of an injective linear map is finite dimensional, the domain must be as well. | true |
Array.instOrientedCmpCompareLex | Init.Data.Order.Ord | ∀ {α : Type u_1} {cmp : α → α → Ordering} [Std.OrientedCmp cmp], Std.OrientedCmp (Array.compareLex cmp) | null | true |
Bundle.Trivialization.nhds_eq_inf_comap | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) {z : Z},
z ∈ e.source → nhds z = Filter.comap proj (nhds (proj z)) ⊓ Filter.comap (Prod.snd ∘ ↑e) (nhds (↑e z).2) | null | true |
Lean.Lsp.instHashableMarkupKind.hash | Lean.Data.Lsp.Basic | Lean.Lsp.MarkupKind → UInt64 | null | true |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.ext_indep._simp_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M.IsBase B = Maximal M.Indep B | null | false |
CategoryTheory.IsModHom | Mathlib.CategoryTheory.Monoidal.Mod | {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.MonoidalLeftAction C D] →
(A : C) →
[inst_4 : Cat... | A morphism in `D` is a morphism of `A`-module objects if it commutes with
the action maps | true |
NonUnitalSemiring.ext_iff | Mathlib.Algebra.Ring.Ext | ∀ {R : Type u} {inst₁ inst₂ : NonUnitalSemiring R}, inst₁ = inst₂ ↔ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul | null | true |
Flow.IsFactorOf.self | Mathlib.Dynamics.Flow | ∀ {τ : Type u_1} {α : Type u_2} [inst : TopologicalSpace τ] [inst_1 : TopologicalSpace α] [inst_2 : AddMonoid τ]
(ϕ : Flow τ α), ϕ.IsFactorOf ϕ | Every flow is a factor of itself. | true |
MeasureTheory.«_aux_Mathlib_MeasureTheory_Measure_MeasureSpaceDef___macroRules_MeasureTheory_term∀ᵐ_,__1» | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | Lean.Macro | null | false |
RingCat.Colimits.Prequotient.recOn | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J RingCat} →
{motive : RingCat.Colimits.Prequotient F → Sort u} →
(t : RingCat.Colimits.Prequotient F) →
((j : J) → (x : ↑(F.obj j)) → motive (RingCat.Colimits.Prequotient.of j x)) →
motive Rin... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_insert._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Std.DHashMap.Internal.Raw₀.eraseMany_eq_eraseListₘ_toListModel | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m m₂ : Std.DHashMap.Internal.Raw₀ α β),
↑(m.eraseManyEntries ↑m₂) = m.eraseListₘ (List.map (fun x => x.fst) (Std.DHashMap.Internal.toListModel (↑m₂).buckets)) | null | true |
Complex.UnitClosedDisc.mk_coe | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z : Complex.UnitClosedDisc) (hz : optParam (‖↑z‖ ≤ 1) ⋯), Complex.UnitClosedDisc.mk (↑z) hz = z | null | true |
HilbertBasis._sizeOf_inst | Mathlib.Analysis.InnerProductSpace.l2Space | (ι : Type u_1) →
(𝕜 : Type u_2) →
{inst : RCLike 𝕜} →
(E : Type u_3) →
{inst_1 : NormedAddCommGroup E} →
{inst_2 : InnerProductSpace 𝕜 E} → [SizeOf ι] → [SizeOf 𝕜] → [SizeOf E] → SizeOf (HilbertBasis ι 𝕜 E) | null | false |
_private.Init.Data.Nat.Fold.0.Nat.dfold._proof_9 | Init.Data.Nat.Fold | ∀ (n m : ℕ), m.succ ≤ n → ¬n - m.succ + 1 = n - m → False | null | false |
_private.Mathlib.Topology.Spectral.Prespectral.0.PrespectralSpace.of_isOpenCover._simp_1_1 | Mathlib.Topology.Spectral.Prespectral | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
CategoryTheory.Oplax.StrongTrans.Modification.whiskerRight_naturality | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} (Γ : CategoryTheory.Oplax.StrongTrans.Modification η θ)
{a b : B} {a' : C} (f : a ⟶ b) (g : G.obj b ⟶ a'),
CategoryTheory.CategoryStruct.comp
(Categ... | null | true |
WithBot.pow_ne_bot_iff | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MonoidWithZero α] [inst_2 : NoZeroDivisors α] [inst_3 : Nontrivial α]
{x : WithBot α} {n : ℕ}, x ^ n ≠ ⊥ ↔ x ≠ ⊥ ∨ n = 0 | null | true |
indicator_union_eventuallyEq | Mathlib.Order.Filter.IndicatorFunction | ∀ {α : Type u_1} {M : Type u_3} [inst : AddMonoid M] {s t : Set α} {f : α → M} {l : Filter α},
(∀ᶠ (a : α) in l, a ∉ s ∩ t) → (s ∪ t).indicator f =ᶠ[l] s.indicator f + t.indicator f | null | true |
Relation.ReflTransGen.below.refl | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop} {a : α} {motive : (a_1 : α) → Relation.ReflTransGen r a a_1 → Prop},
Relation.ReflTransGen.below ⋯ | null | true |
_private.Std.Do.WP.SimpLemmas.0.Option.orElse.match_1.splitter | Std.Do.WP.SimpLemmas | {α : Type u_1} →
(motive : Option α → (Unit → Option α) → Sort u_2) →
(x : Option α) →
(x_1 : Unit → Option α) →
((a : α) → (x : Unit → Option α) → motive (some a) x) → ((b : Unit → Option α) → motive none b) → motive x x_1 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_left._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.Mathlib.Probability.Process.LocalProperty.0.ProbabilityTheory.IsStable.locally_and_iff._simp_1_5 | Mathlib.Probability.Process.LocalProperty | ∀ {α : Type u_1} {M : Type u_3} [inst : Zero M] (s t : Set α) (f : α → M),
(s ∩ t).indicator f = s.indicator (t.indicator f) | null | false |
Submodule.finrank_sup_add_finrank_inf_eq | Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(s t : Submodule K V) [FiniteDimensional K ↥s] [FiniteDimensional K ↥t],
Module.finrank K ↥(s ⊔ t) + Module.finrank K ↥(s ⊓ t) = Module.finrank K ↥s + Module.finrank K ↥t | The sum of the dimensions of s + t and s ∩ t is the sum of the dimensions of s and t | true |
_private.Aesop.Tree.Data.0.Aesop.instDecidableEqGoalId.decEq._proof_2 | Aesop.Tree.Data | ∀ (a b : ℕ), ¬a = b → { toNat := a } = { toNat := b } → False | null | false |
Std.Tactic.BVDecide.Gate.beq.sizeOf_spec | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | sizeOf Std.Tactic.BVDecide.Gate.beq = 1 | null | true |
LieAlgebra.Orthogonal.indefiniteDiagonal_assoc | Mathlib.Algebra.Lie.Classical | ∀ (l : Type u_4) (R : Type u₂) [inst : DecidableEq l] [inst_1 : CommRing R] [inst_2 : Fintype l],
LieAlgebra.Orthogonal.indefiniteDiagonal (Unit ⊕ l) l R =
(Matrix.reindexLieEquiv (Equiv.sumAssoc Unit l l).symm)
(Matrix.fromBlocks 1 0 0 (LieAlgebra.Orthogonal.indefiniteDiagonal l l R)) | null | true |
LinearMap.IsRefl.nondegenerate_iff_separatingRight | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup M₁] [inst_4 : Module R M₁] {B : M →ₗ[R] M →ₗ[R] M₁},
B.IsRefl → (B.Nondegenerate ↔ B.SeparatingRight) | null | true |
Function.mulSupport_one_add' | Mathlib.Algebra.GroupWithZero.Indicator | ∀ {ι : Type u_1} {R : Type u_5} [inst : One R] [inst_1 : AddLeftCancelMonoid R] (f : ι → R),
Function.mulSupport (1 + f) = Function.support f | null | true |
AlgebraicGeometry.IsOpenImmersion | Mathlib.AlgebraicGeometry.OpenImmersion | CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme | A morphism of Schemes is an open immersion if it is an open immersion as a morphism
of LocallyRingedSpaces
| true |
FinPartOrd.mk.inj | Mathlib.Order.Category.FinPartOrd | ∀ {toPartOrd : PartOrd} {isFintype : Fintype ↑toPartOrd} {toPartOrd_1 : PartOrd} {isFintype_1 : Fintype ↑toPartOrd_1},
{ toPartOrd := toPartOrd, isFintype := isFintype } = { toPartOrd := toPartOrd_1, isFintype := isFintype_1 } →
toPartOrd = toPartOrd_1 ∧ isFintype ≍ isFintype_1 | null | true |
smoothSheaf.eval_surjective | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : Topo... | The `eval` map is surjective at `x`. | true |
isBounded_ge_nhds | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : TopologicalSpace α] [BoundedGENhdsClass α] (a : α),
Filter.IsBounded (fun x1 x2 => x1 ≥ x2) (nhds a) | null | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.processConstructor.match_5 | Lean.Meta.Match.Match | (motive : List Lean.Expr → Sort u_1) →
(x : List Lean.Expr) →
((x : Lean.Expr) → (xs : List Lean.Expr) → motive (x :: xs)) → ((x : List Lean.Expr) → motive x) → motive x | null | false |
AddActionHom.mk.injEq | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_8} {N : Type u_9} {φ : M → N} {X : Type u_10} [inst : VAdd M X] {Y : Type u_11} [inst_1 : VAdd N Y]
(toFun : X → Y) (map_vadd' : ∀ (m : M) (x : X), toFun (m +ᵥ x) = φ m +ᵥ toFun x) (toFun_1 : X → Y)
(map_vadd'_1 : ∀ (m : M) (x : X), toFun_1 (m +ᵥ x) = φ m +ᵥ toFun_1 x),
({ toFun := toFun, map_vadd' ... | null | true |
stronglyMeasurable_bot_iff | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : TopologicalSpace β] [Nonempty β] [T2Space β],
MeasureTheory.StronglyMeasurable f ↔ ∃ c, f = fun x => c | null | true |
OrderDual.instMeasurableInf₂ | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] [inst_1 : Max M] [MeasurableSup₂ M], MeasurableInf₂ Mᵒᵈ | null | true |
MeasureTheory.LevyProkhorov.probabilityMeasureHomeomorph._proof_2 | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (x : MeasureTheory.LevyProkhorov (MeasureTheory.ProbabilityMeasure Ω)),
MeasureTheory.LevyProkhorov.ofMeasure x.toMeasure = MeasureTheory.LevyProkhorov.ofMeasure x.toMeasure | null | false |
Aesop.NormSimpRule.instHashable | Aesop.Rule | Hashable Aesop.NormSimpRule | null | true |
Lean.Meta.SynthInstance.TableEntry.recOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.SynthInstance.TableEntry → Sort u} →
(t : Lean.Meta.SynthInstance.TableEntry) →
((waiters : Array Lean.Meta.SynthInstance.Waiter) →
(answers : Array Lean.Meta.SynthInstance.Answer) → motive { waiters := waiters, answers := answers }) →
motive t | null | false |
pointedToBipointedCompBipointedToPointedSnd_hom_app_toFun | Mathlib.CategoryTheory.Category.Bipointed | ∀ (X : Pointed) (a : ((pointedToBipointed.comp bipointedToPointedSnd).obj X).X),
(pointedToBipointedCompBipointedToPointedSnd.hom.app X).toFun a = a | null | true |
Lean.Elab.ConfigEval.EvalConfigItemHandlerKind.wildcard | Lean.Elab.ConfigEval.DeriveEvalConfigItem | Lean.Elab.ConfigEval.EvalConfigItemHandlerKind | Handler is called when its key is a strict prefix of the configuration key.
The matched key may be `Name.anonymous`. | true |
Subring.topologicalClosure._proof_5 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsSemitopologicalRing R] (S : Subring R)
{a b : R},
a ∈ S.toAddSubgroup.topologicalClosure.carrier →
b ∈ S.toAddSubgroup.topologicalClosure.carrier → a + b ∈ S.toAddSubgroup.topologicalClosure.carrier | null | false |
_private.Mathlib.Tactic.Setm.0.Mathlib.Tactic.SetM.replaceWithLDecls | Mathlib.Tactic.Setm | Lean.Syntax → Mathlib.Tactic.SetM.SetMReplaceM✝ Lean.Syntax | Traverse all synthetic holes, creating local declarations for them.
A synthetic hole of the form `?n` leads to a local declaration of the form `n := ?m.1`, with the
new metavariable natural and recorded in the state. | true |
SimpleGraph.Iso.connectedComponentEquiv | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | {V : Type u} →
{V' : Type v} → {G : SimpleGraph V} → {G' : SimpleGraph V'} → G ≃g G' → G.ConnectedComponent ≃ G'.ConnectedComponent | An isomorphism of graphs induces a bijection of connected components. | true |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.ExtState.default._proof_1 | Mathlib.Tactic.Widget.LibraryRewrite | Nonempty (ST.Ref IO.RealWorld (Option (Lean.Meta.RefinedDiscrTree Mathlib.Tactic.LibraryRewrite.RewriteLemma))) | null | false |
ENNReal.inv_limsup | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {ι : Type u_4} {x : ι → ENNReal} {l : Filter ι}, (Filter.limsup x l)⁻¹ = Filter.liminf (fun i => (x i)⁻¹) l | null | true |
Hyperreal.instLinearOrder._proof_24 | Mathlib.Analysis.Real.Hyperreal | autoParam (∀ (a b : ℝ*), compare a b = compareOfLessAndEq a b) LinearOrder.compare_eq_compareOfLessAndEq._autoParam | null | false |
one_lt_sq_iff₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a : M₀}
[ZeroLEOneClass M₀], 0 ≤ a → (1 < a ^ 2 ↔ 1 < a) | null | true |
Group.IsFinitelyPresented.rec | Mathlib.GroupTheory.FinitelyPresentedGroup | {G : Type u_4} →
[inst : Group G] →
{motive : Group.IsFinitelyPresented G → Sort u} →
((out : ∃ n φ, Function.Surjective ⇑φ ∧ φ.ker.IsFinitelyNormallyGenerated) → motive ⋯) →
(t : Group.IsFinitelyPresented G) → motive t | null | false |
Turing.PartrecToTM2.trPosNum.eq_3 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (n : PosNum), Turing.PartrecToTM2.trPosNum n.bit1 = Turing.PartrecToTM2.Γ'.bit1 :: Turing.PartrecToTM2.trPosNum n | null | true |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.image._simp_1_1 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : DivisionMonoid β] [inst_2 : FunLike F α β]
[MonoidHomClass F α β] (f : F) (s : Set α), (⇑f '' s)⁻¹ = ⇑f '' s⁻¹ | null | false |
CategoryTheory.ComposableArrows.fourδ₄Toδ₃_app_zero | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₃₄ : i₂ ⟶ i₄) (h₃₄ : CategoryTheory.CategoryStruct.comp f₃ f₄ = f₃₄),
(CategoryTheory.ComposableArrows.fourδ₄Toδ₃ f₁ f₂ f₃ f₄ f₃₄ h₃₄).app 0 =
CategoryTheory.Category... | null | true |
BoxIntegral.Prepartition.sum_fiberwise | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {α : Type u_2} {M : Type u_3} [inst : AddCommMonoid M]
(π : BoxIntegral.Prepartition I) (f : BoxIntegral.Box ι → α) (g : BoxIntegral.Box ι → M),
∑ y ∈ Finset.image f π.boxes, ∑ J ∈ (π.filter fun J => f J = y).boxes, g J = ∑ J ∈ π.boxes, g J | null | true |
Set.instSupSet | Mathlib.Order.SetNotation | {α : Type u} → SupSet (Set α) | null | true |
CategoryTheory.GradedObject.Monoidal.ιTensorObj₃._proof_2 | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u_1} [inst : AddMonoid I] (i₂ i₃ : I), i₂ + i₃ = i₂ + i₃ | null | false |
_private.Batteries.Data.Nat.Bisect.0.Nat.bisect._unary._proof_3 | Batteries.Data.Nat.Bisect | ∀ {p : ℕ → Bool} (start stop : ℕ) (h : start < stop) (hstart : p start = true) (hstop : p stop = false)
(hmidstop : start.avg stop < stop),
start < start.avg stop →
∀ (hmid : p (start.avg stop) = true),
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSigma.casesOn x fun start stop =>
... | null | false |
RingCat.limitRing._proof_26 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J RingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget RingCat)).sections]
(a b c : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget RingCat))).pt),
a * (b + c) = a * b + a ... | null | false |
IsOpenMap.image_interior_subset | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
IsOpenMap f → ∀ (s : Set X), f '' interior s ⊆ interior (f '' s) | null | true |
DividedPowers.OfInvertibleFactorial.dividedPowers | Mathlib.RingTheory.DividedPowers.RatAlgebra | {A : Type u_1} →
[inst : CommSemiring A] →
{I : Ideal A} → [DecidablePred fun x => x ∈ I] → {n : ℕ} → IsUnit ↑(n - 1).factorial → I ^ n = 0 → DividedPowers I | If `(n-1)!` is invertible in `A` and `I^n = 0`, then `I` admits a divided power structure.
Proposition 1.2.7 of [B74], part (ii). | true |
Orientation.definition._proof_3._@.Mathlib.Analysis.InnerProductSpace.Orientation.2114562672._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {n : ℕ}, n = 0 → 0 = n | null | false |
HahnSeries.order_eq_orderTop_of_ne_zero | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] {x : HahnSeries Γ R} [inst_2 : Zero Γ],
x ≠ 0 → ↑x.order = x.orderTop | null | true |
Bundle.RiemannianBundle.mk._flat_ctor | Mathlib.Topology.VectorBundle.Riemannian | {B : Type u_4} →
{E : B → Type u_6} →
[inst : (b : B) → TopologicalSpace (E b)] →
[inst_1 : (b : B) → AddCommGroup (E b)] →
[inst_2 : (b : B) → Module ℝ (E b)] → Bundle.RiemannianMetric E → Bundle.RiemannianBundle E | null | false |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.ensureClassTranslated._sparseCasesOn_4 | Mathlib.Tactic.Translate.Core | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
LieRing.lie_self | Mathlib.Algebra.Lie.Basic | ∀ {L : Type v} [self : LieRing L] (x : L), ⁅x, x⁆ = 0 | A Lie ring bracket vanishes on the diagonal in L × L. | true |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.OfKernel.kerFunAux | Mathlib.Analysis.InnerProductSpace.Reproducing | {𝕜 : Type u_1} →
[inst : RCLike 𝕜] →
{X : Type u_2} →
{V : Type u_3} →
[inst_1 : NormedAddCommGroup V] →
[inst_2 : InnerProductSpace 𝕜 V] →
[inst_3 : CompleteSpace V] →
{K : Matrix X X (V →L[𝕜] V)} →
[inst_4 : Fact K.PosSemidef] → X → V →ₗ[𝕜] ... | null | true |
instIsIntegrallyClosedPolynomialOfIsDomain | Mathlib.RingTheory.Polynomial.IsIntegral | ∀ {R : Type u_4} [inst : CommRing R] [IsDomain R] [IsIntegrallyClosed R], IsIntegrallyClosed (Polynomial R) | [Stacks Tag 030A](https://stacks.math.columbia.edu/tag/030A) | true |
Lean.Compiler.InlineAttributeKind.alwaysInline | Lean.Compiler.InlineAttrs | Lean.Compiler.InlineAttributeKind | null | true |
lTensor.inverse_of_rightInverse._proof_5 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
Bialgebra.Quotient.instQuotientIdeal._proof_8 | Mathlib.RingTheory.Bialgebra.Quotient | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | null | false |
ReaderT.instULiftableULiftULift | Mathlib.Control.ULiftable | {s : Type u₀} →
{m : Type (max u₀ v₀) → Type u_5} →
{m' : Type (max u₀ v₁) → Type u_6} →
[ULiftable m m'] → ULiftable (ReaderT (ULift.{max v₀ u₀, u₀} s) m) (ReaderT (ULift.{max v₁ u₀, u₀} s) m') | null | true |
Multiplicative.toAdd_eq_top._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags | ∀ {α : Type u_1} [inst : LE α] [inst_1 : OrderTop α] {a : Multiplicative α}, (Multiplicative.toAdd a = ⊤) = (a = ⊤) | null | false |
_private.Mathlib.Order.Ideal.0.Order.Ideal.mem_sInf._simp_1_2 | Mathlib.Order.Ideal | ∀ {γ : Type u_3} {ι : Sort u_4} {κ : ι → Sort u_7} {x : γ} {s : (i : ι) → κ i → Set γ},
(x ∈ ⋂ i, ⋂ j, s i j) = ∀ (i : ι) (j : κ i), x ∈ s i j | null | false |
Std.Sat.CNF.sat_of_all_mem_sat | Std.Sat.CNF.Sat | ∀ {α : Type u_1} {f : Std.Sat.CNF α} {a : α → Bool}, (∀ c ∈ f, Std.Sat.CNF.Clause.Sat a c) → Std.Sat.CNF.Sat a f | null | true |
_private.Mathlib.Data.Nat.WithBot.0.Nat.WithBot.add_eq_two_iff._simp_1_1 | Mathlib.Data.Nat.WithBot | ∀ {α : Type u} [inst : Add α] (a b : α), ↑a + ↑b = ↑(a + b) | null | false |
_private.Mathlib.NumberTheory.Transcendental.Liouville.Measure.0.setOfPred_liouvilleWith_subset_aux._simp_1_3 | Mathlib.NumberTheory.Transcendental.Liouville.Measure | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : LinearOrder α] [inst_2 : FloorRing α] (a : α), (↑⌊a⌋ ≤ a) = True | null | false |
IsAdicComplete.of_lift | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_5} [inst_3 : AddCommGroup N] [inst_4 : Module R N] [inst_5 : IsAdicComplete I N]
(f : (n : ℕ) → M →ₗ[R] N ⧸ I ^ n • ⊤) (h : ∀ {m n : ℕ} (hle : m ≤ n), Submodule.factorPow I N hle ∘ₗ f n = f ... | null | true |
Lean.SimplePersistentEnvExtensionDescr.addEntryFn | Lean.EnvExtension | {α σ : Type} → Lean.SimplePersistentEnvExtensionDescr α σ → σ → α → σ | null | true |
MemHolder.smul | Mathlib.Topology.MetricSpace.HolderNorm | ∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : NormedAddCommGroup Y] {r : NNReal} {f : X → Y}
{𝕜 : Type u_3} [inst_2 : SeminormedRing 𝕜] [inst_3 : Module 𝕜 Y] [IsBoundedSMul 𝕜 Y] {c : 𝕜},
MemHolder r f → MemHolder r (c • f) | null | true |
instUniformSpaceBool | Mathlib.Topology.UniformSpace.Basic | UniformSpace Bool | null | true |
CategoryTheory.Limits.IndObjectPresentation.yoneda_F | Mathlib.CategoryTheory.Limits.Indization.IndObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.Limits.IndObjectPresentation.yoneda X).F = CategoryTheory.Functor.fromPUnit X | null | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.mul_dvd_mul_eq | Init.Data.Int.Linear | ∀ {a b c : ℤ}, a ≠ 0 → (a * b ∣ a * c ↔ b ∣ c) | null | true |
HurwitzZeta.hasSum_nat_completedSinZeta | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : ℝ) {s : ℂ},
1 < s.re →
HasSum (fun n => (s + 1).Gammaℝ * ↑(Real.sin (2 * Real.pi * a * ↑n)) / ↑n ^ s) (HurwitzZeta.completedSinZeta (↑a) s) | Formula for `completedSinZeta` as a Dirichlet series in the convergence range
(second version, with sum over `ℕ`). | true |
HomologicalComplex.cylinder.ι₀.eq_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} (K : HomologicalComplex C c) [inst_2 : DecidableRel c.Rel]
[inst_3 : ∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)] [inst_4 : K.HasCylinder],
Homological... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.