name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Tactic.Matrix.ListMatrix.0.Mathlib.Tactic.Matrix.ListMatrix.getD_transpose._proof_1_9 | Mathlib.Tactic.Matrix.ListMatrix | ∀ {α : Type u_1} (row : List α) (tl : List (List α)), 1 ≤ (row :: tl).length → 0 < (row :: tl).length | null | false |
Std.HashMap.Raw.getD_emptyWithCapacity | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {a : α} {fallback : β} {c : ℕ},
(Std.HashMap.Raw.emptyWithCapacity c).getD a fallback = fallback | null | true |
Finset.prod_congr_of_eq_on_inter | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_5} {M : Type u_6} {s₁ s₂ : Finset ι} {f g : ι → M} [inst : CommMonoid M],
(∀ a ∈ s₁, a ∉ s₂ → f a = 1) →
(∀ a ∈ s₂, a ∉ s₁ → g a = 1) → (∀ a ∈ s₁, a ∈ s₂ → f a = g a) → ∏ a ∈ s₁, f a = ∏ a ∈ s₂, g a | The products of two functions `f g : ι → M` over finite sets `s₁ s₂ : Finset ι`
are equal if the functions agree on `s₁ ∩ s₂`, `f = 1` and `g = 1` on the respective
set differences. | true |
NonUnitalStarAlgebra.adjoin_induction | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] {s : Set A} {p : (x : A) → x ∈ NonUnitalStarAlgebra.adjoin R s → Prop},
(∀ (x... | null | true |
FirstOrder.Language.closedUnder_univ | Mathlib.ModelTheory.Substructures | ∀ (L : FirstOrder.Language) {M : Type w} [inst : L.Structure M] {n : ℕ} (f : L.Functions n),
FirstOrder.Language.ClosedUnder f Set.univ | null | true |
IsLUB.isLUB_sSup | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderSupSet α] {s : Set α} {a : α}, IsLUB s a → IsLUB s (sSup s) | null | true |
Std.DTreeMap.Internal.Impl.isEmpty_diff_iff | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
((m₁.diff m₂ ⋯).isEmpty = true ↔
∀ (k : α), Std.DTreeMap.Internal.Impl.contains k m₁ = true → Std.DTreeMap.Internal.Impl.contains k m₂ = true) | null | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.Riemannian.0.«term⟪_,_⟫» | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | Lean.ParserDescr | null | true |
DilationEquiv.self_trans_symm | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] (e : X ≃ᵈ Y),
e.trans e.symm = DilationEquiv.refl X | null | true |
Rat.instNormedField._proof_1 | Mathlib.Analysis.Normed.Field.Lemmas | ∀ (a b : ℚ), ‖a * b‖ = ‖a‖ * ‖b‖ | null | false |
CStarMatrix.mul_zero | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} {o : Type u_7} [inst : Fintype n] [inst_1 : NonUnitalNonAssocSemiring A]
(M : CStarMatrix m n A), M * 0 = 0 | null | true |
hahnEmbedding_isOrderedAddMonoid | Mathlib.RingTheory.HahnSeries.HahnEmbedding | ∀ (M : Type u_1) [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M],
∃ f,
Function.Injective ⇑f ∧
∀ (a : M), ArchimedeanClass.mk a = (FiniteArchimedeanClass.withTopOrderIso M) (ofLex (f a)).orderTop | **Hahn embedding theorem**
For a linearly ordered additive group `M`, there exists an injective `OrderAddMonoidHom` from `M` to
`Lex ℝ⟦FiniteArchimedeanClass M⟧` that sends each `a : M` to an element of the `a`-Archimedean class
of the Hahn series.
| true |
Lean.Doc.Parser.UnorderedListType.asterisk.elim | Lean.DocString.Parser | {motive : Lean.Doc.Parser.UnorderedListType → Sort u} →
(t : Lean.Doc.Parser.UnorderedListType) → t.ctorIdx = 0 → motive Lean.Doc.Parser.UnorderedListType.asterisk → motive t | null | false |
Lean.Elab.Term.GeneralizeResult.mk.sizeOf_spec | Lean.Elab.Match | ∀ (discrs : Array Lean.Elab.Term.Discr) (toClear : Array Lean.FVarId) (matchType : Lean.Expr)
(altViews : Array Lean.Elab.Term.TermMatchAltView) (refined : Bool),
sizeOf { discrs := discrs, toClear := toClear, matchType := matchType, altViews := altViews, refined := refined } =
1 + sizeOf discrs + sizeOf toClea... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic.0.CFC.exp_log._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : NormedAlgebra ℝ A] [inst_2 : PartialOrder A] [NonnegSpectrumClass ℝ A]
(a : A), IsStrictlyPositive a → ∀ x ∈ spectrum ℝ a, ¬x = 0 | null | false |
Mathlib.Tactic.ITauto.Proof.hyp.injEq | Mathlib.Tactic.ITauto | ∀ (n n_1 : Lean.Name), (Mathlib.Tactic.ITauto.Proof.hyp n = Mathlib.Tactic.ITauto.Proof.hyp n_1) = (n = n_1) | null | true |
infPrime_toDual._simp_2 | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a : α}, InfPrime (OrderDual.toDual a) = SupPrime a | null | false |
Option.elim'.eq_2 | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} {β : Type u_2} (b : β) (f : α → β), Option.elim' b f none = b | null | true |
MonoidHom.inverse._proof_4 | Mathlib.Algebra.Group.Hom.Defs | ∀ {A : Type u_1} {B : Type u_2} [inst : Monoid A] [inst_1 : Monoid B] (f : A →* B) (g : B → A)
(h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f) (x y : B),
((↑f).inverse g h₁ h₂).toFun (x * y) = ((↑f).inverse g h₁ h₂).toFun x * ((↑f).inverse g h₁ h₂).toFun y | null | false |
_private.Mathlib.Basic.Real.ConjExponents.0.Real.HolderConjugate.div_conj_eq_sub_one._simp_1_1 | Mathlib.Basic.Real.ConjExponents | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Lean.Elab.Term.Arg._sizeOf_inst | Lean.Elab.Arg | SizeOf Lean.Elab.Term.Arg | null | false |
LinearMap.fst_surjective | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂], Function.Surjective ⇑(LinearMap.fst R M M₂) | null | true |
ENNReal.add_sub_add_eq_sub_right | Mathlib.Basic.ENNReal.Operations | ∀ {a b c : ENNReal}, autoParam (c ≠ ⊤) ENNReal.add_sub_add_eq_sub_right._auto_1 → a + c - (b + c) = a - b | null | true |
ContinuousMap.nnnorm_sum_eq_sup | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] {R : Type u_4}
[inst_2 : NonUnitalSeminormedRing R] [IsCancelMulZero R] {ι : Type u_5} {f : ι → C(α, R)} (s : Finset ι),
Pairwise (Function.onFun (fun x1 x2 => x1 * x2 = 0) f) → ‖∑ i ∈ s, f i‖₊ = s.sup fun x => ‖f x‖₊ | If the pairwise products of continuous functions on a compact space are all zero, then the norm
of their sum is the maximum of their norms. | true |
Matrix.replicateCol_smul | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {R : Type u_5} {α : Type v} {ι : Type u_6} [inst : SMul R α] (x : R) (v : m → α),
Matrix.replicateCol ι (x • v) = x • Matrix.replicateCol ι v | null | true |
Algebra.coe_inf | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S T : Subalgebra R A),
↑(S ⊓ T) = ↑S ∩ ↑T | null | true |
_private.Mathlib.AlgebraicTopology.ModelCategory.Basic.0.HomotopicalAlgebra.ModelCategory.mk'.cm3a_aux._simp_1_4 | Mathlib.AlgebraicTopology.ModelCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C],
HomotopicalAlgebra.WeakEquivalence f = HomotopicalAlgebra.weakEquivalences C f | null | false |
DifferentiableAt.finsetProd | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {ι : Type u_2} {𝔸' : Type u_3} [inst_1 : NormedCommRing 𝔸']
[inst_2 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {f : ι → 𝕜 → 𝔸'},
(∀ i ∈ u, DifferentiableAt 𝕜 (f i) x) → DifferentiableAt 𝕜 (∏ i ∈ u, f i) x | null | true |
_private.Mathlib.Algebra.Star.Subalgebra.0.StarSubalgebra.mem_centralizer_iff._simp_1_2 | Mathlib.Algebra.Star.Subalgebra | ∀ {α : Type u_1} {s : Set α} [inst : InvolutiveStar α], star s = star '' s | null | false |
EReal.div_pos | Mathlib.Data.EReal.Inv | ∀ {a b : EReal}, 0 < a → 0 < b → b ≠ ⊤ → 0 < a / b | null | true |
_private.Mathlib.SetTheory.Lists.0.Lists.mem.decidable.match_1.eq_2 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} (motive : Lists α → Lists' α true → Sort u_2) (a : Lists α) (b : Bool) (b_1 : Lists' α b)
(l₂ : Lists' α true) (h_1 : (a : Lists α) → motive a Lists'.nil)
(h_2 : (a : Lists α) → (b : Bool) → (b_2 : Lists' α b) → (l₂ : Lists' α true) → motive a (b_2.cons' l₂)),
(match a, b_1.cons' l₂ with
| a,... | null | true |
CategoryTheory.Retract.ofIso._proof_2 | Mathlib.CategoryTheory.Retract | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (e : X ≅ Y),
CategoryTheory.CategoryStruct.comp e.hom e.inv = CategoryTheory.CategoryStruct.id X | null | false |
Submodule.eq_of_le_of_finrank_le | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{S₁ S₂ : Submodule K V} [FiniteDimensional K ↥S₂], S₁ ≤ S₂ → Module.finrank K ↥S₂ ≤ Module.finrank K ↥S₁ → S₁ = S₂ | If a submodule is contained in a finite-dimensional
submodule with the same or smaller dimension, they are equal. | true |
AlgebraicGeometry.Scheme.Pullback.openCoverOfRight._proof_3 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : Y.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) (i : 𝒰.I₀),
CategoryTheory.Limits.HasPullback f (CategoryTheory.CategoryStruct.comp (𝒰.f i) g) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.signExtend_extractLsb_setWidth._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ} (i : ℕ), n + i < w → ¬n + i < w + n → False | null | false |
TensorProduct.uniqueLeft._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} {N : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [Subsingleton M] (z : TensorProduct R M N),
z = 0 | null | false |
closedBall_add_singleton | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x y : E),
Metric.closedBall x δ + {y} = Metric.closedBall (x + y) δ | null | true |
enorm_eq_zero'._simp_2 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ENormedMonoid E] {a : E}, (‖a‖ₑ = 0) = (a = 1) | null | false |
Sbtw.left_mem_image_Ioi | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] {x y z : P},
Sbtw R x y z → x ∈ ⇑(AffineMap.lineMap z y) '' Set.Ioi 1 | null | true |
FractionalIdeal.coeIdeal_span_singleton | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] (x : R), ↑(Ideal.span {x}) = (FractionalIdeal.spanSingleton S) ((algebraMap R P) x) | null | true |
sSupHom.cancel_left._simp_2 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SupSet α] [inst_1 : SupSet β] [inst_2 : SupSet γ]
{g : sSupHom β γ} {f₁ f₂ : sSupHom α β}, Function.Injective ⇑g → (g.comp f₁ = g.comp f₂) = (f₁ = f₂) | null | false |
div_lt_div_right_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b c : α},
c < 0 → (a / c < b / c ↔ b < a) | null | true |
SemilatInfCat._sizeOf_inst | Mathlib.Order.Category.Semilat | SizeOf SemilatInfCat | null | false |
LinearEquiv.smul_id_of_finrank_eq_one.eq_1 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_2} [inst : CommSemiring R] [inst_1 : StrongRankCondition R] {M : Type u_3} [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [inst_4 : Module.Free R M] (d1 : Module.finrank R M = 1),
LinearEquiv.smul_id_of_finrank_eq_one d1 =
{ toFun := fun c => c • LinearMap.id, map_add' := ⋯, map_smul' := ⋯, invF... | null | true |
MagmaCat.coe_id | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X : MagmaCat}, ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) = id | null | true |
Subgroup.IsSubnormal.below.rec | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {motive : (a : Subgroup G) → a.IsSubnormal → Prop}
{motive_1 : {a : Subgroup G} → (t : a.IsSubnormal) → Subgroup.IsSubnormal.below t → Prop},
motive_1 ⋯ ⋯ →
(∀ (H K : Subgroup G) (h_le : H ≤ K) (hSubn : K.IsSubnormal) (hN : (H.subgroupOf K).Normal)
(ih : Subgroup.IsSubn... | null | false |
_private.Mathlib.Algebra.Polynomial.EraseLead.0.Polynomial.card_support_eq'._simp_1_1 | Mathlib.Algebra.Polynomial.EraseLead | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | null | false |
MeasureTheory.Measure.MutuallySingular.restrict_nullSet | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ.MutuallySingular ν),
μ.restrict h.nullSet = 0 | null | true |
Bool.dite_true_right_eq_false._simp_1 | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : p → Bool}, ((if h : p then x h else true) = false) = ∃ (h : p), x h = false | null | false |
Set.eqOn_mulIndicator | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] {s : Set α} {f : α → M}, Set.EqOn (s.mulIndicator f) f s | See `Set.eqOn_mulIndicator'` for the version with `sᶜ`. | true |
HVertexOperator.coeff_inj_iff | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_1} [inst : PartialOrder Γ] {R : Type u_2} {V : Type u_3} {W : Type u_4} [inst_1 : CommRing R]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddCommGroup W] [inst_5 : Module R W]
{a₁ a₂ : HVertexOperator Γ R V W}, a₁ = a₂ ↔ HVertexOperator.coeff a₁ = HVertexOperator.coeff a₂ | null | true |
Lean.Elab.Term.Do.ToTerm.Kind.forIn.elim | Lean.Elab.Do.Legacy | {motive : Lean.Elab.Term.Do.ToTerm.Kind → Sort u} →
(t : Lean.Elab.Term.Do.ToTerm.Kind) → t.ctorIdx = 1 → motive Lean.Elab.Term.Do.ToTerm.Kind.forIn → motive t | null | false |
Lean.Import.mk.injEq | Lean.Setup | ∀ (module : Lean.Name) (importAll isExported isMeta : Bool) (module_1 : Lean.Name)
(importAll_1 isExported_1 isMeta_1 : Bool),
({ module := module, importAll := importAll, isExported := isExported, isMeta := isMeta } =
{ module := module_1, importAll := importAll_1, isExported := isExported_1, isMeta := isMet... | null | true |
_private.Mathlib.Data.List.Interleave.0.List.interleaves_ofFn_even._proof_1_81 | Mathlib.Data.List.Interleave | ∀ {n : ℕ} (i : ℕ), 2 * i + 4 ≤ 2 * n → 2 * i + 2 < 2 * n | null | false |
CategoryTheory.Limits.colimit.toCostructuredArrow | Mathlib.CategoryTheory.Limits.ConeCategory | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasColimit F] →
CategoryTheory.Functor J (CategoryTheory.CostructuredArrow F (Categor... | If `F` has a colimit, then the colimit inclusions can be interpreted as costructured arrows
`F.obj - ⟶ colimit F`. | true |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.part_mem._simp_1_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (l : Finset α) (hp : ∃! a, a ∈ l ∧ p a),
(Finset.choose p l hp ∈ l) = True | null | false |
DirichletCharacter.conductor_mul_dvd_lcm_conductor | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} (χ ψ : DirichletCharacter R n),
(χ * ψ).conductor ∣ χ.conductor.lcm ψ.conductor | The conductor of `χ * ψ` divides the lcm of the conductors of `χ` and `ψ`. | true |
Mathlib.Tactic.Linarith.CompSource.noConfusionType | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | Sort u → Mathlib.Tactic.Linarith.CompSource → Mathlib.Tactic.Linarith.CompSource → Sort u | null | false |
_private.Std.Tactic.Do.Syntax.0.Lean.Parser.Tactic.instReprMCasesPat.repr.match_1 | Std.Tactic.Do.Syntax | (motive : Lean.Parser.Tactic.MCasesPat → Sort u_1) →
(x : Lean.Parser.Tactic.MCasesPat) →
((a : Lean.TSyntax `Lean.binderIdent) → motive (Lean.Parser.Tactic.MCasesPat.one a)) →
(Unit → motive Lean.Parser.Tactic.MCasesPat.clear) →
((a : List Lean.Parser.Tactic.MCasesPat) → motive (Lean.Parser.Tactic.... | null | false |
Qq.Impl.MVarSynth.term.elim | Qq.Macro | {motive : Qq.Impl.MVarSynth → Sort u} →
(t : Qq.Impl.MVarSynth) →
t.ctorIdx = 0 →
((quotedType : Lean.Expr) →
(unquotedMVar : Lean.MVarId) → motive (Qq.Impl.MVarSynth.term quotedType unquotedMVar)) →
motive t | null | false |
Filter.map_add_atTop_eq_nat | Mathlib.Order.Filter.AtTopBot.Basic | ∀ (k : ℕ), Filter.map (fun a => a + k) Filter.atTop = Filter.atTop | null | true |
IsLUB.inter_Ici_of_mem | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : LinearOrder γ] {s : Set γ} {a b : γ}, IsLUB s a → b ∈ s → IsLUB (s ∩ Set.Ici b) a | null | true |
Setoid.mapOfSurjective_eq_map | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : Setoid α} {f : α → β} (h : Setoid.ker f ≤ r) (hf : Function.Surjective f),
r.map f = r.mapOfSurjective f h hf | A special case of the equivalence closure of an equivalence relation r equaling r. | true |
Std.Iterators.ProductivenessRelation.mk.noConfusion | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{inst : Std.Iterator α m β} →
{P : Sort u} →
{Rel : Std.IterM m β → Std.IterM m β → Prop} →
{wf : WellFounded Rel} →
{subrelation : ∀ {it it' : Std.IterM m β}, it'.IsPlausibleSkipSuccessorOf it → Rel it' it} →... | null | false |
ZeroAtInftyContinuousMap.instIsCentralScalar | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β] {R : Type u_2}
[inst_3 : Zero R] [inst_4 : SMulWithZero R β] [inst_5 : SMulWithZero Rᵐᵒᵖ β] [inst_6 : ContinuousConstSMul R β]
[inst_7 : IsCentralScalar R β], IsCentralScalar R (ZeroAtInftyContinuousMap α β) | null | true |
_private.Mathlib.Data.Finset.Union.0.Finset.mem_disjiUnion._simp_1_1 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ s) = (a ∈ s.val) | null | false |
CategoryTheory.instAbelianOpposite._proof_4 | Mathlib.CategoryTheory.Abelian.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
CategoryTheory.Limits.HasKernels Cᵒᵖ | null | false |
NonUnitalSubsemiring.toSubsemiring | Mathlib.Algebra.Ring.Subsemiring.Defs | {R : Type u} → [inst : NonAssocSemiring R] → (S : NonUnitalSubsemiring R) → 1 ∈ S → Subsemiring R | Turn a non-unital subsemiring containing `1` into a subsemiring. | true |
exists_nonarchimedean_pow_mul_seminorm_of_finiteDimensional | Mathlib.Analysis.Normed.Unbundled.FiniteExtension | ∀ {K : Type u_1} {L : Type u_2} [inst : NormedField K] [inst_1 : Field L] [inst_2 : Algebra K L],
FiniteDimensional K L →
IsNonarchimedean norm → ∃ f, IsPowMul ⇑f ∧ (∀ (x : K), f ((algebraMap K L) x) = ‖x‖) ∧ IsNonarchimedean ⇑f | If `K` is a nonarchimedean normed field `L/K` is a finite extension, then there exists a
power-multiplicative nonarchimedean `K`-algebra norm on `L` extending the norm on `K`. | true |
CategoryTheory.CosimplicialObject.δ_comp_σ_self'_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ}
{j : Fin (n + 2)} {i : Fin (n + 1)},
j = i.castSucc →
∀ {Z : C} (h : X.obj { len := n } ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.δ j) (CategoryTheory.CategoryStruct.comp (X.σ i) h) = h | null | true |
Std.Time.Internal.UnitVal.recOn | Std.Time.Internal.UnitVal | {α : ℚ} →
{motive : Std.Time.Internal.UnitVal α → Sort u} →
(t : Std.Time.Internal.UnitVal α) → ((val : ℤ) → motive { val := val }) → motive t | null | false |
CategoryTheory.ObjectProperty.InheritedFromSource.of_hom_of_source | Mathlib.CategoryTheory.ObjectProperty.InheritedFromHom | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {P : CategoryTheory.ObjectProperty C}
{Q : CategoryTheory.MorphismProperty C} [self : P.InheritedFromSource Q] {X Y : C} (f : X ⟶ Y), Q f → P X → P Y | null | true |
CategoryTheory.Adjunction.compYonedaIso_hom_app_app_hom_apply | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (X : D) (X_1 : Cᵒᵖ)
(x : Opposite.unop X_1 ⟶ G.obj X),
(CategoryTheory.ConcreteCategory.hom ((adj.compYonedaIso.ho... | null | true |
Vector.isNone_finIdxOf? | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] [PartialEquivBEq α] {v : Vector α n} {a : α},
(v.finIdxOf? a).isNone = !v.contains a | null | true |
TypeCat.hom_ofHom | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} (f : X → Y), TypeCat.Hom.hom (TypeCat.ofHom f) = { toFun := f } | null | true |
SetLike.exists_of_lt | Mathlib.Basic.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : Membership B A] [inst_1 : Preorder A] [IsConcreteLE A B] {p q : A},
p < q → ∃ x ∈ q, x ∉ p | **Alias** of `IsConcreteLE.exists_of_lt`. | true |
ConjAct.Subgroup.val_conj_smul | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ {G : Type u_3} [inst : Group G] {H : Subgroup G} [inst_1 : H.Normal] (g : ConjAct G) (h : ↥H), ↑(g • h) = g • ↑h | null | true |
OpenPartialHomeomorph.MDifferentiable | Mathlib.Geometry.Manifold.MFDeriv.Defs | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
ModelWithCorners 𝕜 E H →
{M : Type u_4} →
[... | Prop registering if an open partial homeomorphism is a local diffeomorphism on its source | true |
localCohomology.ringModIdeals_obj_carrier | Mathlib.Algebra.Homology.LocalCohomology | ∀ {R : Type u} [inst : CommRing R] {D : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} D]
(I : CategoryTheory.Functor D (Ideal R)) (t : D), ↑((localCohomology.ringModIdeals I).obj t) = (R ⧸ I.obj t) | null | true |
HasFibers.Fib.isoMk | Mathlib.CategoryTheory.FiberedCategory.HasFibers | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳] →
{p : CategoryTheory.Functor 𝒳 𝒮} →
[inst_2 : HasFibers p] →
{S : 𝒮} →
{a b : HasFibers.Fib p S} →
(Φ : (HasFibers.ι... | The lift of an isomorphism `Φ : (ι S).obj a ≅ (ι S).obj b` lying over `𝟙 S` to an isomorphism
in `Fib S`. | true |
groupCohomology.isoCocycles₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] → (A : Rep.{u, u, u} k G) → groupCohomology.cocycles A 1 ≅ ↧↥(groupCohomology.cocycles₁ A) | The 1-cocycles of the complex of inhomogeneous cochains of `A` are isomorphic to
`cocycles₁ A`, which is a simpler type. | true |
RightCancelSemigroup.ctorIdx | Mathlib.Algebra.Group.Semigroup | {G : Type u_2} → RightCancelSemigroup G → ℕ | null | false |
Set.inter_eq_right | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, s ∩ t = t ↔ t ⊆ s | null | true |
Metric.unitSphere.instCommMonoid._proof_1 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : SeminormedCommRing 𝕜] [inst_1 : NormMulClass 𝕜] [inst_2 : NormOneClass 𝕜]
(a b : ↑(Metric.sphere 0 1)), a * b = b * a | null | false |
AddCancelMonoid.toIsCancelAdd | Mathlib.Algebra.Group.Monoid | ∀ (M : Type u_2) [inst : AddCancelMonoid M], IsCancelAdd M | Any `AddCancelMonoid G` satisfies `IsCancelAdd G`. | true |
_private.Mathlib.FieldTheory.Finite.Valuation.0.FiniteField.valuation_algebraMap_le_one._proof_1_1 | Mathlib.FieldTheory.Finite.Valuation | ∀ {Fq : Type u_3} {A : Type u_2} {Γ : Type u_1} [inst : Field Fq] [inst_1 : Ring A] [inst_2 : Algebra Fq A]
[inst_3 : LinearOrderedCommMonoidWithZero Γ] (v : Valuation A Γ) (a : Fq), a = 0 → v ((algebraMap Fq A) a) ≤ 1 | null | false |
CategoryTheory.Limits.IsInitial.equivOfIso.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (e : X ≅ Y),
CategoryTheory.Limits.IsInitial.equivOfIso e =
{ toFun := fun h => h.ofIso e, invFun := fun h => h.ofIso e.symm, left_inv := ⋯, right_inv := ⋯ } | null | true |
AddCon.instDecidableEqQuotientOfDecidableCoeForallProp | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} → [inst : Add M] → (c : AddCon M) → [(a b : M) → Decidable (c a b)] → DecidableEq c.Quotient | The quotient by a decidable additive congruence relation has decidable equality. | true |
CategoryTheory.SmallObject.SuccStruct.ιIterationFunctor | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Φ : CategoryTheory.SmallObject.SuccStruct C) →
(J : Type w) →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
[inst_5 : CategoryThe... | The natural map `Φ.X₀ ⟶ (Φ.iterationFunctor J).obj j`. | true |
CategoryTheory.ObjectProperty.prop_X₁_of_shortExact | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderSubobjects] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex C},
S.ShortExact → P S.X₂ → P S.X₁ | null | true |
WithTop.zero.eq_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α], WithTop.zero = { zero := ↑0 } | null | true |
Polynomial.IsDistinguishedAt.casesOn | Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished | {R : Type u_1} →
[inst : CommRing R] →
{f : Polynomial R} →
{I : Ideal R} →
{motive : f.IsDistinguishedAt I → Sort u} →
(t : f.IsDistinguishedAt I) →
((toIsWeaklyEisensteinAt : f.IsWeaklyEisensteinAt I) → (monic : f.Monic) → motive ⋯) → motive t | null | false |
Lean.Elab.Tactic.withMacroExpansion | Lean.Elab.Tactic.Basic | {α : Type} → Lean.Syntax → Lean.Syntax → Lean.Elab.Tactic.TacticM α → Lean.Elab.Tactic.TacticM α | Elaborate `x` with `stx` on the macro stack | true |
Measure.eq_prod_of_integral_mul_boundedContinuousFunction | Mathlib.MeasureTheory.Measure.HasOuterApproxClosedProd | ∀ {Z : Type u_3} {T : Type u_4} {mZ : MeasurableSpace Z} [inst : TopologicalSpace Z] [BorelSpace Z]
[HasOuterApproxClosed Z] {mT : MeasurableSpace T} [inst_3 : TopologicalSpace T] [BorelSpace T]
[HasOuterApproxClosed T] {μ : MeasureTheory.Measure Z} {ν : MeasureTheory.Measure T}
{ξ : MeasureTheory.Measure (Z × T)... | The product of two finite measures `μ` and `ν` is the only finite measure `ξ` such that
for all real bounded continuous functions `f` and `g` we have
`∫ z, f z.1 * g z.2 ∂ξ = ∫ x, f x ∂μ * ∫ y, g y ∂ν`. | true |
RingTheory.Sequence.IsWeaklyRegular.recIterModByRegularWithRing._unary._proof_29 | Mathlib.RingTheory.Regular.RegularSequence | ∀
(_x :
(x : Type u_1) ×'
(x_1 : CommRing x) ×'
(x_2 : Type u_2) ×'
(x_3 : AddCommGroup x_2) ×'
(x_4 : Module x x_2) ×' (x_5 : List x) ×' RingTheory.Sequence.IsWeaklyRegular x_2 x_5),
RingTheory.Sequence.IsWeaklyRegular _x.2.2.1 _x.2.2.2.2.2.1 | null | false |
Prod.map_comp_swap | Init.Data.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ),
Prod.map f g ∘ Prod.swap = Prod.swap ∘ Prod.map g f | For two functions `f` and `g`, the composition of `Prod.map f g` with `Prod.swap`
is equal to the composition of `Prod.swap` with `Prod.map g f`.
| true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Char.0.String.Slice.startsWith_char_eq_head?._simp_1_8 | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {l₁ l₂ : List Char}, (l₁ = l₂) = (String.ofList l₁ = String.ofList l₂) | null | false |
Std.ExtTreeMap.contains_unitOfList | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : BEq α] [Std.LawfulBEqCmp cmp] {l : List α}
{k : α}, (Std.ExtTreeMap.unitOfList l cmp).contains k = l.contains k | null | true |
Lean.Compiler.LCNF.Simp.ConstantFold.applyFolders | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure →
Lean.SMap Lean.Name Lean.Compiler.LCNF.Simp.ConstantFold.Folder →
Lean.Compiler.LCNF.CompilerM (Option (Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure))) | Apply all known folders to `decl`.
| true |
MeasureTheory.VectorMeasure.semivariation_union_le | Mathlib.MeasureTheory.VectorMeasure.Variation.Semivariation | ∀ {X : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {mX : MeasurableSpace X}
{μ : MeasureTheory.VectorMeasure X E} {s t : Set X}, μ.semivariation (s ∪ t) ≤ μ.semivariation s + μ.semivariation t | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.