name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ImportGraph.Shake.Bitset.mk.noConfusion | ImportGraph.Shake.Core | {P : Sort u} → {toNat toNat' : ℕ} → { toNat := toNat } = { toNat := toNat' } → (toNat = toNat' → P) → P | null | false |
Lean.PersistentHashMap.Node.casesOn | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{motive_1 : Lean.PersistentHashMap.Node α β → Sort u_1} →
(t : Lean.PersistentHashMap.Node α β) →
((es : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) →
motive_1 (Lean.PersistentHashMap.Node.entries es)) →
((ks : Array... | null | false |
TrivSqZeroExt.addGroupWithOne._proof_5 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddGroupWithOne R] [inst_1 : AddGroup M] (a : TrivSqZeroExt R M), -a + a = 0 | null | false |
Aesop.FIFOQueue.casesOn | Aesop.Search.Queue | {motive : Aesop.FIFOQueue → Sort u} →
(t : Aesop.FIFOQueue) → ((goals : Array Aesop.GoalRef) → (pos : ℕ) → motive { goals := goals, pos := pos }) → motive t | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.isClassQuick?.match_3 | Lean.Meta.Basic | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
FreeAlgebra.Pre.hasZero | Mathlib.Algebra.FreeAlgebra | (R : Type u_1) → (X : Type u_2) → [CommSemiring R] → Zero (FreeAlgebra.Pre R X) | Zero in `Pre R X` defined as the image of `0` from `R`. Note: Used for notation only. | true |
add_le_add_add_tsub | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α] {a b c : α}
[AddLeftMono α], a + b ≤ a + c + (b - c) | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.length_eq_match_step.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type u_1} (motive : Std.IterStep (Std.Iter β) β → Sort u_2) (it' : Std.Iter β)
(h_1 : (it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.Iter β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.skip it' with
| Std.Iter... | null | true |
_private.Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic.0._proof_107 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X ⟶ Z) (g : Y ⟶ Z) (i : Function.Pullback f.f g.f), Z.obj (f.f (↑i).1) = Z.obj (g.f (↑i).2) | null | false |
Continuous.of_inv | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ {G : Type u_1} {α : Type u_3} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [ContinuousInv G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous f⁻¹ → Continuous f | **Alias** of the forward direction of `continuous_inv_iff`. | true |
FormalMultilinearSeries.prod.eq_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u} {E : Type v} {F : Type w} {G : Type x} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E]
[inst_6 : AddCommMonoid F] [inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : Continu... | null | true |
_private.Aesop.Stats.Basic.0.Aesop.profiling.match_1 | Aesop.Stats.Basic | {α : Type} →
(motive : α × Aesop.Nanos → Sort u_1) →
(x : α × Aesop.Nanos) → ((result : α) → (elapsed : Aesop.Nanos) → motive (result, elapsed)) → motive x | null | false |
Multipliable.div | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} {L : SummationFilter β} [inst : CommGroup α] [inst_1 : TopologicalSpace α]
[IsTopologicalGroup α] {f g : β → α}, Multipliable f L → Multipliable g L → Multipliable (fun b => f b / g b) L | null | true |
LinearMap.HasFiniteRange.of_isNoetherian_rng | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_3} [inst : Semiring K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V]
[inst_3 : AddCommMonoid V₂] [inst_4 : Module K V₂] [IsNoetherian K V₂] {f : V →ₗ[K] V₂}, f.HasFiniteRange | null | true |
LieSubmodule.toSubmodule_eq_bot._simp_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M), (↑N = ⊥) = (N = ⊥) | null | false |
LinearEquiv.sumArrowLequivProdArrow_apply_fst | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_5}
{β : Type u_6} (f : α ⊕ β → M) (a : α), ((LinearEquiv.sumArrowLequivProdArrow α β R M) f).1 a = f (Sum.inl a) | null | true |
_private.Lean.Elab.SetOption.0.Lean.Elab.elabSetOption.match_1 | Lean.Elab.SetOption | (motive : Lean.Syntax → Sort u_1) →
(val : Lean.Syntax) →
((info : Lean.SourceInfo) → motive (Lean.Syntax.atom info "true")) →
((info : Lean.SourceInfo) → motive (Lean.Syntax.atom info "false")) → ((x : Lean.Syntax) → motive x) → motive val | null | false |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.getHaveTelescopeInfo.collect._f | Lean.Meta.HaveTelescope | (e : Lean.Expr) →
Lean.Expr.below (motive := fun e =>
ℕ → Lean.Meta.HaveTelescopeInfo → Lean.LocalContext → Array Lean.Expr → Lean.MetaM Lean.Meta.HaveTelescopeInfo)
e →
ℕ → Lean.Meta.HaveTelescopeInfo → Lean.LocalContext → Array Lean.Expr → Lean.MetaM Lean.Meta.HaveTelescopeInfo | null | false |
SemiRingCat.limitSemiring._proof_22 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections],
autoParam
(∀ (x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt), ... | null | false |
Ideal.Filtration.smul_le | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(self : I.Filtration M) (i : ℕ), I • self.N i ≤ self.N (i + 1) | null | true |
_private.Lean.Meta.Eqns.0.Lean.Meta.getEqnsFnsRef | Lean.Meta.Eqns | IO.Ref (List Lean.Meta.GetEqnsFn) | null | true |
CuspForm.ofMulDiscriminant._proof_3 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | (Matrix.SpecialLinearGroup.mapGL ℝ).range.HasDetPlusMinusOne | null | false |
CategoryTheory.Limits.kernelCompMono_hom | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) [inst_2 : CategoryTheory.Limits.HasKernel f] [inst_3 : CategoryTheory.Mono g],
(CategoryTheory.Limits.kernelCompMono f g).hom =
CategoryTheory.Limits.kernel.lift f (Ca... | null | true |
_private.Lean.Elab.Deriving.Basic.0.Lean.Elab.Term.processDefDeriving._sparseCasesOn_22 | Lean.Elab.Deriving.Basic | {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 |
Lean.Parser.Tactic.Conv.occsWildcard | Init.Conv | Lean.ParserDescr | The `*` occurrence list means to apply to all occurrences of the pattern. | true |
_private.Mathlib.Order.Interval.Finset.Gaps.0.Finset.intervalGapsWithin_fst_le_snd._proof_1_13 | Mathlib.Order.Interval.Finset.Gaps | ∀ {α : Type u_1} (F : Finset (α × α)) {k : ℕ}, ∀ j < k + 1, k - 1 + 1 = k → ¬j - 1 < k → False | null | false |
Real.sqPartialHomeomorph._proof_4 | Mathlib.Analysis.SpecialFunctions.Sqrt | ∀ x ∈ Set.Ioi 0, √x ^ 2 = x | null | false |
_private.Plausible.Gen.0.Plausible.instReprGenError.repr.match_1 | Plausible.Gen | (motive : Plausible.GenError → Sort u_1) →
(x : Plausible.GenError) → ((a : String) → motive (Plausible.GenError.genError a)) → motive x | null | false |
HopfAlgebra.ofSurjective._proof_2 | Mathlib.RingTheory.HopfAlgebra.Convolution | ∀ {R : Type u_1} [inst : CommSemiring R] {B : Type u_2} [inst_1 : Semiring B] [inst_2 : HopfAlgebraStruct R B],
IsScalarTower R B B | null | false |
MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image | Mathlib.MeasureTheory.Function.Jacobian | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] {s : Set E}
{f : E → E} {f' : E → E →L[ℝ] E} [inst_3 : MeasurableSpace E] [BorelSpace E] (μ : MeasureTheory.Measure E)
[μ.IsAddHaarMeasure],
MeasurableSet s →
(∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) →
Set... | null | true |
HasDerivWithinAt.neg | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
HasDerivWithinAt f f' s x → HasDerivWithinAt (-f) (-f') s x | null | true |
CStarAlgebra.toCompleteSpace | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [self : CStarAlgebra A], CompleteSpace A | null | true |
Finset.recOn | Mathlib.Data.Finset.Defs | {α : Type u_3} →
{motive : Finset α → Sort u} →
(t : Finset α) → ((val : Multiset α) → (nodup : val.Nodup) → motive { val := val, nodup := nodup }) → motive t | null | false |
IsometryEquiv.toRealLinearIsometryEquivOfMapZero._proof_7 | Mathlib.Analysis.Normed.Affine.MazurUlam | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] (f : E ≃ᵢ F),
Function.LeftInverse f.invFun f.toFun | null | false |
GroupExtension.Section.exists_mul_eq_inl_mul_mul | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ : S.Section) (g₁ g₂ : G), ∃ n, σ (g₁ * g₂) = S.inl n * σ g₁ * σ g₂ | null | true |
ContinuousLinearEquiv.restrictScalars_toLinearEquiv | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ (R : Type u_1) {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [inst_4 : Module S M] [inst_5 : TopologicalSpace M] [inst_6 : LinearMap.CompatibleSMul M M R S]
(f : M ≃L[S] M), ↑(ContinuousLinearEquiv.restrictScalars R f) = LinearEquiv.restri... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getLsbD_sshiftRight._simp_1_2 | Init.Data.BitVec.Lemmas | ∀ {a b : Bool}, (b = (a && b)) = (b = true → a = true) | null | false |
List.sublists'Aux.eq_1 | Mathlib.Data.List.Sublists | ∀ {α : Type u} (a : α) (r₁ r₂ : List (List α)), List.sublists'Aux a r₁ r₂ = List.foldl (fun r l => r ++ [a :: l]) r₂ r₁ | null | true |
Mathlib.Tactic.tacticApply_At_ | Mathlib.Tactic.ApplyAt | Lean.ParserDescr | `apply t at i` uses forward reasoning with `t` at the hypothesis `i`.
Explicitly, if `t : α₁ → ⋯ → αᵢ → ⋯ → αₙ` and `i` has type `αᵢ`, then this tactic adds
metavariables/goals for any terms of `αⱼ` for `j = 1, …, i-1`,
then replaces the type of `i` with `αᵢ₊₁ → ⋯ → αₙ` by applying those metavariables and the
original ... | true |
CategoryTheory.OverClass.asOverHom.eq_1 | Mathlib.AlgebraicGeometry.Group.Affine | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (S : C) [inst_1 : CategoryTheory.OverClass X S]
[inst_2 : CategoryTheory.OverClass Y S] (f : X ⟶ Y) [inst_3 : CategoryTheory.HomIsOver f S],
CategoryTheory.OverClass.asOverHom S f = CategoryTheory.Over.homMk f ⋯ | null | true |
Subfield.extendScalars_toSubfield | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {L : Type u_2} [inst : Field L] {F E : Subfield L} (h : F ≤ E), (Subfield.extendScalars h).toSubfield = E | null | true |
CategoryTheory.Pretriangulated.isomorphic_distinguished | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Limits.HasZeroObject C}
{inst_2 : CategoryTheory.HasShift C ℤ} {inst_3 : CategoryTheory.Preadditive C}
{inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive} [self : CategoryTheory.Pretriangulated C],
∀ T₁ ∈ CategoryTheory... | a triangle that is isomorphic to a distinguished triangle is distinguished | true |
Std.HashMap.Raw.Equiv.insertIfNew | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ (k : α) (v : β), m₁.Equiv m₂ → (m₁.insertIfNew k v).Equiv (m₂.insertIfNew k v) | null | true |
_private.Mathlib.MeasureTheory.Function.JacobianOneDim.0.MeasureTheory.integral_Icc_deriv_smul_of_deriv_nonpos._proof_1_2 | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {f : ℝ → ℝ} {a b : ℝ}, f '' Set.Ioo a b \ f '' Set.Icc a b = ∅ | null | false |
Submodule.involutivePointwiseNeg._proof_1 | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(_S : Submodule R M), - -_S = _S | null | false |
AddConGen.Rel.casesOn | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {r : M → M → Prop} {motive : (a a_1 : M) → AddConGen.Rel r a a_1 → Prop} {a a_1 : M}
(t : AddConGen.Rel r a a_1),
(∀ (x y : M) (a : r x y), motive x y ⋯) →
(∀ (x : M), motive x x ⋯) →
(∀ {x y : M} (a : AddConGen.Rel r x y), motive y x ⋯) →
(∀ {x y z : M} (a : AddCon... | null | false |
Module.Basis.flag_le_ker_coord_iff | Mathlib.LinearAlgebra.Basis.Flag | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {n : ℕ}
[Nontrivial R] (b : Module.Basis (Fin n) R M) {k : Fin (n + 1)} {l : Fin n},
b.flag k ≤ (b.coord l).ker ↔ k ≤ l.castSucc | null | true |
MeasureTheory.preVariation_apply | Mathlib.MeasureTheory.Measure.PreVariation | ∀ {X : Type u_1} [inst : MeasurableSpace X] (f : Set X → ENNReal) (hf : MeasureTheory.IsSigmaSubadditiveSetFun f)
(hf' : f ∅ = 0) (s : Set X),
(MeasureTheory.preVariation f hf hf') s = (MeasureTheory.ennrealPreVariation f hf hf').ennrealToMeasure s | null | true |
ModuleCat.MonModuleEquivalenceAlgebra.Algebra_of_Mon_ | Mathlib.CategoryTheory.Monoidal.Internal.Module | {R : Type u} → [inst : CommRing R] → (A : ModuleCat R) → [inst_1 : CategoryTheory.MonObj A] → Algebra R ↑A | The algebra structure on a monoid object.
This instance is dangerous as it doesn't round trip from a ring to a monoid object and then back
to a ring, since the `npow` field is lost in the middle. Therefore, it is scoped. | true |
Std.Roc.Sliceable.mkSlice | Init.Data.Slice.Notation | {α : Type u} → {β : outParam (Type v)} → {γ : outParam (Type w)} → [self : Std.Roc.Sliceable α β γ] → α → Std.Roc β → γ | Slices `carrier` from `range.lower` \(exclusive\) to `range.upper` \(inclusive\).
| true |
_private.Mathlib.Analysis.Convex.Basic.0.Convex.exists_mem_add_smul_eq._simp_1_5 | Mathlib.Analysis.Convex.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
AbstractMeasure.instRing._proof_2 | Mathlib.NumberTheory.Padics.Measure.Monoid | ∀ {G : Type u_1} {R : Type u_2} [inst : TopologicalSpace G] [inst_1 : CommRing R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalRing R] [inst_4 : Monoid G] [inst_5 : ContinuousMul G] [inst_6 : LocallyCompactSpace G]
(x x_1 x_2 : AbstractMeasure G R R), x * x_1 * x_2 = x * (x_1 * x_2) | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.cycle_zpow_mem_support_iff._simp_1_2 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (n : ℕ), (0 ≤ ↑n) = True | null | false |
Lean.Lsp.CodeActionClientCapabilities.disabledSupport?._default | Lean.Data.Lsp.CodeActions | Option Bool | null | false |
_private.Mathlib.Tactic.Linter.Style.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.Style.830885783._hygCtx._hyg.4 | Mathlib.Tactic.Linter.Style | IO (Lean.Option Bool) | null | false |
MulEquiv.ofBijective_apply | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} {F : Type u_11} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[inst_3 : MulHomClass F M N] (f : F) (hf : Function.Bijective ⇑f) (a : M), (MulEquiv.ofBijective f hf) a = f a | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.not_matchesAt_of_prefixFunction_eq._simp_1_2 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {a b c : ℕ}, (a - b ≤ c) = (a ≤ c + b) | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AccLevelState.ctorIdx | Lean.Elab.MutualInductive | Lean.Elab.Command.AccLevelState✝ → ℕ | null | false |
List.getLast_tail | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (h : l.tail ≠ []), l.tail.getLast h = l.getLast ⋯ | null | true |
CategoryTheory.IsSplitCoequalizer.isCoequalizer | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{Z : C} →
{h : Y ⟶ Z} → (t : CategoryTheory.IsSplitCoequalizer f g h) → CategoryTheory.Limits.IsColimit t.asCofork | The cofork induced by a split coequalizer is a coequalizer, justifying the name. In some cases it
is more convenient to show a given cofork is a coequalizer by showing it is split.
| true |
fintypeToFinBoolAlgOp._proof_5 | Mathlib.Order.Category.FinBoolAlg | ∀ {X Y : FintypeCat} (f : X ⟶ Y) (a b : Set Y.obj),
{ toFun := ⇑(CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)), map_sup' := ⋯,
map_inf' := ⋯ }.toFun
(a ⊔ b) =
{ toFun := ⇑(CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)), map_sup' := ⋯,
... | null | false |
meromorphicTrailingCoeffAt_fun_neg | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : 𝕜} {f : 𝕜 → E},
meromorphicTrailingCoeffAt (fun z => -f z) x = -meromorphicTrailingCoeffAt f x | Taking the negative commutes with taking `meromorphicTrailingCoeffAt`.
| true |
AddUnits.val_zsmul_eq_zsmul_val._simp_1 | Mathlib.Algebra.Group.Units.Hom | ∀ {α : Type u_1} [inst : SubtractionMonoid α] (u : AddUnits α) (n : ℤ), n • ↑u = ↑(n • u) | null | false |
AddSubgroup.IsSubnormal.normal_of_isSimpleAddGroup | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, IsSimpleAddGroup G → H.IsSubnormal → H.Normal | A subnormal additive subgroup of a simple additive group is normal. | true |
uniformEquicontinuousOn_empty | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {α : Type u_6} {β : Type u_8} [uα : UniformSpace α] [uβ : UniformSpace β] [h : IsEmpty ι]
(F : ι → β → α) (S : Set β), UniformEquicontinuousOn F S | null | true |
MeasureTheory.AEEqFun.toGermMonoidHom_apply | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Monoid γ] [inst_3 : ContinuousMul γ] (f : α →ₘ[μ] γ), MeasureTheory.AEEqFun.toGermMonoidHom f = f.toGerm | null | true |
isRelLowerSet_empty | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α], IsRelLowerSet ∅ P | null | true |
Rat.ceil_intCast | Init.Data.Rat.Lemmas | ∀ (a : ℤ), (↑a).ceil = a | null | true |
FirstOrder.Language.Term.varFinset._unsafe_rec | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [DecidableEq α] → L.Term α → Finset α | null | false |
Lean.Lsp.ClientCapabilities.mk.injEq | Lean.Data.Lsp.Capabilities | ∀ (textDocument? : Option Lean.Lsp.TextDocumentClientCapabilities) (window? : Option Lean.Lsp.WindowClientCapabilities)
(workspace? : Option Lean.Lsp.WorkspaceClientCapabilities) (lean? : Option Lean.Lsp.LeanClientCapabilities)
(textDocument?_1 : Option Lean.Lsp.TextDocumentClientCapabilities)
(window?_1 : Option... | null | true |
CategoryTheory.Over.postEquiv._proof_6 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (X : T) (F : T ≌ D) (A : CategoryTheory.Over (F.functor.obj X)),
CategoryTheory.CategoryStruct.comp (F.counitIso.app A.left).hom
((CategoryTheory.Functor.id (CategoryTheory.Over (F.fun... | null | false |
Matrix.nonsing_inv_apply_not_isUnit | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
¬IsUnit A.det → A⁻¹ = 0 | null | true |
CategoryTheory.Limits.Types.TypeMax.colimitCoconeIsColimit | Mathlib.CategoryTheory.Limits.Types.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J (Type (max v u))) →
CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Types.TypeMax.colimitCocone F) | (internal implementation) the fact that the proposed colimit cocone is the colimit | true |
MinTropical.trop_coe_ne_zero | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} (x : R), MinTropical.trop ↑x ≠ 0 | null | true |
BumpCovering.locallyFinite | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : BumpCovering ι X s),
LocallyFinite fun i => Function.support ⇑(f i) | null | true |
IsHausdorff.of_isTorsionFree | Mathlib.RingTheory.AdicCompletion.Noetherian | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[IsNoetherianRing R] [Module.Finite R M] [IsDomain R] [Module.IsTorsionFree R M], I ≠ ⊤ → IsHausdorff I M | null | true |
Mathlib.Tactic.Peel.eventually_imp | Mathlib.Tactic.Peel | ∀ {α : Type u_1} {p q : α → Prop} {f : Filter α}, (∀ (x : α), p x → q x) → (∀ᶠ (x : α) in f, p x) → ∀ᶠ (x : α) in f, q x | null | true |
Fintype.prod_fiberwise | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} {ι : Type u_5} {κ : Type u_6} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : CommMonoid M]
[inst_3 : DecidableEq κ] (g : ι → κ) (f : ι → M), ∏ j, ∏ i, f ↑i = ∏ i, f i | null | true |
Lean.Lsp.ShowMessageParams.recOn | Lean.Data.Lsp.Window | {motive : Lean.Lsp.ShowMessageParams → Sort u} →
(t : Lean.Lsp.ShowMessageParams) →
((type : Lean.Lsp.MessageType) → (message : String) → motive { type := type, message := message }) → motive t | null | false |
_private.Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule.0.HomogeneousSubmodule.toSubmodule_injective.match_1_1 | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule | ∀ {ιA : Type u_1} {ιM : Type u_2} {σA : Type u_3} {σM : Type u_4} {A : Type u_5} {M : Type u_6} [inst : Semiring A]
[inst_1 : AddCommMonoid M] [inst_2 : Module A M] (𝒜 : ιA → σA) (ℳ : ιM → σM) [inst_3 : DecidableEq ιA]
[inst_4 : AddMonoid ιA] [inst_5 : SetLike σA A] [inst_6 : AddSubmonoidClass σA A] [inst_7 : Grad... | null | false |
_private.Mathlib.Analysis.Normed.Affine.Simplex.0.Affine.Simplex.scalene_reindex_iff._proof_1_4 | Mathlib.Analysis.Normed.Affine.Simplex | ∀ {m n : ℕ} (e : Fin (m + 1) ≃ Fin (n + 1)) (fst snd : Fin (m + 1)) (property : fst < snd),
e fst < e snd → e (↑⟨(fst, snd), property⟩).1 < e (↑⟨(fst, snd), property⟩).2 | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.unop._regBuiltin.Lean.Parser.Term.unop_1 | Lean.Parser.Term | IO Unit | null | false |
MeasureTheory.measure_symmDiff_eq_zero_iff | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, μ (symmDiff s t) = 0 ↔ s =ᵐ[μ] t | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.subschemeFunctor_obj | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ (Y : AlgebraicGeometry.Scheme) (I : Y.IdealSheafDataᵒᵖ),
(AlgebraicGeometry.Scheme.IdealSheafData.subschemeFunctor Y).obj I =
CategoryTheory.Over.mk (Opposite.unop I).subschemeι | null | true |
List.recOn.eq._@.Mathlib.Util.CompileInductive.1590845460._hygCtx._hyg.6 | Mathlib.Util.CompileInductive | @List.recOn = @List.recOn✝ | null | false |
Lean.Meta.instReprConfig_1 | Init.Meta.Defs | Repr Lean.Meta.Simp.Config | null | true |
_private.Mathlib.Algebra.Homology.ShortComplex.PreservesHomology.0.CategoryTheory.ShortComplex.mapOpcyclesIso_hom_naturality._simp_1_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃) (h₁ : S₁.RightHomologyData)
(h₂ : S₂.RightHomologyData) (h₃ : S₃.RightHomologyData),
CategoryTheory.CategoryStruct.comp (Categ... | null | false |
IsMinFilter.comp_mono | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {l : Filter α} {a : α},
IsMinFilter f l a → ∀ {g : β → γ}, Monotone g → IsMinFilter (g ∘ f) l a | null | true |
_private.Mathlib.Data.Nat.Choose.Lucas.0.Choose.choose_modEq_choose_mod_mul_choose_div.match_1_4 | Mathlib.Data.Nat.Choose.Lucas | ∀ (motive : ℕ × ℕ → Prop) (h : ℕ × ℕ), (∀ (x₁ x₂ : ℕ), motive (x₁, x₂)) → motive h | null | false |
one_div_mul_eq_div | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), 1 / a * b = b / a | null | true |
Ideal.exists_smith_normal_form | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommRing R] [IsDomain R] [IsPrincipalIdealRing R] {S : Type u_4}
[inst_3 : CommRing S] [IsDomain S] [inst_5 : Algebra R S] [Finite ι] (b : Module.Basis ι R S) (I : Ideal S),
I ≠ ⊥ → ∃ b' a ab', ∀ (i : ι), ↑(ab' i) = a i • b' i | If `S` a finite-dimensional ring extension of a PID `R` which is free as an `R`-module,
then any nonzero `S`-ideal `I` is free as an `R`-submodule of `S`, and we can
find a basis for `S` and `I` such that the inclusion map is a square diagonal
matrix.
See also `Ideal.smithNormalForm` for a version of this theorem that... | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.applyPartition_eq._simp_1_2 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) | null | false |
Rat.instEncodable.match_5 | Mathlib.Data.Rat.Encodable | ∀ (motive : (n : ℤ) × { d // 0 < d ∧ n.natAbs.Coprime d } → Prop) (x : (n : ℤ) × { d // 0 < d ∧ n.natAbs.Coprime d }),
(∀ (fst : ℤ) (val : ℕ) (left : 0 < val) (right : fst.natAbs.Coprime val), motive ⟨fst, ⟨val, ⋯⟩⟩) → motive x | null | false |
Std.TreeSet.Raw.size_le_size_erase | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.size ≤ (t.erase k).size + 1 | null | true |
CategoryTheory.MorphismProperty.IsStableUnderTransfiniteCompositionOfShape.of_isStableUnderColimitsOfShape.mem_map_bot_le | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {J : Type w}
[inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J] {X Y : C} {f : X ⟶ Y}
(hf : W.TransfiniteCompositionOfShape J f) [W.IsMultiplicative],
(∀ (J : Type w) [ins... | null | true |
Std.DTreeMap.Raw.Const.mem_insertManyIfNewUnit_list | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α (fun x => Unit) cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp],
t.WF → ∀ {l : List α} {k : α}, k ∈ Std.DTreeMap.Raw.Const.insertManyIfNewUnit t l ↔ k ∈ t ∨ l.contains k = true | null | true |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.asymptoticCone_closure._simp_1_2 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (x ∈ closure s) = ∃ᶠ (x : X) in nhds x, x ∈ s | null | false |
Vector.findSome?_isSome_iff | Init.Data.Vector.Find | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → Option β} {xs : Vector α n},
(Vector.findSome? f xs).isSome = true ↔ ∃ x ∈ xs, (f x).isSome = true | null | true |
CategoryTheory.Comon.comp_hom' | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N K : CategoryTheory.Comon C} (f : M ⟶ N) (g : N ⟶ K),
(CategoryTheory.CategoryStruct.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom | null | true |
Set.Icc.coeMonoidWithZeroHom._proof_2 | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R], ↑1 = ↑1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.