name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
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₂ | true |
ContinuousLinearEquiv.restrictScalars_toLinearEquiv | Mathlib.Topology.Algebra.Module.Equiv | ∀ (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).toLinearEquiv = Lin... | 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) | 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₁ | true |
Mathlib.Tactic.tacticApply_At_ | Mathlib.Tactic.ApplyAt | Lean.ParserDescr | 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 | 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... | 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) | 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 = ∅ | 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 | 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... | 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 | 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 | true |
Std.Roc.Sliceable.mkSlice | Init.Data.Slice.Notation | {α : Type u} → {β : outParam (Type v)} → {γ : outParam (Type w)} → [self : Std.Roc.Sliceable α β γ] → α → Std.Roc β → γ | 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 | 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 | false |
Lean.Lsp.CodeActionClientCapabilities.disabledSupport?._default | Lean.Data.Lsp.CodeActions | Option Bool | 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 | 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) | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AccLevelState.ctorIdx | Lean.Elab.MutualInductive | Lean.Elab.Command.AccLevelState✝ → ℕ | false |
List.getLast_tail | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (h : l.tail ≠ []), l.tail.getLast h = l.getLast ⋯ | 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 | 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' := ⋯,
... | false |
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) | 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 | 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 | 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 | true |
isRelLowerSet_empty | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α], IsRelLowerSet ∅ P | true |
Rat.ceil_intCast | Init.Data.Rat.Lemmas | ∀ (a : ℤ), (↑a).ceil = a | true |
FirstOrder.Language.Term.varFinset._unsafe_rec | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [DecidableEq α] → L.Term α → Finset α | 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... | 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... | 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 | 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) | true |
_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) | false |
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) | 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 | 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 | true |
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 | true |
_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... | 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 | 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 | 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ι | true |
List.recOn.eq._@.Mathlib.Util.CompileInductive.1590845460._hygCtx._hyg.6 | Mathlib.Util.CompileInductive | @List.recOn = @List.recOn✝ | false |
Lean.Meta.instReprConfig_1 | Init.Meta.Defs | Repr Lean.Meta.Simp.Config | 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... | 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 | 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 | false |
one_div_mul_eq_div | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), 1 / a * b = b / a | 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 | 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) | 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 | 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 | 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... | 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 | 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 | 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 | 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 | true |
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],
MeasureT... | true |
_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 | true |
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 | 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) | false |
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 | false |
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) | true |
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 | false |
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 ... | true |
Units.instCommGroupUnits.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u_1} [inst : CommMonoid α], Units.instCommGroupUnits = { toGroup := Units.instGroup, mul_comm := ⋯ } | true |
Ordnode.map._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → {β : Type u_2} → (α → β) → Ordnode α → Ordnode β | false |
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 | true |
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 | true |
Lean.Server.DirectImports.ordered | Lean.Server.References | Lean.Server.DirectImports → Array Lean.Server.ModuleImport | true |
CategoryTheory.SmallObject.transfiniteCompositionOfShapeιIterationAppRight._proof_3 | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ (κ : Cardinal.{u_1}) (j : κ.ord.ToType), j ≤ Order.succ j | false |
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 | false |
Mathlib.Tactic.TFAE.proveChain._unsafe_rec | Mathlib.Tactic.TFAE | Array (ℕ × ℕ × Lean.Expr) →
Array Q(Prop) →
ℕ → List ℕ → (P : Q(Prop)) → (l : Q(List Prop)) → Lean.MetaM Q(List.IsChain (fun x1 x2 => x1 → x2) («$P» :: «$l»)) | false |
CategoryTheory.Functor.currying_inverse_obj_obj_obj | Mathlib.CategoryTheory.Functor.Currying | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
{E : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E) (X : C) (Y : D),
((CategoryTheory.Functor.currying.inverse.obj F).obj X).obj Y = F.obj (X, Y) | true |
Nondet.filterM | Batteries.Control.Nondet.Basic | {σ : Type} →
{m : Type → Type} →
[Monad m] → [inst : Lean.MonadBacktrack σ m] → {α : Type} → (α → m (ULift.{0, 0} Bool)) → Nondet m α → Nondet m α | true |
CategoryTheory.Hom.addEquivCongrRight.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N : C} [inst_2 : CategoryTheory.AddMonObj M] [inst_3 : CategoryTheory.AddMonObj N] (e : M ≅ N)
[inst_4 : CategoryTheory.IsAddMonHom e.hom] (X : C),
CategoryTheory.Hom.addEquivCongrRight e X =
... | true |
NonUnitalAlgHom.snd_prod | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} [inst : Monoid R] {A : Type v} {B : Type w} {C : Type w₁} [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : NonUnitalNonAssocSemiring C]
[inst_5 : DistribMulAction R B] [inst_6 : DistribMulAction R C] (f : A →ₙₐ[R] B) (g : A →ₙₐ[R]... | true |
_private.Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace.0.volumePreservingSymmMeasurableEquivToLpProdAux._proof_4 | Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace | ∀ (U : Type u_1) [inst : NormedAddCommGroup U] [inst_1 : InnerProductSpace ℝ U], BorelSpace (PiLp 2 fun x => ℝ) | false |
NonUnitalIsometricContinuousFunctionalCalculus.norm_quasispectrum_le._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | false |
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.splitTarget?.go._unsafe_rec | Lean.Meta.Tactic.Split | Lean.MVarId → Bool → Bool → Lean.Expr → Lean.ExprSet → Lean.MetaM (Option (List Lean.MVarId)) | false |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieIdeal.coe_lcs_eq._simp_1_2 | Mathlib.Algebra.Lie.Nilpotent | ∀ {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] (x : M), (x ∈ ⊤) = True | false |
WeierstrassCurve.Jacobian.Point.mk_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} [inst_1 : Nontrivial R] {X Y : R}
(h : W'.NonsingularLift ⟦![X, Y, 1]⟧), { point := ⟦![X, Y, 1]⟧, nonsingular := h } ≠ 0 | true |
MvPowerSeries.coeff_mul_left_one_sub_of_lt_order | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_3} [inst : Ring R] {f g : MvPowerSeries σ R} (d : σ →₀ ℕ),
↑(Finsupp.degree d) < g.order → (MvPowerSeries.coeff d) (f * (1 - g)) = (MvPowerSeries.coeff d) f | true |
Lean.Parser.Term.completion.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | true |
AffineSubspace.mem_direction_iff_eq_vsub_left | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p : P}, p ∈ s → ∀ (v : V), v ∈ s.direction ↔ ∃ p₂ ∈ s, v = p -ᵥ p₂ | true |
Subalgebra.finrank_right_dvd_finrank_sup_of_free | Mathlib.Algebra.Algebra.Subalgebra.Rank | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A B : Subalgebra R S)
[Module.Free R ↥B] [Module.Free ↥B ↥(Algebra.adjoin ↥B ↑A)], Module.finrank R ↥B ∣ Module.finrank R ↥(A ⊔ B) | true |
Prod.instSubsingletonUnits | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : Monoid M] [inst_1 : Monoid N] [Subsingleton Mˣ] [Subsingleton Nˣ],
Subsingleton (M × N)ˣ | true |
UInt32.ofBitVec_mod | Init.Data.UInt.Lemmas | ∀ (a b : BitVec 32), { toBitVec := a % b } = { toBitVec := a } % { toBitVec := b } | true |
Aesop.instInhabitedRule.default | Aesop.Rule.Basic | {a : Type} → [Inhabited a] → Aesop.Rule a | true |
CategoryTheory.CartesianMonoidalCategory.mono_lift_of_mono_right | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{W X Y : C} (f : W ⟶ X) (g : W ⟶ Y) [CategoryTheory.Mono g],
CategoryTheory.Mono (CategoryTheory.CartesianMonoidalCategory.lift f g) | true |
Subgroup.rightCosetEquivSubgroup.eq_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} (g : α),
Subgroup.rightCosetEquivSubgroup g =
{ toFun := fun x => ⟨↑x * g⁻¹, ⋯⟩, invFun := fun x => ⟨↑x * g, ⋯⟩, left_inv := ⋯, right_inv := ⋯ } | true |
CategoryTheory.Localization.Lifting₂.ctorIdx | Mathlib.CategoryTheory.Localization.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D₁ : Type u_3} →
{D₂ : Type u_4} →
{E : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} D₁} →
{inst_3 ... | false |
_private.Mathlib.Algebra.Polynomial.Degree.Defs.0.Polynomial.degree_le_iff_coeff_zero._simp_1_2 | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
(s.sup f ≤ a) = ∀ b ∈ s, f b ≤ a | false |
_private.Mathlib.Topology.Connected.Clopen.0.nonempty_frontier_iff._simp_1_1 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {s : Set α}, s.Nonempty = (s ≠ ∅) | false |
SimpleGraph.IsClique.of_induce | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {S : G.Subgraph} {F : Set α} {A : Set ↑F},
(S.induce F).coe.IsClique A → G.IsClique (Subtype.val '' A) | true |
ULift.seminormedCommRing._proof_15 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (n : ℕ) (a : ULift.{u_1, u_2} α),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | false |
NonarchAddGroupNorm.rec | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : NonarchAddGroupNorm G → Sort u} →
((toNonarchAddGroupSeminorm : NonarchAddGroupSeminorm G) →
(eq_zero_of_map_eq_zero' : ∀ (x : G), toNonarchAddGroupSeminorm.toFun x = 0 → x = 0) →
motive
{ toNonarchAddGroupSeminorm := toNon... | false |
exteriorPower.pairingDual | Mathlib.LinearAlgebra.ExteriorPower.Pairing | (R : Type u_1) →
(M : Type u_2) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (n : ℕ) → ↥(⋀[R]^n (Module.Dual R M)) →ₗ[R] Module.Dual R ↥(⋀[R]^n M) | true |
Ordinal.cof_eq | Mathlib.SetTheory.Cardinal.Cofinality | ∀ (α : Type u) [inst : Preorder α], ∃ s, IsCofinal s ∧ Cardinal.mk ↑s = Order.cof α | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.