name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
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 α) →
(vs : Array β) → (h : ks.size = vs.size) → motive_1 (Lean.PersistentHashMap.Node.collision ks vs h)) →
motive_1 t |
TrivSqZeroExt.addGroupWithOne._proof_5 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddGroupWithOne R] [inst_1 : AddGroup M] (n : ℕ) (a : TrivSqZeroExt R M),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a |
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 |
_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 |
FreeAlgebra.Pre.hasZero | Mathlib.Algebra.FreeAlgebra | (R : Type u_1) → (X : Type u_2) → [CommSemiring R] → Zero (FreeAlgebra.Pre R X) |
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) |
_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.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it' => h_2 it'
| Std.IterStep.done => h_3 ()) =
h_2 it' |
Continuous.of_inv | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [ContinuousInv G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous f⁻¹ → Continuous f |
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 : ContinuousAdd F]
[inst_10 : ContinuousConstSMul 𝕜 F] [inst_11 : AddCommMonoid G] [inst_12 : Module 𝕜 G] [inst_13 : TopologicalSpace G]
[inst_14 : ContinuousAdd G] [inst_15 : ContinuousConstSMul 𝕜 G] (p : FormalMultilinearSeries 𝕜 E F)
(q : FormalMultilinearSeries 𝕜 E G) (x : ℕ), p.prod q x = (p x).prod (q x) |
_private.Aesop.Stats.Basic.0.Aesop.profiling.match_1 | Aesop.Stats.Basic | {α : Type} →
(motive : α × Aesop.Nanos → Sort u_1) →
(__discr : α × Aesop.Nanos) → ((result : α) → (elapsed : Aesop.Nanos) → motive (result, elapsed)) → motive __discr |
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 |
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 = ⊥) |
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) |
_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 |
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) |
_private.Lean.Meta.Eqns.0.Lean.Meta.getEqnsFnsRef | Lean.Meta.Eqns | IO.Ref (List Lean.Meta.GetEqnsFn) |
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 (CategoryTheory.Limits.kernel.ι (CategoryTheory.CategoryStruct.comp f g)) ⋯ |
Lean.Parser.Tactic.Conv.occsWildcard | Init.Conv | Lean.ParserDescr |
_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 |
Real.sqPartialHomeomorph._proof_4 | Mathlib.Analysis.SpecialFunctions.Sqrt | ∀ x ∈ Set.Ioi 0, √x ^ 2 = x |
_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 |
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.InjOn f s → ∫⁻ (x : E) in s, ENNReal.ofReal |(f' x).det| ∂μ ≤ μ (f '' s) |
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 |
CStarAlgebra.toCompleteSpace | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [self : CStarAlgebra A], CompleteSpace A |
Finset.recOn | Mathlib.Data.Finset.Defs | {α : Type u_4} →
{motive : Finset α → Sort u} →
(t : Finset α) → ((val : Multiset α) → (nodup : val.Nodup) → motive { val := val, nodup := nodup }) → motive t |
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.RightInverse f.invFun f.toFun |
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₂ |
_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) |
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₁ |
Mathlib.Tactic.tacticApply_At_ | Mathlib.Tactic.ApplyAt | Lean.ParserDescr |
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 |
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.Pretriangulated.distinguishedTriangles,
∀ (T₂ : CategoryTheory.Pretriangulated.Triangle C) (x : T₂ ≅ T₁),
T₂ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles |
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) |
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 |
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 : AddConGen.Rel r x y) (a_2 : AddConGen.Rel r y z), motive x z ⋯) →
(∀ {w x y z : M} (a : AddConGen.Rel r w x) (a_2 : AddConGen.Rel r y z), motive (w + y) (x + z) ⋯) →
motive a a_1 t |
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 |
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 |
Std.Roc.Sliceable.mkSlice | Init.Data.Slice.Notation | {α : Type u} → {β : outParam (Type v)} → {γ : outParam (Type w)} → [self : Std.Roc.Sliceable α β γ] → α → Std.Roc β → γ |
Unitization.instRing._proof_15 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : NonUnitalRing A] (a b : Unitization R A), a - b = a + -b |
_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 |
_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 |
Lean.Lsp.CodeActionClientCapabilities.disabledSupport?._default | Lean.Data.Lsp.CodeActions | Option Bool |
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 |
_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) |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AccLevelState.ctorIdx | Lean.Elab.MutualInductive | Lean.Elab.Command.AccLevelState✝ → ℕ |
List.getLast_tail | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (h : l.tail ≠ []), l.tail.getLast h = l.getLast ⋯ |
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 |
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' := ⋯,
map_inf' := ⋯ }.toFun
a ⊔
{ toFun := ⇑(CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)), map_sup' := ⋯,
map_inf' := ⋯ }.toFun
b |
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) |
AddSubgroup.IsSubnormal.normal_of_isSimpleAddGroup | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, IsSimpleAddGroup G → H.IsSubnormal → H.Normal |
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 |
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 |
isRelLowerSet_empty | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α], IsRelLowerSet ∅ P |
Rat.ceil_intCast | Init.Data.Rat.Lemmas | ∀ (a : ℤ), (↑a).ceil = a |
FirstOrder.Language.Term.varFinset._unsafe_rec | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [DecidableEq α] → L.Term α → Finset α |
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 Lean.Lsp.WindowClientCapabilities) (workspace?_1 : Option Lean.Lsp.WorkspaceClientCapabilities)
(lean?_1 : Option Lean.Lsp.LeanClientCapabilities),
({ textDocument? := textDocument?, window? := window?, workspace? := workspace?, lean? := lean? } =
{ textDocument? := textDocument?_1, window? := window?_1, workspace? := workspace?_1, lean? := lean?_1 }) =
(textDocument? = textDocument?_1 ∧ window? = window?_1 ∧ workspace? = workspace?_1 ∧ lean? = lean?_1) |
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.functor.obj X))).obj A).hom =
((((CategoryTheory.Over.post F.inverse).comp (CategoryTheory.Over.map (F.unitIso.inv.app X))).comp
(CategoryTheory.Over.post F.functor)).obj
A).hom |
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 |
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) |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage.0.circleAverage_log_norm_sub_const_eq_log_radius_add_posLog._simp_1_10 | Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] {a b : E} {r : ℝ}, (b ∈ Metric.sphere a r) = (‖b - a‖ = r) |
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) |
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 |
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 |
Fintype.prod_fiberwise | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} {κ : Type u_6} {ι : Type u_7} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : CommMonoid M]
[inst_3 : DecidableEq κ] (g : ι → κ) (f : ι → M), ∏ j, ∏ i, f ↑i = ∏ i, f i |
_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 : GradedRing 𝒜]
[inst_8 : DecidableEq ιM] [inst_9 : SetLike σM M] [inst_10 : AddSubmonoidClass σM M]
[inst_11 : DirectSum.Decomposition ℳ] [inst_12 : VAdd ιA ιM] [inst_13 : SetLike.GradedSMul 𝒜 ℳ]
(motive : HomogeneousSubmodule 𝒜 ℳ → Prop) (x : HomogeneousSubmodule 𝒜 ℳ),
(∀ (y : Submodule A M) (hy : y.IsHomogeneous ℳ), motive { toSubmodule := y, is_homogeneous' := hy }) → motive x |
_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 |
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 |
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ι |
List.recOn.eq._@.Mathlib.Util.CompileInductive.1590845460._hygCtx._hyg.6 | Mathlib.Util.CompileInductive | @List.recOn = @List.recOn✝ |
Lean.Meta.instReprConfig_1 | Init.Meta.Defs | Repr Lean.Meta.Simp.Config |
_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 (CategoryTheory.ShortComplex.opcyclesMap' φ₁ h₁ h₂)
(CategoryTheory.ShortComplex.opcyclesMap' φ₂ h₂ h₃) =
CategoryTheory.ShortComplex.opcyclesMap' (CategoryTheory.CategoryStruct.comp φ₁ φ₂) h₁ h₃ |
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 |
_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 |
one_div_mul_eq_div | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), 1 / a * b = b / a |
FermatLastTheoremForThreeGen.Solution.Solution'_descent | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} →
{hζ : IsPrimitiveRoot ζ 3} →
FermatLastTheoremForThreeGen.Solution hζ →
[inst_1 : NumberField K] → [IsCyclotomicExtension {3} ℚ K] → FermatLastTheoremForThreeGen.Solution' hζ |
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 |
_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) |
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 |
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 |
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) [inst_6 : LinearOrder J] [SuccOrder J] [OrderBot J] [WellFoundedLT J],
W.IsStableUnderColimitsOfShape J) →
∀ {j : J} (g : ⊥ ⟶ j), W (hf.F.map g) |
_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 |
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 |
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 |
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 |
MeasureTheory.IsAddFundamentalDomain.integral_eq_tsum' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} {E : Type u_5} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
[inst_3 : NormedAddCommGroup E] {s : Set α} {μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α]
[MeasureTheory.VAddInvariantMeasure G α μ] [Countable G] [inst_7 : NormedSpace ℝ E],
MeasureTheory.IsAddFundamentalDomain G s μ →
∀ (f : α → E), MeasureTheory.Integrable f μ → ∫ (x : α), f x ∂μ = ∑' (g : G), ∫ (x : α) in s, f (-g +ᵥ x) ∂μ |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.rotate_eq_iff | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ {n : ℕ} {x y : BitVec n}, BitVec.Signed.rotate✝ x = y ↔ x = BitVec.Signed.rotate✝¹ y |
Rep.leftRegularTensorTrivialIsoFree._proof_3 | Mathlib.RepresentationTheory.Rep | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Monoid G] (α : Type u_1) (x : G),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategoryStruct.tensorObj (Rep.leftRegular k G) (Rep.trivial k G (α →₀ k))).ρ x)
(((finsuppTensorFinsupp' k G α).trans (Finsupp.domLCongr (Equiv.prodComm G α))).trans
(Finsupp.curryLinearEquiv k)).toModuleIso.hom =
CategoryTheory.CategoryStruct.comp
(((finsuppTensorFinsupp' k G α).trans (Finsupp.domLCongr (Equiv.prodComm G α))).trans
(Finsupp.curryLinearEquiv k)).toModuleIso.hom
((Rep.free k G α).ρ x) |
Std.DHashMap.Internal.Raw₀.equiv_emptyWithCapacity_iff_isEmpty | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF → ∀ {c : ℕ}, (↑m).Equiv ↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity c) ↔ (↑m).isEmpty = true |
LinearEquiv.automorphismGroup.toLinearMapMonoidHom._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x x_1 : M ≃ₗ[R] M), ↑(x * x_1) = ↑(x * x_1) |
Std.Slice.Internal.ListSliceData.mk.noConfusion | Init.Data.Slice.List.Basic | {α : Type u} →
{P : Sort u_1} →
{list : List α} →
{stop : Option ℕ} →
{list' : List α} →
{stop' : Option ℕ} →
{ list := list, stop := stop } = { list := list', stop := stop' } → (list ≍ list' → stop = stop' → P) → P |
Real.volume_pi_Ico_toReal | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] {a b : ι → ℝ},
a ≤ b → (MeasureTheory.volume (Set.univ.pi fun i => Set.Ico (a i) (b i))).toReal = ∏ i, (b i - a i) |
Finpartition.restrict._proof_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {a b : α}
(P : Finpartition a), ((Finset.image (fun x => x ⊓ b) P.parts).erase ⊥).SupIndep id |
abs_setIntegral_mulExpNegMulSq_comp_sub_le_mul_measure | Mathlib.Analysis.SpecialFunctions.MulExpNegMulSqIntegral | ∀ {E : Type u_1} [inst : TopologicalSpace E] [inst_1 : MeasurableSpace E] [BorelSpace E] {P : MeasureTheory.Measure E}
[MeasureTheory.IsFiniteMeasure P] {ε : ℝ} {K : Set E},
IsCompact K →
MeasurableSet K →
∀ (f g : C(E, ℝ)) {δ : ℝ},
0 < ε →
(∀ x ∈ K, |g x - f x| < δ) →
|∫ (x : E) in K, ε.mulExpNegMulSq (g x) ∂P - ∫ (x : E) in K, ε.mulExpNegMulSq (f x) ∂P| ≤ δ * (P K).toReal |
Units.instCommGroupUnits.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u_1} [inst : CommMonoid α], Units.instCommGroupUnits = { toGroup := Units.instGroup, mul_comm := ⋯ } |
Ordnode.map._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → {β : Type u_2} → (α → β) → Ordnode α → Ordnode β |
SimpleGraph.Subgraph.Adj.ne | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H : G.Subgraph} {u v : V}, H.Adj u v → u ≠ v |
Std.DHashMap.getKeyD_insertIfNew | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{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 |
Lean.Server.DirectImports.ordered | Lean.Server.References | Lean.Server.DirectImports → Array Lean.Server.ModuleImport |
CategoryTheory.SmallObject.transfiniteCompositionOfShapeιIterationAppRight._proof_3 | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ (κ : Cardinal.{u_1}) (j : κ.ord.ToType), j ≤ Order.succ j |
HomologicalComplex.instModuleHom._proof_8 | Mathlib.Algebra.Homology.Linear | ∀ {R : Type u_4} [inst : Semiring R] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {ι : Type u_1} {c : ComplexShape ι}
(X Y : HomologicalComplex C c) (x x_1 : R) (x_2 : X ⟶ Y), (x + x_1) • x_2 = x • x_2 + x_1 • x_2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.