name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.Group.group | Mathlib.Tactic.Group | Lean.ParserDescr | `group` normalizes expressions in multiplicative groups that occur in the goal. `group` does not
assume commutativity, instead using only the group axioms without any information about which group
is manipulated. If the goal is an equality, and after normalization the two sides are equal, `group`
closes the goal.
For ... | true |
CategoryTheory.IsPushout.of_map | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.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) {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z}
[CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Limits.span f g) F],
CategoryTheory.Category... | null | true |
SemiRingCat.semiringObj._aux_8 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J SemiRingCat) →
(j : J) →
ℕ → (F.comp (CategoryTheory.forget SemiRingCat)).obj j → (F.comp (CategoryTheory.forget SemiRingCat)).obj j | null | false |
Std.Time.DateTime.subNanoseconds | Std.Time.Zoned.DateTime | {tz : Std.Time.TimeZone} → Std.Time.DateTime tz → Std.Time.Nanosecond.Offset → Std.Time.DateTime tz | Subtract `Nanosecond.Offset` from a `DateTime`.
| true |
Std.Rxi.HasSize.casesOn | Init.Data.Range.Polymorphic.Basic | {α : Type u} →
{motive : Std.Rxi.HasSize α → Sort u_1} →
(t : Std.Rxi.HasSize α) → ((size : α → ℕ) → motive { size := size }) → motive t | null | false |
List.foldl.match_1.congr_eq_1 | Init.Data.List.MinMaxOn | ∀ {α : Type u_3} {β : Type u_1} (motive : α → List β → Sort u_2) (x : α) (x_1 : List β) (h_1 : (a : α) → motive a [])
(h_2 : (a : α) → (b : β) → (l : List β) → motive a (b :: l)) (a : α),
x = a →
x_1 = [] →
(match x, x_1 with
| a, [] => h_1 a
| a, b :: l => h_2 a b l) ≍
h_1 a | null | true |
_private.Lean.Util.ReplaceLevel.0.Lean.Expr.ReplaceLevelImpl.replaceUnsafeM.match_1 | Lean.Util.ReplaceLevel | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.la... | null | false |
SeparationQuotient.instRing._proof_6 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
Congr!.plausiblyEqualTypes._unsafe_rec | Mathlib.Tactic.CongrExclamation | Lean.Expr → Lean.Expr → optParam ℕ 5 → Lean.MetaM Bool | null | false |
AddEquiv.arrowCongr._proof_3 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M : Type u_4} {N : Type u_1} {P : Type u_3} {Q : Type u_2} [inst : Add P] [inst_1 : Add Q] (f : M ≃ N) (g : P ≃+ Q)
(h k : M → P), (fun n => g ((h + k) (f.symm n))) = (fun n => g (h (f.symm n))) + fun n => g (k (f.symm n)) | null | false |
CategoryTheory.Limits.createsColimitsOfShapeOfCreatesCoequalizersAndCoproducts._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{D : Type u_5} [inst_2 : CategoryTheory.Category.{u_4, u_5} D]
[CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) D]
(G : CategoryTheory.Functor C D)... | null | false |
Std.DTreeMap.Internal.Impl.isEmpty_insertMany_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{l : List ((a : α) × β a)}, (↑(t.insertMany l ⋯)).isEmpty = (t.isEmpty && l.isEmpty) | null | true |
MeasurableEq.mk | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasurableSet (Set.diagonal α) → MeasurableEq α | null | true |
instComplSubtypeProdAndEqHMulFstSndOfNatHAdd | Mathlib.Algebra.Order.Ring.Idempotent | {R : Type u_1} → [inst : CommMonoid R] → [inst_1 : AddCommMonoid R] → Compl { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 } | null | true |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.mahlerMeasure_X_add_C._simp_1_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a b : α), a + b = a - -b | null | false |
NonUnitalSubsemiring.prod_mono_right | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(s : NonUnitalSubsemiring R), Monotone fun t => s.prod t | null | true |
StarAlgHom.realContinuousMapOfNNReal._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | IsTopologicalSemiring ℝ | null | false |
profiniteToCompHaus | Mathlib.Topology.Category.Profinite.Basic | CategoryTheory.Functor Profinite CompHaus | The fully faithful embedding of `Profinite` in `CompHaus`. | true |
Plausible.InjectiveFunction.instArbitraryInt | Mathlib.Testing.Plausible.Functions | Plausible.Arbitrary (Plausible.InjectiveFunction ℤ) | null | true |
HomotopicalAlgebra.CategoryWithCofibrations.recOn | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : HomotopicalAlgebra.CategoryWithCofibrations C → Sort u_1} →
(t : HomotopicalAlgebra.CategoryWithCofibrations C) →
((cofibrations : CategoryTheory.MorphismProperty C) → motive { cofibrations := cofibrations }) → motive t | null | false |
Lean.Parser.Tactic.mvcgen'Macro | Init.Tactics | Lean.ParserDescr | Experimental Sym-based drop-in for `mvcgen`; see `mvcgen` for documentation. | true |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.restrict_lintegral._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β) (x : α),
(f x ∈ f.range) = True | null | false |
iterateInduction.eq_2 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ {X : ℕ → Type u_1} {a : ℕ} (x : (i : ↥(Finset.Iic a)) → X ↑i)
(ind : (n : ℕ) → ((i : ↥(Finset.Iic n)) → X ↑i) → X (n + 1)) (k : ℕ),
iterateInduction x ind k.succ = if h : k + 1 ≤ a then x ⟨k + 1, ⋯⟩ else ind k fun i => iterateInduction x ind ↑i | null | true |
LieAlgebra.isNilpotent_ad_of_mem_rootSpace | Mathlib.Algebra.Lie.Weights.Chain | ∀ {L : Type u_2} [inst : LieRing L] {K : Type u_4} [inst_1 : Field K] [CharZero K] [inst_3 : LieAlgebra K L]
(H : LieSubalgebra K L) [inst_4 : LieRing.IsNilpotent ↥H] [LieModule.IsTriangularizable K (↥H) L]
[FiniteDimensional K L] {x : L} {χ : ↥H → K},
χ ≠ 0 → x ∈ LieAlgebra.rootSpace H χ → IsNilpotent ((LieAlgeb... | null | true |
Lean.PrettyPrinter.Delaborator.SubExpr.withBoundedAppFnArgs._sunfold | Lean.PrettyPrinter.Delaborator.SubExpr | {α : Type} →
{m : Type → Type} →
[Monad m] → [MonadReaderOf Lean.SubExpr m] → [MonadWithReaderOf Lean.SubExpr m] → ℕ → m α → (α → m α) → m α | null | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.instDecidableEqStained.decEq._proof_8 | Mathlib.Tactic.Linter.FlexibleLinter | Mathlib.Linter.Flexible.Stained.wildcard✝ = Mathlib.Linter.Flexible.Stained.goal✝ → False | null | false |
Nat.isLeast_nth_of_infinite | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop}, (setOf p).Infinite → ∀ (n : ℕ), IsLeast {i | p i ∧ ∀ k < n, Nat.nth p k < i} (Nat.nth p n) | null | true |
CliffordAlgebra.reverseOp_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (m : M),
CliffordAlgebra.reverseOp ((CliffordAlgebra.ι Q) m) = MulOpposite.op ((CliffordAlgebra.ι Q) m) | null | true |
_private.Batteries.Data.Array.Scan.0.Array.getElem?_scanl._proof_1_1 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {a : β} {l : Array α} {i : ℕ} {f : β → α → β},
i + 1 ≤ (Array.scanl f a l).size → i < (Array.scanl f a l).size | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithInitial.id.match_1.eq_2 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_1} (motive : CategoryTheory.WithInitial C → Sort u_2)
(h_1 : (a : C) → motive (CategoryTheory.WithInitial.of a)) (h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of a => h_1 a
| CategoryTheory.WithInitial.star => h_... | null | true |
FunLike.addCancelMonoid | Mathlib.Data.FunLike.Group | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : Add F] →
[inst_2 : Zero F] →
[inst_3 : SMul ℕ F] →
[inst_4 : AddCancelMonoid β] →
[IsZeroApply F α β] → [IsAddApply F α β] → [IsSMulApply ℕ F α β] → AddCancelMono... | A `FunLike` type that satisfies `(f + g) x = f x + g x`, `0 x = 0`, and
`(n • f) x = n • f x` is a cancel additive monoid if `β` is a cancel additive monoid. | true |
Std.Time.Modifier.s.noConfusion | Std.Time.Format.Basic | {P : Sort u} →
{presentation presentation' : Std.Time.Number} →
Std.Time.Modifier.s presentation = Std.Time.Modifier.s presentation' → (presentation = presentation' → P) → P | null | false |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkListLitAux._sunfold | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → List Lean.Expr → Lean.Expr | null | false |
Lean.Meta.Grind.mkExtension._auto_1 | Lean.Meta.Tactic.Grind.Extension | Lean.Syntax | null | false |
Lean.ScopedEnvExtension.ScopedEntries.casesOn | Lean.ScopedEnvExtension | {β : Type} →
{motive : Lean.ScopedEnvExtension.ScopedEntries β → Sort u} →
(t : Lean.ScopedEnvExtension.ScopedEntries β) →
((map : Lean.SMap Lean.Name (Lean.PArray β)) → motive { map := map }) → motive t | null | false |
_private.Mathlib.RingTheory.ZariskisMainTheorem.0.Algebra.ZariskisMainProperty.of_adjoin_eq_top._simp_1_9 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_2} [inst : Ring R] (f : Polynomial R), f.eraseLead = f - (Polynomial.monomial f.natDegree) f.leadingCoeff | null | false |
NonUnitalSubsemiring.instSetLike | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} → [inst : NonUnitalNonAssocSemiring R] → SetLike (NonUnitalSubsemiring R) R | null | true |
CochainComplex.mappingCone.rotateHomotopyEquiv_comm₂_assoc | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
{Z : HomotopyCategory C (ComplexShape.up ℤ)}
(h :
(HomotopyCategory.quotient C (ComplexShape.up ℤ)).obj
(... | null | true |
_private.Mathlib.CategoryTheory.Generator.Preadditive.0.CategoryTheory.Preadditive.isSeparating_iff._simp_1_1 | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Lean.Server.handleCodeActionResolve | Lean.Server.CodeActions.Basic | Lean.Lsp.CodeAction → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Lsp.CodeAction) | Handler for `"codeAction/resolve"`.
[reference](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#codeAction_resolve)
| true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.M.tell | Lean.Meta.Tactic.FunInd | Lean.Expr → Lean.Tactic.FunInd.M✝ Unit | null | true |
_private.Mathlib.NumberTheory.ModularForms.Cusps.0.Subgroup.two_mul_widthInfty_mem_strictPeriods._simp_1_2 | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {A : Type u_1} {M : Type u_3} [inst : AddMonoid A] [inst_1 : Monoid M] (ψ : AddChar A M) (n : ℕ) (x : A),
ψ x ^ n = ψ (n • x) | null | false |
Polynomial.Sequence.elems' | Mathlib.Algebra.Polynomial.Sequence | {R : Type u_1} → [inst : Semiring R] → Polynomial.Sequence R → ℕ → Polynomial R | The `i`-th element in the sequence. Use `S i` instead, defined via `CoeFun`. | true |
Lean.Elab.Term.elabWithoutExpectedTypeAttr | Lean.Elab.App | Lean.TagAttribute | Instructs the elaborator to elaborate applications of the given declaration without an expected
type. This may prevent the elaborator from incorrectly inferring implicit arguments.
| true |
CategoryTheory.Grothendieck.isoMk._proof_3 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (e₁ : X.base ≅ Y.base) (e₂ : (F.map e₁.hom).toFunctor.obj X.fiber ≅ Y.fiber),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.Cat... | null | false |
CategoryTheory.Reflective | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor D C → Type (max (max (max u₁ u₂) v₁) v₂) | A functor is *reflective*, or *a reflective inclusion*, if it is fully faithful and right adjoint.
| true |
PseudoMetricSpace.noConfusionType | Mathlib.Topology.MetricSpace.Pseudo.Defs | Sort u_1 → {α : Type u} → PseudoMetricSpace α → {α' : Type u} → PseudoMetricSpace α' → Sort u_1 | null | false |
AlgebraicGeometry.Scheme.OpenCover.pullbackCoverAffineRefinementObjIso._proof_1 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover) (i : 𝒰.affineRefinement.openCover.I₀),
CategoryTheory.Limits.HasPullback f (𝒰.affineRefinement.openCover.f i) | null | false |
Finset.coe_pimage | Mathlib.Data.Finset.PImage | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α →. β} [inst_1 : (x : α) → Decidable (f x).Dom]
{s : Finset α}, ↑(Finset.pimage f s) = f.image ↑s | null | true |
Real.tendsto_rightDeriv_mul_log_atTop | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | Filter.Tendsto (fun x => derivWithin (fun x => x * Real.log x) (Set.Ioi x) x) Filter.atTop Filter.atTop | null | true |
Set.singletonMulHom_apply | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Mul α] (a : α), Set.singletonMulHom a = {a} | null | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.«_aux_Mathlib_AlgebraicGeometry_ProjectiveSpectrum_Scheme___macroRules__private_Mathlib_AlgebraicGeometry_ProjectiveSpectrum_Scheme_0_AlgebraicGeometry_termSpec.T__1» | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.Macro | null | false |
Array.prod_reverse_nat | Init.Data.Array.Nat | ∀ (xs : Array ℕ), xs.reverse.prod = xs.prod | null | true |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mrevertError_1 | Std.Tactic.Do.Syntax | Lean.Macro | null | false |
MvPolynomial.zeroLocus_span | Mathlib.RingTheory.Nullstellensatz | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {σ : Type u_3}
(S : Set (MvPolynomial σ k)), MvPolynomial.zeroLocus K (Ideal.span S) = {x | ∀ p ∈ S, (MvPolynomial.aeval x) p = 0} | null | true |
Lean.Kernel.Exception.toMessageData | Lean.Message | Lean.Kernel.Exception → Lean.Options → Lean.MessageData | null | true |
_private.Mathlib.Tactic.Push.0.Mathlib.Tactic.Push.elabPushTree._sparseCasesOn_3 | Mathlib.Tactic.Push | {motive : Mathlib.Tactic.Push.Head → Sort u} →
(t : Mathlib.Tactic.Push.Head) →
motive Mathlib.Tactic.Push.Head.lambda → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Std.DTreeMap.Internal.Impl.getKeyD_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α],
t.WF →
∀ {k k' fallback : α} {f : Option (β k) → Option (β k)},
(Std.DTreeMap.Internal.Impl.alter! k f t).getKeyD k' fallback =
if compare k k' = Ordering.eq then if ... | null | true |
MeasureTheory.Integrable.measure_gt_lt_top | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β} [inst_1 : Lattice β] [HasSolidNorm β] [AddLeftMono β],
MeasureTheory.Integrable f μ → ∀ {ε : β}, 0 < ε → μ {a | ε < f a} < ⊤ | If `f` is integrable, then for any `c > 0` the set `{x | f x > c}` has finite
measure. | true |
Lean.Lsp.instFromJsonPartialResultParams | Lean.Data.Lsp.Basic | Lean.FromJson Lean.Lsp.PartialResultParams | null | true |
iteratedDeriv_fun_mul | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : ℕ} {x : 𝕜} {𝔸 : Type u_5} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f g : 𝕜 → 𝔸},
ContDiffAt 𝕜 (↑n) f x →
ContDiffAt 𝕜 (↑n) g x →
iteratedDeriv n (fun i => f i * g i) x =
∑ i ∈ Finset.range (n + 1), ↑(n.choose i) * ite... | Eta-expanded form of `iteratedDeriv_mul` | true |
isOpen_sum_iff | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
IsOpen s ↔ IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s) | null | true |
HomologicalComplex.mk._flat_ctor | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} →
(X : ι → V) →
(d : (i j : ι) → X i ⟶ X j) →
autoParam (∀ (i j : ι), ¬c.Rel i j → d i j = 0) HomologicalComplex.... | null | false |
Std.TreeMap.Raw.getKey!_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ \ t₂).getKey! k = default | null | true |
CategoryTheory.CosimplicialObject.Truncated.trunc._auto_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | Lean.Syntax | null | false |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.consumeForallN._unsafe_rec | Lean.Meta.Sym.Simp.Have | Lean.Expr → ℕ → Lean.Expr | null | false |
UniformSpace.Completion.uniformSpace._proof_4 | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α],
Filter.Tendsto Prod.swap
(Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (uniformity (CauchyFilter α)))
(Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (uniformity (CauchyFilter α))) | null | false |
Monoid.toMulAction._proof_2 | Mathlib.Algebra.Group.Action.Defs | ∀ (M : Type u_1) [inst : Monoid M] (a : M), 1 * a = a | null | false |
Std.Internal.USquash.inflate.inj | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {α : Type v} {x : Std.Internal.Small α} {x_1 y : Std.Internal.USquash α}, x_1.inflate = y.inflate → x_1 = y | null | true |
subsingleton_iff_zero_eq_one | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroOneClass M₀], 0 = 1 ↔ Subsingleton M₀ | In a monoid with zero, zero equals one if and only if all elements of that semiring
are equal. | true |
instFunLikeMulActionHom._proof_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_3} {N : Type u_4} (φ : M → N) (X : Type u_1) [inst : SMul M X] (Y : Type u_2) [inst_1 : SMul N Y]
(f g : X →ₑ[φ] Y), f.toFun = g.toFun → f = g | null | false |
_private.Mathlib.RingTheory.Multiplicity.0.emultiplicity_eq_of_dvd_of_not_dvd._simp_1_4 | Mathlib.RingTheory.Multiplicity | ∀ {p : Prop} [Decidable p], (¬¬p) = p | null | false |
AddGroupSeminorm.apply_one | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] [inst_1 : DecidableEq E] (x : E), 1 x = if x = 0 then 0 else 1 | null | true |
Lean.instEmptyCollectionPrefixTree | Lean.Data.PrefixTree | {α : Type u_1} → {β : Type u_2} → {p : α → α → Ordering} → EmptyCollection (Lean.PrefixTree α β p) | null | true |
Equiv.removeNone_aux_none | Mathlib.Logic.Equiv.Option | ∀ {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α}, e (some x) = none → some (e.removeNoneAux x) = e none | **Alias** of `Equiv.removeNoneAux_none`. | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.append_append_left_iff._simp_1_3 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} (p : α × Bool), FreeGroup.Red (p :: L₁) (p :: L₂) = FreeGroup.Red L₁ L₂ | null | false |
Int32.toISize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n ≤ 2147483647 → (OfNat.ofNat n).toISize = OfNat.ofNat n | null | true |
LinearMap.convSemiring._proof_6 | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_3} {A : Type u_1} {C : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid C] [inst_4 : Module R C] [inst_5 : Coalgebra R C] (n : ℕ) (x : WithConv (C →ₗ[R] A)),
npowRecAuto (n + 1) x = npowRecAuto n x * x | null | false |
Subring.inclusion._proof_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : NonAssocRing R] {S T : Subring R}, S ≤ T → ∀ (x : ↥S), S.subtype x ∈ T | null | false |
MeasureTheory.eLpNormEssSup_le_of_ae_nnnorm_bound | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_5} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup F]
{f : α → F} {C : NNReal}, (∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ C) → MeasureTheory.eLpNormEssSup f μ ≤ ↑C | null | true |
ZeroLEOneClass.rec | Mathlib.Algebra.Order.ZeroLEOne | {α : Type u_2} →
[inst : Zero α] →
[inst_1 : One α] →
[inst_2 : LE α] →
{motive : ZeroLEOneClass α → Sort u} → ((zero_le_one : 0 ≤ 1) → motive ⋯) → (t : ZeroLEOneClass α) → motive t | null | false |
List.pmap_attachWith._proof_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {q : α → Prop} {l : List α} (H₁ : ∀ x ∈ l, q x) (a : α) (h : a ∈ l), ⟨a, ⋯⟩ ∈ l.attachWith q H₁ | null | false |
Polynomial.logMahlerMeasure.eq_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ (p : Polynomial ℂ), p.logMahlerMeasure = Real.circleAverage (fun x => Real.log ‖Polynomial.eval x p‖) 0 1 | null | true |
BialgHom.instCommMonoidWithConv._proof_5 | Mathlib.RingTheory.Bialgebra.Convolution | ∀ {R : Type u_3} {A : Type u_1} {C : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Semiring C]
[inst_3 : Bialgebra R A] [inst_4 : Bialgebra R C] [inst_5 : Coalgebra.IsCocomm R C],
autoParam (∀ (n : ℕ) (x : WithConv (C →ₐc[R] A)), npowRec (n + 1) x = npowRec n x * x) Monoid.npow_succ._autoPar... | null | false |
UpperHalfPlane.IsZeroAtImInfty.petersson_isZeroAtImInfty_left | Mathlib.NumberTheory.ModularForms.Petersson | ∀ {F : Type u_1} {F' : Type u_2} [inst : FunLike F UpperHalfPlane ℂ] [inst_1 : FunLike F' UpperHalfPlane ℂ] (k : ℤ)
(Γ : Subgroup (GL (Fin 2) ℝ)) [Fact (IsCusp OnePoint.infty Γ)] [Γ.HasDetPlusMinusOne] [DiscreteTopology ↥Γ]
[ModularFormClass F Γ k] [ModularFormClass F' Γ k] {f : F},
UpperHalfPlane.IsZeroAtImInfty... | null | true |
List.Vector.instLawfulTraversableFlipNat | Mathlib.Data.Vector.Basic | ∀ {n : ℕ}, LawfulTraversable (flip List.Vector n) | null | true |
SymbolicDynamics.FullShift.Pattern.rec | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
{G : Type u_2} →
[inst : Inhabited A] →
{motive : SymbolicDynamics.FullShift.Pattern A G → Sort u} →
((config : G → A) →
(support : Finset G) →
(condition : ∀ g ∉ support, config g = default) →
motive { config := config, support := support, ... | null | false |
AddSubmonoid.instInfSet._proof_2 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] (s : Set (AddSubmonoid M)) {a b : M},
a ∈ ⋂ t ∈ s, ↑t → b ∈ ⋂ t ∈ s, ↑t → a + b ∈ ⋂ x ∈ s, ↑x | null | false |
PFunctor.Approx.Agree.continu | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (x : PFunctor.Approx.CofixA F 0) (y : PFunctor.Approx.CofixA F 1), PFunctor.Approx.Agree x y | null | true |
FirstOrder.«_aux_Mathlib_ModelTheory_Semantics___macroRules_FirstOrder_term_≅[_]__1» | Mathlib.ModelTheory.Semantics | Lean.Macro | null | false |
SlashInvariantForm.constℝ._proof_1 | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.HasDetPlusMinusOne] (x : ℝ),
∀ g ∈ Γ,
∀ (τ : UpperHalfPlane),
SlashAction.map 0 g (Function.const UpperHalfPlane ↑x) τ = Function.const UpperHalfPlane (↑x) τ | null | false |
String.Pos.slice_le_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {p : (s.slice p₀ p₁ h).Pos} {q : s.Pos} {h₀ : p₀ ≤ q} {h₁ : q ≤ p₁},
q.slice p₀ p₁ h₀ h₁ ≤ p ↔ q ≤ String.Pos.ofSlice p | null | true |
MvPolynomial.coeff_expand_zero | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (p : ℕ),
p ≠ 0 → ∀ (φ : MvPolynomial σ R), MvPolynomial.coeff 0 ((MvPolynomial.expand p) φ) = MvPolynomial.coeff 0 φ | null | true |
Algebra.adjoin_singleton_eq_range_aeval | Mathlib.RingTheory.Adjoin.Polynomial.Basic | ∀ (R : Type u) {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
R[x] = (Polynomial.aeval x).range | null | true |
_private.Mathlib.Analysis.Convex.Gauge.0.gauge_lt_eq'._simp_1_3 | Mathlib.Analysis.Convex.Gauge | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.saveAppOf._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Types | {motive : Lean.HeadIndex → Sort u} →
(t : Lean.HeadIndex) →
((constName : Lean.Name) → motive (Lean.HeadIndex.const constName)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
Eq.mpr_prop | Init.SimpLemmas | ∀ {p q : Prop}, p = q → q → p | null | true |
_private.Mathlib.Analysis.Analytic.Basic.0.HasFPowerSeriesWithinOnBall.congr._simp_1_1 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
LieModule.shiftedGenWeightSpace.instLieRingModuleSubtypeMemLieSubmodule._proof_6 | Mathlib.Algebra.Lie.Weights.Linear | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] (χ : L → R) [LieModule.LinearWeights R L M] (x y : L)
(m : ↥(Li... | null | false |
UpperSet.infIrred_iff_of_finite | Mathlib.Order.Birkhoff | ∀ {α : Type u_1} [inst : PartialOrder α] {s : UpperSet α} [Finite α], InfIrred s ↔ ∃ a, UpperSet.Ici a = s | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.