name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
OmegaCompletePartialOrder.ContinuousHom.ωSup._proof_1 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_1} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(c : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c' : OmegaCompletePartialOrder.Chain α) (a : β),
(OmegaCompletePartialOrder.ωSup (c.map OmegaCompletePartialOrder.ContinuousHom.toMono)).toFun
(OmegaCo... | false |
MulEquiv.funUnique._proof_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ (α : Type u_2) (M : Type u_1) [inst : Mul M] [inst_1 : Unique α] (x y : α → M),
(Equiv.funUnique α M).toFun (x * y) = (Equiv.funUnique α M).toFun x * (Equiv.funUnique α M).toFun y | false |
HasFDerivAt.multiset_prod | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_5} {𝔸' : Type u_7} [inst_3 : NormedCommRing 𝔸'] [inst_4 : NormedAlgebra 𝕜 𝔸']
{g : ι → E → 𝔸'} {g' : ι → E →L[𝕜] 𝔸'} [inst_5 : DecidableEq ι] {u : Multiset ι} {x : E},
... | true |
_private.Mathlib.Algebra.Module.SpanRank.0.Submodule.spanRank_toENat_eq_iInf_finset_card._simp_1_1 | Mathlib.Algebra.Module.SpanRank | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (iInf s = ⊤) = ∀ (i : ι), s i = ⊤ | false |
instAddLeftCancelSemigroupPNat._proof_2 | Mathlib.Data.PNat.Basic | IsLeftCancelAdd ℕ+ | false |
FinTopCat.instHasForget₂ContinuousMapCarrierToTopFintypeCatHomObjFinite._proof_3 | Mathlib.Topology.Category.FinTopCat | ∀ {X Y : FinTopCat} {f : X ⟶ Y},
(CategoryTheory.forget FintypeCat).map (FintypeCat.homMk ⇑(CategoryTheory.ConcreteCategory.hom f)) ≍
(CategoryTheory.forget FintypeCat).map (FintypeCat.homMk ⇑(CategoryTheory.ConcreteCategory.hom f)) | false |
Std.ExtHashSet.size_diff_add_size_inter_eq_size_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ \ m₂).size + (m₁ ∩ m₂).size = m₁.size | true |
Ideal.connectedComponentOfZero._proof_2 | Mathlib.Topology.Algebra.Ring.Ideal | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R] (c x : R),
x ∈ (AddSubgroup.connectedComponentOfZero R).carrier → c • x ∈ connectedComponent 0 | false |
_private.Mathlib.MeasureTheory.Measure.OpenPos.0.IsMeagre.of_isSigmaCompact_null.match_1_1 | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} (K : ℕ → Set X) (t : Set X) (motive : t ∈ Set.range K → Prop) (x : t ∈ Set.range K),
(∀ (n : ℕ) (hn : K n = t), motive ⋯) → motive x | false |
Matrix.mulVecLin_reindex | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {k : Type u_2} {l : Type u_3} {m : Type u_4} {n : Type u_5}
[inst_1 : Fintype n] [inst_2 : Fintype l] (e₁ : k ≃ m) (e₂ : l ≃ n) (M : Matrix k l R),
((Matrix.reindex e₁ e₂) M).mulVecLin =
↑(LinearEquiv.funCongrLeft R R e₁.symm) ∘ₗ M.mulVecLin ∘ₗ ↑(LinearEquiv.funCongrLeft... | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat.0.SSet.Truncated.HomotopyCategory.subsingleton_hom._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ (X : SSet.Truncated 2)
[Subsingleton (X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := SSet.Truncated.ι0₂._proof_4 }))]
(x y : SSet.OneTruncation₂ X), Subsingleton (x ⟶ y) | false |
Ordinal.CNF.snd_lt | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {b o : Ordinal.{u}}, 1 < b → ∀ {x : Ordinal.{u} × Ordinal.{u}}, x ∈ Ordinal.CNF b o → x.2 < b | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.disjoint_iff._simp_1_3 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {f : Filter α}, (f ≠ ⊥) = f.NeBot | false |
Std.Do.Spec.Iter.forIn_map | Std.Do.Triple.SpecLemmas | ∀ {α β β₂ γ : Type w} [inst : Std.Iterator α Id β] {ps : Std.Do.PostShape} {n : Type w → Type u_1} [inst_1 : Monad n]
[LawfulMonad n] [inst_3 : Std.Do.WPMonad n ps] [Std.Iterators.Finite α Id] [inst_5 : Std.IteratorLoop α Id n]
[Std.LawfulIteratorLoop α Id n] {it : Std.Iter β} {f : β → β₂} {init : γ} {g : β₂ → γ → ... | true |
Vector.mk_isPrefixOf_mk | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] {xs ys : Array α} (h : xs.size = n) (h' : ys.size = n),
(Vector.mk xs h).isPrefixOf (Vector.mk ys h') = xs.isPrefixOf ys | true |
AddSubgroup.continuousVAdd | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X] [inst_2 : AddGroup M]
[inst_3 : AddAction M X] [ContinuousVAdd M X] {S : AddSubgroup M}, ContinuousVAdd (↥S) X | true |
CategoryTheory.Limits.CompleteLattice.finiteColimitCocone._proof_2 | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u_2} {J : Type u_1} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
[inst_2 : SemilatticeSup α] [inst_3 : OrderBot α] (F : CategoryTheory.Functor J α)
(s : CategoryTheory.Limits.Cocone F) (j : J),
CategoryTheory.CategoryStruct.comp
({ pt := Finset.univ.sup F.obj, ... | false |
Real.Angle.toReal_neg_iff_sign_neg | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, θ.toReal < 0 ↔ θ.sign = -1 | true |
Array.extract.loop.eq_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (as : Array α) (i j : ℕ) (bs : Array α),
Array.extract.loop as i j bs =
if hlt : j < as.size then
match i with
| 0 => bs
| i'.succ => Array.extract.loop as i' (j + 1) (bs.push (as.getInternal j hlt))
else bs | true |
NonUnitalRingHom.srange_eq_top_iff_surjective | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] {F : Type u_1} [inst_1 : FunLike F R S]
[inst_2 : NonUnitalNonAssocSemiring S] [inst_3 : NonUnitalRingHomClass F R S] {f : F},
NonUnitalRingHom.srange f = ⊤ ↔ Function.Surjective ⇑f | true |
Std.DHashMap.get?_insert_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{v : β k}, (m.insert k v).get? k = some v | true |
Std.Time.PlainTime.toHours | Std.Time.Time.PlainTime | Std.Time.PlainTime → Std.Time.Hour.Offset | true |
_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix.go._unsafe_rec | Lean.Util.Diff | {α : Type u_1} → [BEq α] → Subarray α → Subarray α → ℕ → Subarray α × Subarray α × Array α | false |
FormalMultilinearSeries.iteratedFDerivSeries._proof_1 | Mathlib.Analysis.Analytic.IteratedFDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | false |
_private.Mathlib.Analysis.Normed.Group.Ultra.0.IsUltrametricDist.exists_norm_finset_sum_le_of_nonempty.match_1_1 | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_2} {ι : Type u_1} [inst : SeminormedAddCommGroup M] {t : Finset ι} (ht : t.Nonempty) (f : ι → M)
(motive : (∃ i ∈ t, (t.sup' ht fun x => ‖f x‖) = ‖f i‖) → Prop) (x : ∃ i ∈ t, (t.sup' ht fun x => ‖f x‖) = ‖f i‖),
(∀ (j : ι) (hj : j ∈ t) (hj' : (t.sup' ht fun x => ‖f x‖) = ‖f j‖), motive ⋯) → motive x | false |
AddValuation.map_eq_of_lt_sub | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{x y : R}, v x < v (y - x) → v y = v x | true |
instShiftLeftUSize | Init.Data.UInt.Basic | ShiftLeft USize | true |
_private.Mathlib.Order.Filter.Pi.0.Filter.tendsto_pi._simp_1_2 | Mathlib.Order.Filter.Pi | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : α → β} {x : Filter α} {y : ι → Filter β},
Filter.Tendsto f x (⨅ i, y i) = ∀ (i : ι), Filter.Tendsto f x (y i) | false |
CategoryTheory.Pseudofunctor.CoGrothendieck.mapCompIso._proof_2 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} 𝒮]
{F G H : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} (α : F ⟶ G) (β : G ⟶ H)
{X Y : F.CoGrothendieck} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pseudofunctor.CoGrothendieck.map ... | false |
LieAlgebra.maxNilpotentIdeal_le_radical | Mathlib.Algebra.Lie.Nilpotent | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.maxNilpotentIdeal R L ≤ LieAlgebra.radical R L | true |
Lean.Doc.builtinDocDirectives | Lean.Elab.DocString | IO.Ref (Lean.NameMap (Array (Lean.Name × Lean.Doc.DocDirectiveExpander))) | true |
toAdd_div | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u} [inst : Sub α] (x y : Multiplicative α),
Multiplicative.toAdd (x / y) = Multiplicative.toAdd x - Multiplicative.toAdd y | true |
powMonoidWithZeroHom_apply | Mathlib.Algebra.GroupWithZero.Hom | ∀ {M₀ : Type u_6} [inst : CommMonoidWithZero M₀] {n : ℕ} (hn : n ≠ 0) (a : M₀), (powMonoidWithZeroHom hn) a = a ^ n | true |
_private.Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo.0.CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp_hom._simp_1_2 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : Y ⟶ X) [inst_1 : CategoryTheory.IsIso α]
{f : Z ⟶ X} {g : Z ⟶ Y},
(f = CategoryTheory.CategoryStruct.comp g α) = (CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g) | false |
MonomialOrder.coeff_degree_ne_zero_iff | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {f : MvPolynomial σ R},
MvPolynomial.coeff (m.degree f) f ≠ 0 ↔ f ≠ 0 | true |
SchwartzMap._aux_Mathlib_Analysis_Distribution_TemperedDistribution___unexpand_TemperedDistribution_1 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.PrettyPrinter.Unexpander | false |
Submodule.Quotient.restrictScalarsEquiv_symm_mk | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Type u_3)
[inst_3 : Ring S] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M] (P : Submodule R M)
(x : M), (Submodule.Quotient.restrictScalarsEquiv S P).symm (Submodule.Quotient.mk x) = Submod... | true |
ValueDistribution.characteristic | Mathlib.Analysis.Complex.ValueDistribution.CharacteristicFunction | {E : Type u_1} → [inst : NormedAddCommGroup E] → [NormedSpace ℂ E] → (ℂ → E) → WithTop E → ℝ → ℝ | true |
IsMulTorsionFree.zpow_eq_one_iff | Mathlib.Algebra.Group.Torsion | ∀ {G : Type u_2} [inst : Group G] [IsMulTorsionFree G] {n : ℤ} {a : G}, a ^ n = 1 ↔ a = 1 ∨ n = 0 | true |
Multiset.Icc_eq_zero_iff._simp_1 | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, (Multiset.Icc a b = 0) = ¬a ≤ b | false |
StructureGroupoid.noConfusion | Mathlib.Geometry.Manifold.StructureGroupoid | {P : Sort u} →
{H : Type u_2} →
{inst : TopologicalSpace H} →
{t : StructureGroupoid H} →
{H' : Type u_2} →
{inst' : TopologicalSpace H'} →
{t' : StructureGroupoid H'} → H = H' → inst ≍ inst' → t ≍ t' → StructureGroupoid.noConfusionType P t t' | false |
_private.Mathlib.Data.Part.0.Part.mem_unique.match_1_1 | Mathlib.Data.Part | ∀ {α : Type u_1} (motive : (x x_1 : α) → (x_2 : Part α) → x ∈ x_2 → x_1 ∈ x_2 → Prop) (x x_1 : α) (x_2 : Part α)
(x_3 : x ∈ x_2) (x_4 : x_1 ∈ x_2),
(∀ (Dom : Prop) (get : Dom → α) (w w_1 : { Dom := Dom, get := get }.Dom),
motive ({ Dom := Dom, get := get }.get w) ({ Dom := Dom, get := get }.get w_1) { Dom := ... | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorObj_hom_ext.match_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀
(motive :
(x y z : AugmentedSimplexCategory) →
(f g : CategoryTheory.MonoidalCategoryStruct.tensorObj x y ⟶ z) →
CategoryTheory.CategoryStruct.comp (x.inl y) f = CategoryTheory.CategoryStruct.comp (x.inl y) g →
CategoryTheory.CategoryStruct.comp (x.inr y) f = CategoryTheory.CategoryStruc... | false |
CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Functor_Oplax___unexpand_CategoryTheory_OplaxFunctor_1 | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | Lean.PrettyPrinter.Unexpander | false |
convex_iff_pairwise_pos | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {s : Set E},
Convex 𝕜 s ↔ s.Pairwise fun x y => ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s | true |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.continuous_map_iff._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_3} [inst_1 : TopologicalSpace Y] (f : OnePoint X → Y),
Continuous f =
(Filter.Tendsto (fun x => f ↑x) (Filter.coclosedCompact X) (nhds (f OnePoint.infty)) ∧ Continuous fun x => f ↑x) | false |
CategoryTheory.Idempotents.split_imp_of_iso | Mathlib.CategoryTheory.Idempotents.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X X' : C} (φ : X ≅ X') (p : X ⟶ X) (p' : X' ⟶ X'),
CategoryTheory.CategoryStruct.comp p φ.hom = CategoryTheory.CategoryStruct.comp φ.hom p' →
(∃ Y i e,
CategoryTheory.CategoryStruct.comp i e = CategoryTheory.CategoryStruct.id Y ∧
Ca... | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.IterM.step_filterM.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {β : Type u_1} {n : Type u_1 → Type u_2} {f : β → n (ULift.{u_1, 0} Bool)} [inst : MonadAttach n] (out : β)
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) (hf : MonadAttach.CanReturn (f out) { down := false })
(h_1 : (hf : MonadAttach.CanReturn (f out) { down := false }) → motive ⟨{ down := false }... | true |
Interval.lattice._proof_2 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : DecidableLE α] (s t : Interval α),
(match s, t with
| none, x => ⊥
| x, none => ⊥
| some s, some t =>
if h : s.toProd.1 ≤ t.toProd.2 ∧ t.toProd.1 ≤ s.toProd.2 then
↑{ fst := s.toProd.1 ⊔ t.toProd.1, snd := s.toProd.2 ⊓ t.toProd.2, fst_le_snd := ⋯... | false |
Algebra.IsAlgebraic.algHomEmbeddingOfSplits._proof_3 | Mathlib.FieldTheory.Normal.Closure | ∀ {F : Type u_1} [inst : Field F] (L' : Type u_2) [inst_1 : Field L'] [inst_2 : Algebra F L'], IsScalarTower F F L' | false |
isCyclic_tfae | Mathlib.FieldTheory.KummerExtension | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L],
(primitiveRoots (Module.finrank K L) K).Nonempty →
[IsGalois K L ∧ IsCyclic Gal(L/K),
∃ a,
Irreducible (Polynomial.X ^ Module.finrank K L - Polynomial.C a) ∧
Polynomial... | true |
DivisibleHull.instSMulRat._proof_1 | Mathlib.GroupTheory.DivisibleHull | ∀ (a : ℚ), 0 ≤ |a| | false |
Lean.HeadIndex.sort.sizeOf_spec | Lean.HeadIndex | sizeOf Lean.HeadIndex.sort = 1 | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_Ico_le_integral_of_le._simp_1_3 | Mathlib.Analysis.SumIntegralComparisons | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | false |
_private.Init.PropLemmas.0.and_or_left.match_1_1 | Init.PropLemmas | ∀ {a b c : Prop} (motive : a ∧ (b ∨ c) → Prop) (x : a ∧ (b ∨ c)), (∀ (ha : a) (hbc : b ∨ c), motive ⋯) → motive x | false |
Array.map_set | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α} {i : ℕ} {h : i < xs.size} {a : α},
Array.map f (xs.set i a h) = (Array.map f xs).set i (f a) ⋯ | true |
Cardinal.commSemiring._proof_10 | Mathlib.SetTheory.Cardinal.Order | ∀ (a : Cardinal.{u_1}), 0 * a = 0 | false |
StateTransition.EvalsToInTime.noConfusion | Mathlib.Computability.StateTransition | {P : Sort u} →
{σ : Type u_1} →
{f : σ → Option σ} →
{a : σ} →
{b : Option σ} →
{m : ℕ} →
{t : StateTransition.EvalsToInTime f a b m} →
{σ' : Type u_1} →
{f' : σ' → Option σ'} →
{a' : σ'} →
{b' : Option σ'} →
... | false |
DilationEquivClass.mk | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {F : Type u_1} {X : outParam (Type u_2)} {Y : outParam (Type u_3)} [inst : PseudoEMetricSpace X]
[inst_1 : PseudoEMetricSpace Y] [inst_2 : EquivLike F X Y],
(∀ (f : F), ∃ r, r ≠ 0 ∧ ∀ (x y : X), edist (f x) (f y) = ↑r * edist x y) → DilationEquivClass F X Y | true |
Lean.Elab.Tactic.initFn._@.Lean.Elab.Tactic.Induction.3151586715._hygCtx._hyg.4 | Lean.Elab.Tactic.Induction | IO (Lean.Option Bool) | false |
_private.Lean.Meta.Tactic.Grind.Arith.EvalNum.0.Lean.Meta.Grind.Arith.evalNatCore | Lean.Meta.Tactic.Grind.Arith.EvalNum | Lean.Expr → OptionT Lean.Meta.Grind.GrindM ℕ | true |
Ring.DimensionLEOne.localization | Mathlib.RingTheory.DedekindDomain.Dvr | ∀ {R : Type u_2} (Rₘ : Type u_3) [inst : CommRing R] [IsDomain R] [inst_2 : CommRing Rₘ] [inst_3 : Algebra R Rₘ]
{M : Submonoid R} [IsLocalization M Rₘ], M ≤ nonZeroDivisors R → ∀ [h : Ring.DimensionLEOne R], Ring.DimensionLEOne Rₘ | true |
Lean.CodeAction.CommandCodeActions.noConfusion | Lean.Server.CodeActions.Attr | {P : Sort u} →
{t t' : Lean.CodeAction.CommandCodeActions} → t = t' → Lean.CodeAction.CommandCodeActions.noConfusionType P t t' | false |
NNReal.coe_sub_of_lt._simp_1 | Mathlib.Data.NNReal.Basic | ∀ {a b : NNReal}, a < b → ↑b - ↑a = ↑(b - a) | false |
UniformSpace.Completion.coe_vadd._simp_1 | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : VAdd M X] [UniformContinuousConstVAdd M X] (c : M)
(x : X), c +ᵥ ↑x = ↑(c +ᵥ x) | false |
ContMDiffWithinAt.prodMap' | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
MeasureTheory.Measure.MutuallySingular.zero_left._simp_1 | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
MeasureTheory.Measure.MutuallySingular 0 μ = True | false |
ComplexShape.Embedding.πTruncGENatTrans | Mathlib.Algebra.Homology.Embedding.TruncGE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
(e : c.Embedding c') →
[inst : e.IsTruncGE] →
(C : Type u_4) →
[inst_1 : CategoryTheory.Category.{v_2, u_4} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] ... | true |
AddMonoid.addOrderOf_le_exponent | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : AddMonoid G], AddMonoid.ExponentExists G → ∀ (g : G), addOrderOf g ≤ AddMonoid.exponent G | true |
Std.ExtTreeSet.min!_eq_iff_mem_and_forall | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
[inst_2 : Inhabited α], t ≠ ∅ → ∀ {km : α}, t.min! = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true | true |
TensorProduct.dualDistribEquivOfBasis_apply_apply | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {ι : Type u_5} {κ : Type u_6} [inst : DecidableEq ι]
[inst_1 : DecidableEq κ] [inst_2 : Fintype ι] [inst_3 : Fintype κ] [inst_4 : CommSemiring R]
[inst_5 : AddCommMonoid M] [inst_6 : AddCommMonoid N] [inst_7 : Module R M] [inst_8 : Module R N]
(b : Module.Basis ι R M... | true |
NNReal.sqrt_le_sqrt | Mathlib.Data.Real.Sqrt | ∀ {x y : NNReal}, NNReal.sqrt x ≤ NNReal.sqrt y ↔ x ≤ y | true |
Batteries.CodeAction.matchExpand.match_6 | Batteries.CodeAction.Match | (motive : Option Lean.Elab.TermInfo → Sort u_1) →
(x : Option Lean.Elab.TermInfo) →
((info : Lean.Elab.TermInfo) → motive (some info)) → ((x : Option Lean.Elab.TermInfo) → motive x) → motive x | false |
SimpleGraph.Walk.take_spec | Mathlib.Combinatorics.SimpleGraph.Walks.Decomp | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support),
(p.takeUntil u h).append (p.dropUntil u h) = p | true |
finSuccEquiv'_below | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {i : Fin (n + 1)} {m : Fin n}, m.castSucc < i → (finSuccEquiv' i) m.castSucc = some m | true |
Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[inst : Std.TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF)
(h' : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.filterMap f t ⋯).impl = true),
(f (t.getKey k ⋯) (Std.DTreeMap.Internal... | true |
Lean.Compiler.LCNF.ConfigOptions.recOn | Lean.Compiler.LCNF.ConfigOptions | {motive : Lean.Compiler.LCNF.ConfigOptions → Sort u} →
(t : Lean.Compiler.LCNF.ConfigOptions) →
((smallThreshold maxRecInline maxRecInlineIfReduce : ℕ) →
(checkTypes extractClosed : Bool) →
(maxRecSpecialize : ℕ) →
(resetReuse : Bool) →
motive
{ smallThr... | false |
CategoryTheory.StructuredArrow.isoMk | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{S : D} →
{T : CategoryTheory.Functor C D} →
{f f' : CategoryTheory.StructuredArrow S T} →
(g : f.right ≅ f'.right) →
auto... | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.truncate.go.match_1 | Lean.Server.Completion.CompletionCollectors | (motive : Lean.Name × ℕ → Sort u_1) → (x : Lean.Name × ℕ) → ((p' : Lean.Name) → (len : ℕ) → motive (p', len)) → motive x | false |
_private.Mathlib.Computability.TuringMachine.Tape.0.Turing.ListBlank.append.match_1.eq_2 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (motive : List Γ → Turing.ListBlank Γ → Sort u_2) (a : Γ) (l : List Γ)
(L : Turing.ListBlank Γ) (h_1 : (L : Turing.ListBlank Γ) → motive [] L)
(h_2 : (a : Γ) → (l : List Γ) → (L : Turing.ListBlank Γ) → motive (a :: l) L),
(match a :: l, L with
| [], L => h_1 L
| a :: ... | true |
MeasureTheory.MemLp.aemeasurable | Mathlib.MeasureTheory.Function.LpSeminorm.Defs | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} [inst : ENorm ε] {μ : MeasureTheory.Measure α}
[inst_1 : MeasurableSpace ε] [inst_2 : TopologicalSpace ε] [TopologicalSpace.PseudoMetrizableSpace ε] [BorelSpace ε]
{f : α → ε} {p : ENNReal}, MeasureTheory.MemLp f p μ → AEMeasurable f μ | true |
Lean.Lsp.FileEvent.recOn | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.FileEvent → Sort u} →
(t : Lean.Lsp.FileEvent) →
((uri : Lean.Lsp.DocumentUri) → (type : Lean.Lsp.FileChangeType) → motive { uri := uri, type := type }) → motive t | false |
EuclideanGeometry.inversion_eq_center'._simp_1 | Mathlib.Geometry.Euclidean.Inversion.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c x : P} {R : ℝ}, (EuclideanGeometry.inversion c R x = c) = (x = c ∨ R = 0) | false |
AddMonoidHom.coeToZeroHom | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_4} → {N : Type u_5} → [inst : AddZero M] → [inst_1 : AddZero N] → Coe (M →+ N) (ZeroHom M N) | true |
CategoryTheory.Functor.homologySequence_mono_shift_map_mor₂_iff | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | ∀ {C : Type u_1} {A : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] (F : CategoryTheory.Functor C A)
[inst_3 : CategoryTheory.Limits.HasZeroObject C] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (Categ... | true |
CategoryTheory.GradedObject.isColimitCofan₃MapBifunctorBifunctor₂₃MapObj._proof_6 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_12} {C₂ : Type u_10} {C₃ : Type u_8} {C₄ : Type u_6} {C₂₃ : Type u_14}
[inst : CategoryTheory.Category.{u_11, u_12} C₁] [inst_1 : CategoryTheory.Category.{u_9, u_10} C₂]
[inst_2 : CategoryTheory.Category.{u_7, u_8} C₃] [inst_3 : CategoryTheory.Category.{u_5, u_6} C₄]
[inst_4 : CategoryTheory.Catego... | false |
MeasureTheory.IntegrableOn.comp_neg_Iio | Mathlib.MeasureTheory.Group.Integral | ∀ {G : Type u_4} {F : Type u_6} [inst : MeasurableSpace G] [inst_1 : NormedAddCommGroup F] {μ : MeasureTheory.Measure G}
[inst_2 : PartialOrder G] [inst_3 : AddCommGroup G] [IsOrderedAddMonoid G] [MeasurableNeg G] [μ.IsNegInvariant]
{c : G} {f : G → F},
MeasureTheory.IntegrableOn f (Set.Ioi (-c)) μ → MeasureTheor... | true |
Ne.irrefl | Init.Core | ∀ {α : Sort u} {a : α}, a ≠ a → False | true |
List.zipWith_rotate_distrib | Mathlib.Data.List.Rotate | ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l : List α) (l' : List β) (n : ℕ),
l.length = l'.length → (List.zipWith f l l').rotate n = List.zipWith f (l.rotate n) (l'.rotate n) | true |
differentIdeal.eq_1 | Mathlib.RingTheory.DedekindDomain.Different | ∀ (A : Type u_1) (B : Type u_3) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[inst_4 : IsDedekindDomain B] [inst_5 : Module.IsTorsionFree A B],
differentIdeal A B =
Submodule.comap (Algebra.linearMap B (FractionRing B)) (1 / Submodule.traceDual A (FractionRing A) 1) | true |
CategoryTheory.Triangulated.TStructure.descTruncGT.congr_simp | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | true |
Std.ExtTreeMap.getKey!_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k k' : α} {f : β → β},
(t.modify k f).getKey! k' = if cmp k k' = Ordering.eq then if k ∈ t then k else default else t.getKey! k' | true |
map_rat_smul | Mathlib.Algebra.Module.Rat | ∀ {M : Type u_1} {M₂ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] [_instM : Module ℚ M]
[_instM₂ : Module ℚ M₂] {F : Type u_3} [inst_2 : FunLike F M M₂] [AddMonoidHomClass F M M₂] (f : F) (c : ℚ) (x : M),
f (c • x) = c • f x | true |
_private.Mathlib.Topology.Order.MonotoneConvergence.0.Pi.supConvergenceClass._simp_2 | Mathlib.Topology.Order.MonotoneConvergence | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), f '' s = Set.range (s.restrict f) | false |
NormedRing.induced._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_2} (R : Type u_1) (S : Type u_3) [inst : FunLike F R S] [inst_1 : Ring R] [inst_2 : NormedRing S]
[inst_3 : NonUnitalRingHomClass F R S] (f : F) (hf : Function.Injective ⇑f) {x y : R}, dist x y = 0 → x = y | false |
CategoryTheory.Limits.coconeOfCoconeUncurryIsColimit._proof_3 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_4} {K : Type u_6} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {D : CategoryTheory.Limits.DiagramOfCocones F}
(Q : (j : J) → Cat... | false |
Polynomial.natTrailingDegree_mul' | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
p.trailingCoeff * q.trailingCoeff ≠ 0 → (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree | true |
Finpartition.combine._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {ι : Type u_2} {I : Finset ι}
{a : ι → α} (P : (i : ι) → Finpartition (a i)), (I.biUnion fun i => (P i).parts).sup id = I.sup a | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getMsbD_umod._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ}, ¬i < w → ¬w ≤ i → False | false |
Commute.intCast_right | Mathlib.Data.Int.Cast.Lemmas | ∀ {α : Type u_3} [inst : NonAssocRing α] {a : α} {n : ℤ}, Commute a ↑n | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.