name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matrix.normedAddCommGroup | Mathlib.Analysis.Matrix.Normed | {m : Type u_3} →
{n : Type u_4} →
{α : Type u_5} → [Fintype m] → [Fintype n] → [NormedAddCommGroup α] → NormedAddCommGroup (Matrix m n α) | Normed group instance (using sup norm of sup norm) for matrices over a normed group. Not
declared as an instance because there are several natural choices for defining the norm of a
matrix. | true |
List.Vector.«_aux_Mathlib_Data_Vector_Basic___macroRules_List_Vector_term_::ᵥ__1» | Mathlib.Data.Vector.Basic | Lean.Macro | null | false |
_private.Mathlib.Tactic.ClickSuggestions.GRewrite.0.Mathlib.Tactic.ClickSuggestions.dummyDischarger._sparseCasesOn_5 | Mathlib.Tactic.ClickSuggestions.GRewrite | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
Finset.Ico_subset_Ici_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] [inst_2 : LocallyFiniteOrder α],
Finset.Ico a b ⊆ Finset.Ici a | null | true |
ContinuousOn.image_Icc_of_antitoneOn | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
[OrderTopology α] [inst_3 : TopologicalSpace β] [DenselyOrdered α] [inst_5 : ConditionallyCompleteLinearOrder β]
[OrderTopology β] {f : α → β} {a b : α},
a ≤ b → ContinuousOn f (Set.Icc a b) → AntitoneOn f (S... | null | true |
LieAlgebra.IsExtension.casesOn | Mathlib.Algebra.Lie.Extension | {R : Type u_1} →
{N : Type u_2} →
{L : Type u_3} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : LieRing N] →
[inst_4 : LieAlgebra R N] →
[inst_5 : LieRing M] →
... | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Rename.0.MvPowerSeries.renameFunAuxImage.match_1 | Mathlib.RingTheory.MvPowerSeries.Rename | {σ : Type u_2} →
{τ : Type u_1} →
(motive : ((τ →₀ ℕ) × (τ →₀ ℕ)) × (σ →₀ ℕ) × (σ →₀ ℕ) → Sort u_3) →
(x : ((τ →₀ ℕ) × (τ →₀ ℕ)) × (σ →₀ ℕ) × (σ →₀ ℕ)) →
((fst : (τ →₀ ℕ) × (τ →₀ ℕ)) → (b : (σ →₀ ℕ) × (σ →₀ ℕ)) → motive (fst, b)) → motive x | null | false |
Polynomial.reflect.match_1 | Mathlib.Algebra.Polynomial.Reverse | {R : Type u_1} →
[inst : Semiring R] →
(motive : Polynomial R → Sort u_2) →
(x : Polynomial R) → ((f : AddMonoidAlgebra R ℕ) → motive { toFinsupp := f }) → motive x | null | false |
FiniteMulArchimedeanClass.closedBallSubgroup | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} →
[inst : CommGroup M] →
[inst_1 : LinearOrder M] → [inst_2 : IsOrderedMonoid M] → FiniteMulArchimedeanClass M → Subgroup M | A closed ball defined by `FiniteMulArchimedeanClass.subgroup` of `UpperSet.Ici c`. | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.ErrorContext.mk.sizeOf_spec | Mathlib.Tactic.Linter.TextBased | ∀ (error : Mathlib.Linter.TextBased.StyleError✝) (lineNumber : ℕ) (path : System.FilePath),
sizeOf { error := error, lineNumber := lineNumber, path := path } = 1 + sizeOf error + sizeOf lineNumber + sizeOf path | null | true |
cfcHom_predicate | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R ... | null | true |
_private.Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra.0.Module.FaithfullyFlat.faithfulSMul._simp_1 | Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b | null | false |
_private.Init.Data.List.ToArray.0.List.findSomeRevM?_find_toArray | Init.Data.List.ToArray | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] (f : α → m (Option β))
(l : List α) (i : ℕ) (h : i ≤ l.toArray.size),
Array.findSomeRevM?.find✝ f l.toArray i h = List.findSomeM? f (List.take i l).reverse | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.inner_eq_norm_mul_norm_mul_cos_oangle._simp_1_7 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Std.BundledIterM.casesOn | Std.Data.Iterators.Lemmas.Equivalence.Basic | {m : Type w → Type w'} →
{β : Type w} →
{motive : Std.BundledIterM m β → Sort u} →
(t : Std.BundledIterM m β) →
((α : Type w) →
(inst : Std.Iterator α m β) →
(iterator : Std.IterM m β) → motive { α := α, inst := inst, iterator := iterator }) →
motive t | null | false |
CategoryTheory.EnrichedOrdinaryCategory.casesOn | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | {V : Type u'} →
[inst : CategoryTheory.Category.{v', u'} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.EnrichedOrdinaryCategory V C → Sort u_1} →
(t : CategoryTheory.EnrichedOrdinaryCate... | null | false |
Ideal.ramificationIdx_eq_one_of_isUnramifiedAt | Mathlib.NumberTheory.RamificationInertia.Unramified | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal S}
[inst_3 : p.IsPrime] [IsNoetherianRing S] [Algebra.IsUnramifiedAt R p],
p ≠ ⊥ → ∀ [IsDomain S] [Algebra.EssFiniteType R S], (Ideal.under R p).ramificationIdx p = 1 | null | true |
ContinuousLinearEquiv.submoduleMap._proof_2 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid M₂] [inst_5 : TopologicalSpace M₂]
{module_M : Module R M} {module_M₂ : Module R₂ M₂} {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : ... | null | false |
IsCompactOperator.restrict | Mathlib.Analysis.Normed.Operator.Compact.Basic | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_3} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] {f : M₁ →ₗ[R₁] M₁},
IsCompactOperator ⇑f →
∀ {V : Submodule R₁ M₁} (hV : ∀ v ∈ V, f v ∈ V), IsClosed ↑V → IsCompactOperator ⇑(f.restrict hV) | If a compact operator preserves a closed submodule, its restriction to that submodule is
compact.
Note that, following mathlib's convention in linear algebra, `restrict` designates the restriction
of an endomorphism `f : E →ₗ E` to an endomorphism `f' : ↥V →ₗ ↥V`. To prove that the restriction
`f' : ↥U →ₛₗ ↥V` of a co... | true |
_private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix._aux_Mathlib_NumberTheory_SiegelsLemma___macroRules__private_Mathlib_NumberTheory_SiegelsLemma_0_Int_Matrix_termB_1 | Mathlib.NumberTheory.SiegelsLemma | Lean.Macro | null | false |
apply_dite | Init.ByCases | ∀ {α : Sort u_1} {β : Sort u_2} (f : α → β) (P : Prop) [inst : Decidable P] (x : P → α) (y : ¬P → α),
f (dite P x y) = if h : P then f (x h) else f (y h) | A function applied to a `dite` is a `dite` of that function applied to each of the branches. | true |
Rat.num_divInt_den | Init.Data.Rat.Lemmas | ∀ (a : ℚ), Rat.divInt a.num ↑a.den = a | null | true |
Matrix.normedAddCommGroup._proof_6 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : NormedAddCommGroup α],
autoParam ((Bornology.cobounded (Matrix m n α)).sets = {s | ∃ C, ∀ x ∈ sᶜ, ∀ y ∈ sᶜ, dist x y ≤ C})
PseudoMetricSpace.cobounded_sets._autoParam | null | false |
PosNum.cast_one | Mathlib.Data.Num.Lemmas | ∀ {α : Type u_1} [inst : One α] [inst_1 : Add α], ↑1 = 1 | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_105 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
hnot_top | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α], ￢⊤ = ⊥ | null | true |
CategoryTheory.MorphismProperty.IsMonoidalStable.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.MorphismProperty C}
[inst_1 : CategoryTheory.MonoidalCategory C],
(∀ (X : C), P (CategoryTheory.CategoryStruct.id X)) →
(∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), P f → P g → P (CategoryTheory.CategoryStruct.comp f g)) →
(∀ (X... | null | false |
Matrix.mul_one | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(M : Matrix m n α), M * 1 = M | null | true |
CommSemiRingCat.forget_preservesLimits | Mathlib.Algebra.Category.Ring.Limits | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommSemiRingCat) | null | true |
finprod_mem_eq_prod | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M) {s : Set α} (hf : (s ∩ Function.mulSupport f).Finite),
∏ᶠ (i : α) (_ : i ∈ s), f i = ∏ i ∈ hf.toFinset, f i | null | true |
Nat.eq_zero_of_lcm_eq_zero | Init.Data.Nat.Lcm | ∀ {m n : ℕ}, m.lcm n = 0 → m = 0 ∨ n = 0 | null | true |
Std.IterM.TerminationMeasures.Productive.casesOn | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{motive : Std.IterM.TerminationMeasures.Productive α m → Sort u} →
(t : Std.IterM.TerminationMeasures.Productive α m) → ((it : Std.IterM m β) → motive { it := it }) → motive t | null | false |
Module.Basis.coe_toOrthonormalBasis | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (v : Module.Basis ι 𝕜 E) (hv : Orthonormal 𝕜 ⇑v),
⇑(v.toOrthonormalBasis hv) = ⇑v | null | true |
Monoid.End.ext | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : MulOne M] {f g : Monoid.End M}, (∀ (x : M), f x = g x) → f = g | null | true |
ContDiffMapSupportedIn.zero_on_compl | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
Set.EqOn (⇑f) 0 (↑K)ᶜ | null | true |
CategoryTheory.Functor.leftExtensionEquivalenceOfIso₁_unitIso_hom_app_right_app | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
{L L' : CategoryTheory.Functor C D} (iso₁ : L ≅ L') (F : CategoryTheory.Functor C H)
(X : CategoryTheory.Comma (CategoryTheor... | null | true |
Height.fun_logHeight_one | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2},
(Height.logHeight fun x => 1) = 0 | Eta-expanded form of `Height.logHeight_one` | true |
Set.image2_inter_union_subset | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {f : α → α → β} {s t : Set α},
(∀ (a b : α), f a b = f b a) → Set.image2 f (s ∩ t) (s ∪ t) ⊆ Set.image2 f s t | null | true |
_private.Mathlib.Geometry.Manifold.IntegralCurve.UniformTime.0.exists_isMIntegralCurve_of_isMIntegralCurveOn._simp_1_1 | Mathlib.Geometry.Manifold.IntegralCurve.UniformTime | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioo a b) = (a < x ∧ x < b) | null | false |
HomologicalComplex.restriction.congr_simp | Mathlib.Algebra.Homology.Embedding.TruncLEHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K K_1 : HomologicalComplex C c'),
K = K_1 → ∀ (e e_1 : c.Embedding c') (e_e : e = e_1) [inst_2 : e.IsRelIff], K.restriction... | null | true |
Aesop.CasesTarget.ctorElimType | Aesop.RuleTac.Basic | {motive : Aesop.CasesTarget → Sort u} → ℕ → Sort (max 1 u) | null | false |
Set.Icc_add_Ico_subset | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Add α] [inst_1 : PartialOrder α] [AddLeftStrictMono α] [AddRightStrictMono α] (a b c d : α),
Set.Icc a b + Set.Ico c d ⊆ Set.Ico (a + c) (b + d) | null | true |
IsSMulRegular.mul | Mathlib.Algebra.Regular.SMul | ∀ {R : Type u_1} {M : Type u_3} {a b : R} [inst : SMul R M] [inst_1 : Mul R] [IsScalarTower R R M],
IsSMulRegular M a → IsSMulRegular M b → IsSMulRegular M (a * b) | null | true |
Lean.Grind.Linarith.instBEqPoly.beq._sunfold | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Bool | null | false |
WithAbs.instRing._proof_3 | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Ring R] (v : AbsoluteValue R S),
autoParam
(∀ (n : ℕ) (a : WithAbs v),
(WithAbs.equiv v).symm.1 (↑n.succ • (WithAbs.equiv v).toEquiv a) =
(WithAbs.equiv v).symm.1 (↑n • (WithAbs.equiv v).toEquiv a) + a)
SubNe... | null | false |
Con.monoid._proof_4 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Monoid M] (c : Con M),
autoParam
(∀ (n : ℕ) (x : c.Quotient), Quotient.map' (fun x => x ^ (n + 1)) ⋯ x = Quotient.map' (fun x => x ^ n) ⋯ x * x)
Monoid.npow_succ._autoParam | null | false |
TopologicalSpace.le_generateFrom_iff_subset_isOpen | Mathlib.Topology.Order | ∀ {α : Type u} {g : Set (Set α)} {t : TopologicalSpace α}, t ≤ TopologicalSpace.generateFrom g ↔ g ⊆ {s | IsOpen s} | null | true |
DomMulAct.instDistribMulActionSubtypeAEEqFunMemAddSubgroupLp | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | {M : Type u_1} →
{α : Type u_3} →
{E : Type u_4} →
[inst : MeasurableSpace α] →
[inst_1 : NormedAddCommGroup E] →
{μ : MeasureTheory.Measure α} →
{p : ENNReal} →
[inst_2 : Monoid M] →
[inst_3 : MulAction M α] →
[MeasureTheory.SMul... | null | true |
Lean.Meta.Sym.Simp.simpForall' | Lean.Meta.Sym.Simp.Forall | Lean.Meta.Sym.Simp.Simproc → Lean.Meta.Sym.Simp.Simproc → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | null | true |
Fin.castSucc_pos | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {i : Fin n}, 0 < i → 0 < i.castSucc | `castSucc i` is positive when `i` is positive | true |
IsIsometricSMul.mk._flat_ctor | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X],
(∀ (c : M), Isometry fun x => c • x) → IsIsometricSMul M X | null | false |
Std.PRange.UpwardEnumerable.least | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u_1} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.Least? α] → [Std.PRange.LawfulUpwardEnumerableLeast? α] → [hn : Nonempty α] → α | null | true |
ProbabilityTheory.HasGaussianLaw.charFunDual_map_eq | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E] (L : StrongDual ℝ E),
ProbabilityTheory.HasGaussianLaw X P →
MeasureTheory.charFunDual (MeasureTheory.Measure.ma... | null | true |
CategoryTheory.Limits.IsLimit.assoc._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {sXY : CategoryTheory.Limits.BinaryFan X Y}
{sYZ : CategoryTheory.Limits.BinaryFan Y Z} (P : CategoryTheory.Limits.IsLimit sXY)
(Q : CategoryTheory.Limits.IsLimit sYZ) {s : CategoryTheory.Limits.BinaryFan sXY.pt Z}
(R : CategoryTheory.Limi... | null | false |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestMatchAt_iff_splits._simp_1_1 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos₁ pos₂ : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt pat pos₁ pos₂ = ∃ (h : pos₁ ≤ pos₂), (s.slice pos₁ pos₂ h).copy = pat.copy | null | false |
Sym.map_mk._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_2} {β : Type u_1} {n : ℕ} {f : α → β} {m : Multiset α} {hc : m.card = n}, (Multiset.map f m).card = n | null | false |
MultilinearMap.mkContinuous_norm_le | 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 : MultilinearMap 𝕜 E G)
{C : ℝ}, 0 ≤... | If a continuous multilinear map is constructed from a multilinear map via the constructor
`mkContinuous`, then its norm is bounded by the bound given to the constructor if it is
nonnegative. | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalReplace.match_1 | Lean.Elab.Tactic.BuiltinTactic | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) →
((ldecl : Lean.LocalDecl) → motive (some ldecl)) → ((x : Option Lean.LocalDecl) → motive x) → motive x | null | false |
Function.HasTemperateGrowth.toTemperedDistribution._proof_6 | Mathlib.Analysis.Distribution.TemperedDistribution | RingHomCompTriple (RingHom.id ℂ) (RingHom.id ℂ) (RingHom.id ℂ) | null | false |
Mathlib.Tactic.Linarith.applyContrLemma | Mathlib.Tactic.Linarith.Frontend | Lean.MVarId → Lean.MetaM (Option (Lean.Expr × Lean.Expr) × Lean.MVarId) | `applyContrLemma` inspects the target to see if it can be moved to a hypothesis by negation.
For example, a goal `⊢ a ≤ b` can become `b < a ⊢ false`.
If this is the case, it applies the appropriate lemma and introduces the new hypothesis.
It returns the type of the terms in the comparison (e.g. the type of `a` and `b`... | true |
Pi.spectrum_eq | Mathlib.Algebra.Algebra.Spectrum.Pi | ∀ {ι : Type u_1} {R : Type u_4} {κ : ι → Type u_5} [inst : CommSemiring R] [inst_1 : (i : ι) → Ring (κ i)]
[inst_2 : (i : ι) → Algebra R (κ i)] (a : (i : ι) → κ i), spectrum R a = ⋃ i, spectrum R (a i) | null | true |
ProofWidgets.RefreshComponent.RefreshState.recOn | ProofWidgets.Component.RefreshComponent | {motive : ProofWidgets.RefreshComponent.RefreshState → Sort u} →
(t : ProofWidgets.RefreshComponent.RefreshState) →
((curr : Thunk ProofWidgets.Html) →
(idx : ℕ) → (next : Task (Option Unit)) → motive { curr := curr, idx := idx, next := next }) →
motive t | null | false |
Path.Homotopic.Quotient.symm | Mathlib.Topology.Homotopy.Path | {X : Type u} → [inst : TopologicalSpace X] → {x₀ x₁ : X} → Path.Homotopic.Quotient x₀ x₁ → Path.Homotopic.Quotient x₁ x₀ | The reverse of a path homotopy class. This is `Path.symm` descended to the quotient. | true |
CategoryTheory.ComposableArrows.sc'._auto_1 | Mathlib.Algebra.Homology.ExactSequence | Lean.Syntax | null | false |
CategoryTheory.Limits.FormalCoproduct.powerMap_id | Mathlib.CategoryTheory.Limits.FormalCoproducts.Cech | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Limits.FormalCoproduct C) (α : Type t)
[inst_1 : CategoryTheory.Limits.HasProductsOfShape α C],
CategoryTheory.Limits.FormalCoproduct.powerMap (CategoryTheory.CategoryStruct.id U) α =
CategoryTheory.CategoryStruct.id (U.power α) | null | true |
Lean.«binderPred⊃_» | Init.BinderPredicates | Lean.ParserDescr | Declare `∀ x ⊃ y, ...` as syntax for `∀ x, x ⊃ y → ...` and `∃ x ⊃ y, ...` as syntax for
`∃ x, x ⊃ y ∧ ...` | true |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.getRecommendedSpellingsForName.match_4 | Lean.Parser.Term.Doc | (motive : Option (Array Lean.Parser.Term.Doc.RecommendedSpelling) → Sort u_1) →
(x : Option (Array Lean.Parser.Term.Doc.RecommendedSpelling)) →
((strs : Array Lean.Parser.Term.Doc.RecommendedSpelling) → motive (some strs)) →
((x : Option (Array Lean.Parser.Term.Doc.RecommendedSpelling)) → motive x) → motive... | null | false |
QuadraticModuleCat.instMonoidalCategory | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | {R : Type u} → [inst : CommRing R] → [Invertible 2] → CategoryTheory.MonoidalCategory (QuadraticModuleCat R) | null | true |
Subgroup.mem_goursatSnd | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] {I : Subgroup (G × H)} {h : H},
h ∈ I.goursatSnd ↔ (1, h) ∈ I | null | true |
CategoryTheory.InjectiveResolution.isoRightDerivedObj_hom_naturality_assoc | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasInjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X)
(J : ... | null | true |
groupCohomology.H1IsoOfIsTrivial.congr_simp | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) [inst_2 : A.IsTrivial],
groupCohomology.H1IsoOfIsTrivial A = groupCohomology.H1IsoOfIsTrivial A | null | true |
Lean.Elab.Term.CollectPatternVars.Context.casesOn | Lean.Elab.PatternVar | {motive : Lean.Elab.Term.CollectPatternVars.Context → Sort u} →
(t : Lean.Elab.Term.CollectPatternVars.Context) →
((funId : Lean.Ident) →
(ctorVal? : Option Lean.ConstructorVal) →
(explicit ellipsis : Bool) →
(paramDecls : Array (Lean.Name × Lean.BinderInfo)) →
(paramDe... | null | false |
Lean.Lsp.InitializeParams.processId?._default | Lean.Data.Lsp.InitShutdown | Option ℤ | null | false |
MonoidAlgebra.ext | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] ⦃f g : MonoidAlgebra R M⦄, (∀ (m : M), f m = g m) → f = g | A copy of `Finsupp.ext` for `MonoidAlgebra`. | true |
ContinuousMultilinearMap.opNorm_prod | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} {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 : SeminormedAddCommGroup G']
[inst_6 ... | null | true |
Std.DHashMap.Raw.getKeyD_insertIfNew | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a fallback : α} {v : β k},
(m.insertIfNew k v).getKeyD a fallback = if (k == a) = true ∧ k ∉ m then k else m.getKeyD a fallback | null | true |
AddMonoidAlgebra.singleZeroAlgHom.eq_1 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddMonoid M],
AddMonoidAlgebra.singleZeroAlgHom = { toRingHom := AddMonoidAlgebra.singleZeroRingHom, commutes' := ⋯ } | null | true |
CategoryTheory.HasDetector.recOn | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.HasDetector C → Sort u} →
(t : CategoryTheory.HasDetector C) → ((hasDetector : ∃ G, CategoryTheory.IsDetector G) → motive ⋯) → motive t | null | false |
Std.Rci.mk.inj | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} {lower lower_1 : α}, lower...* = lower_1...* → lower = lower_1 | null | true |
ContinuousAlgEquiv.isUniformEmbedding | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} [inst : CommSemiring R] {E₁ : Type u_5} {E₂ : Type u_6} [inst_1 : UniformSpace E₁]
[inst_2 : UniformSpace E₂] [inst_3 : Ring E₁] [IsUniformAddGroup E₁] [inst_5 : Algebra R E₁] [inst_6 : Ring E₂]
[IsUniformAddGroup E₂] [inst_8 : Algebra R E₂] (e : E₁ ≃A[R] E₂), IsUniformEmbedding ⇑e | null | true |
RootedTree.mk.injEq | Mathlib.Order.SuccPred.Tree | ∀ (α : Type u_2) [semilatticeInf : SemilatticeInf α] [orderBot : OrderBot α] [predOrder : PredOrder α]
[isPredArchimedean : IsPredArchimedean α] (α_1 : Type u_2) (semilatticeInf_1 : SemilatticeInf α_1)
(orderBot_1 : OrderBot α_1) (predOrder_1 : PredOrder α_1) (isPredArchimedean_1 : IsPredArchimedean α_1),
({ α :=... | null | true |
Lean.Kernel.Exception.unknownConstant.inj | Lean.Environment | ∀ {env : Lean.Kernel.Environment} {name : Lean.Name} {env_1 : Lean.Kernel.Environment} {name_1 : Lean.Name},
Lean.Kernel.Exception.unknownConstant env name = Lean.Kernel.Exception.unknownConstant env_1 name_1 →
env = env_1 ∧ name = name_1 | null | true |
Ideal.hasBasis_nhds_zero_adic | Mathlib.Topology.Algebra.Nonarchimedean.AdicTopology | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), (nhds 0).HasBasis (fun _n => True) fun n => ↑(I ^ n) | For the `I`-adic topology, the neighborhoods of zero has basis given by the powers of `I`. | true |
Std.DTreeMap.Raw.Const.unitOfList_equiv_foldl | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {l : List α},
(Std.DTreeMap.Raw.Const.unitOfList l cmp).Equiv (List.foldl (fun acc a => acc.insertIfNew a ()) ∅ l) | null | true |
AddCommGroup.primaryComponent._proof_3 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : AddCommGroup G] (p : ℕ) {g : G} (k : ℕ), p ^ k • g = 0 → p ^ k • -g = 0 | null | false |
Unitization.inrNonUnitalAlgHom_toFun | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A] (a : A),
(Unitization.inrNonUnitalAlgHom R A) a = ↑a | null | true |
AbsoluteValue.map_units_intCast | Mathlib.Data.Int.AbsoluteValue | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : CommRing S] [inst_2 : LinearOrder S] [IsStrictOrderedRing S]
[Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ), abv ↑↑x = 1 | null | true |
CategoryTheory.CommGrp.forget₂Grp_obj_X | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommGrp C),
((CategoryTheory.CommGrp.forget₂Grp C).obj A).X = A.X | null | true |
ContDiffBump.noConfusionType | Mathlib.Analysis.Calculus.BumpFunction.Basic | Sort u → {E : Type u_1} → {c : E} → ContDiffBump c → {E' : Type u_1} → {c' : E'} → ContDiffBump c' → Sort u | null | false |
List.foldrM_map | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {α : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : β₁ → β₂} {g : β₂ → α → m α} {l : List β₁} {init : α},
List.foldrM g init (List.map f l) = List.foldrM (fun x y => g (f x) y) init l | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose_map_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u₄} {Y : Type u₅}
[inst_3 : CategoryTheory.Category.{v₄, u... | null | true |
Primrec.cond | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {c : α → Bool} {f g : α → σ},
Primrec c → Primrec f → Primrec g → Primrec fun a => bif c a then f a else g a | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.logMap_expMapBasis._simp_1_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
AddConstMap.«term_→+c[_,_]_» | Mathlib.Algebra.AddConstMap.Basic | Lean.TrailingParserDescr | A bundled map `f : G → H` such that `f (x + a) = f x + b` for all `x`,
denoted as `f : G →+c[a, b] H`.
One can think about `f` as a lift to `G` of a map between two `AddCircle`s. | true |
nat_abs_sum_le | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} (s : Finset ι) (f : ι → ℤ), (∑ i ∈ s, f i).natAbs ≤ ∑ i ∈ s, (f i).natAbs | **Alias** of `Int.natAbs_sum_le`. | true |
_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Code.exists_code._simp_1_17 | Mathlib.Computability.TuringMachine.Config | ∀ {α : Type u_1} {a b : α}, (b ∈ Part.some a) = (b = a) | null | false |
CovariantDerivative.finite_affine_combination._proof_2 | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {M : Type u_3} {V : M → Type u_2}
[inst_1 : (x : M) → AddCommGroup (V x)] [inst_2 : (x : M) → Module 𝕜 (V x)]
[inst_3 : (x : M) → TopologicalSpace (V x)] [∀ (x : M), ContinuousSMul 𝕜 (V x)] (x : M), ContinuousConstSMul 𝕜 (V x) | null | false |
OnePoint.continuousMapMkDiscrete._proof_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_2} [inst_1 : TopologicalSpace Y] [inst_2 : DiscreteTopology X]
(f : X → Y) (y : Y),
Filter.Tendsto f Filter.cofinite (nhds y) →
Filter.Tendsto (⇑{ toFun := f, continuous_toFun := ⋯ }) (Filter.coclosedCompact X) (nhds y) | null | false |
Subsemiring.toIsStrictOrderedRing | Mathlib.Algebra.Ring.Subsemiring.Order | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (s : Subsemiring R),
IsStrictOrderedRing ↥s | A subsemiring of a strict ordered semiring is a strict ordered semiring. | true |
String.Pos.Raw.isValidForSlice_eq_false_iff._simp_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw},
(String.Pos.Raw.isValidForSlice s p = false) = ¬String.Pos.Raw.IsValidForSlice s p | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.