name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Meta.Match.AltLHS.casesOn | Lean.Meta.Match.Basic | {motive : Lean.Meta.Match.AltLHS → Sort u} →
(t : Lean.Meta.Match.AltLHS) →
((ref : Lean.Syntax) →
(fvarDecls : List Lean.LocalDecl) →
(patterns : List Lean.Meta.Match.Pattern) →
motive { ref := ref, fvarDecls := fvarDecls, patterns := patterns }) →
motive t | false |
Polynomial.cyclotomic'.congr_simp | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (n n_1 : ℕ),
n = n_1 →
∀ (R : Type u_2) [inst : CommRing R] [inst_1 : IsDomain R],
Polynomial.cyclotomic' n R = Polynomial.cyclotomic' n_1 R | true |
Finpartition.instFintypeOfDecidableEq._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] (a : α) (i : { p // p.SupIndep id ∧ p.sup id = a ∧ ⊥ ∉ p }),
(↑i).sup id = a | false |
AlgebraicGeometry.Scheme.IdealSheafData.equivOfIsAffine._proof_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} [inst : AlgebraicGeometry.IsAffine X] (I : Ideal ↑(X.presheaf.obj (Opposite.op ⊤))),
(fun x => x.ideal ⟨⊤, ⋯⟩) (AlgebraicGeometry.Scheme.IdealSheafData.ofIdealTop I) = I | false |
Homeomorph.trans_toOpenPartialHomeomorph | Mathlib.Topology.OpenPartialHomeomorph.Composition | ∀ {X : Type u_1} {Y : Type u_3} {Z : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : X ≃ₜ Y) (e' : Y ≃ₜ Z),
(e.trans e').toOpenPartialHomeomorph = e.toOpenPartialHomeomorph.trans e'.toOpenPartialHomeomorph | true |
IsLocalRing.ResidueField.map._proof_1 | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : IsLocalRing R] [inst_2 : CommRing S]
[inst_3 : IsLocalRing S] (f : R →+* S) [IsLocalHom f],
∀ a ∈ IsLocalRing.maximalIdeal R, ((Ideal.Quotient.mk (IsLocalRing.maximalIdeal S)).comp f) a = 0 | false |
MeasureTheory.NullMeasurableSet.compl_iff | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasureTheory.NullMeasurableSet sᶜ μ ↔ MeasureTheory.NullMeasurableSet s μ | true |
Subfield.instMulDistribMulActionSubtypeMem._proof_2 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] {X : Type u_2} [inst_1 : Monoid X] [inst_2 : MulDistribMulAction K X]
(F : Subfield K) (r : ↥F.toSubsemiring), ↑r • 1 = 1 | false |
LinearMap.single | Mathlib.LinearAlgebra.Pi | (R : Type u) →
{ι : Type x} →
[inst : Semiring R] →
(φ : ι → Type i) →
[inst_1 : (i : ι) → AddCommMonoid (φ i)] →
[inst_2 : (i : ι) → Module R (φ i)] → [DecidableEq ι] → (i : ι) → φ i →ₗ[R] (i : ι) → φ i | true |
ApplicativeTransformation.mk.injEq | Mathlib.Control.Traversable.Basic | ∀ {F : Type u → Type v} [inst : Applicative F] {G : Type u → Type w} [inst_1 : Applicative G]
(app : (α : Type u) → F α → G α) (preserves_pure' : ∀ {α : Type u} (x : α), app α (pure x) = pure x)
(preserves_seq' : ∀ {α β : Type u} (x : F (α → β)) (y : F α), app β (x <*> y) = app (α → β) x <*> app α y)
(app_1 : (α ... | true |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.functor_map | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {S : AlgebraicGeometry.Scheme} {J : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} J] {D : CategoryTheory.Functor J (P.Over ⊤ S)} {𝒰 : S.OpenCover}
[inst_3 : CategoryTheory.Ca... | true |
Vector.countP_map | Init.Data.Vector.Count | ∀ {α : Type u_2} {β : Type u_1} {n : ℕ} {p : β → Bool} {f : α → β} {xs : Vector α n},
Vector.countP p (Vector.map f xs) = Vector.countP (p ∘ f) xs | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.intMinSealed_add_intMinSealed | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ {n : ℕ}, BitVec.Signed.intMinSealed✝ n + BitVec.Signed.intMinSealed✝¹ n = 0 | true |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.JoinPointFinder.eraseCandidate | Lean.Compiler.LCNF.JoinPoints | Lean.FVarId → Lean.Compiler.LCNF.JoinPointFinder.FindM Unit | true |
Lean.IR.VarId.noConfusion | Lean.Compiler.IR.Basic | {P : Sort u} → {t t' : Lean.IR.VarId} → t = t' → Lean.IR.VarId.noConfusionType P t t' | false |
AddActionHom.id_comp | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : VAdd M X] {Y : Type u_6} [inst_1 : VAdd N Y]
(f : X →ₑ[φ] Y), (AddActionHom.id N).comp f = f | true |
RCLike.innerProductSpace._proof_3 | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] (x y : 𝕜), (starRingEnd 𝕜) (x * (starRingEnd 𝕜) y) = y * (starRingEnd 𝕜) x | false |
MvPolynomial.rTensor._proof_1 | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
IsScalarTower R S S | false |
Std.Rxi.Iterator.pairwise_toList_upwardEnumerableLt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] [Std.Rxi.IsAlwaysFinite α]
(it : Std.Iter α), List.Pairwise (fun a b => Std.PRange.UpwardEnumerable.LT a b) it.toList | true |
_private.Mathlib.Algebra.Category.MonCat.Basic.0.MonCat.Hom.mk._flat_ctor | Mathlib.Algebra.Category.MonCat.Basic | {A B : MonCat} → (↑A →* ↑B) → A.Hom B | false |
_private.Mathlib.LinearAlgebra.QuadraticForm.Signature.0.sigPos._simp_1 | Mathlib.LinearAlgebra.QuadraticForm.Signature | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | false |
Std.TreeMap.getD_filterMap_of_getKey?_eq_some | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{f : α → β → Option γ} {k k' : α} {fallback : γ},
t.getKey? k = some k' → (Std.TreeMap.filterMap f t).getD k fallback = (t[k]?.bind (f k')).getD fallback | true |
AlgebraicGeometry.«_aux_Mathlib_AlgebraicGeometry_Scheme___delab_app_AlgebraicGeometry_termΓ(_,_)_1» | Mathlib.AlgebraicGeometry.Scheme | Lean.PrettyPrinter.Delaborator.Delab | false |
Std.DHashMap.Const.getD_filter' | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [LawfulBEq α]
{f : α → β → Bool} {k : α} {fallback : β},
Std.DHashMap.Const.getD (Std.DHashMap.filter f m) k fallback =
(Option.filter (f k) (Std.DHashMap.Const.get? m k)).getD fallback | true |
_private.Lean.Elab.Tactic.Simpa.0.Lean.Elab.Tactic.Simpa.evalSimpa.match_15 | Lean.Elab.Tactic.Simpa | (motive : Lean.FVarId × Lean.MVarId → Sort u_1) →
(__discr : Lean.FVarId × Lean.MVarId) → ((h : Lean.FVarId) → (g' : Lean.MVarId) → motive (h, g')) → motive __discr | false |
CategoryTheory.ShortComplex.SnakeInput.L₀X₂ToP.eq_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), S.L₀X₂ToP = CategoryTheory.Limits.pullback.lift S.v₀₁.τ₂ S.L₀.g ⋯ | true |
_private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.rangeOfWType._proof_5 | Mathlib.SetTheory.Cardinal.Subfield | ∀ {α : Type u_1} (s : Set α) [inst : DivisionRing α] {x : ↥(Subfield.closure s)},
x ∈ Set.range (WType.elim (↥(Subfield.closure s)) (Subfield.operate✝ s)) →
-x ∈ Set.range (WType.elim (↥(Subfield.closure s)) (Subfield.operate✝¹ s)) | false |
DFinsupp.filter._proof_2 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → Zero (β i)] (p : ι → Prop) [inst_1 : DecidablePred p]
(x : Π₀ (i : ι), β i) (xs : { s // ∀ (i : ι), i ∈ s ∨ x.toFun i = 0 }) (i : ι), i ∈ ↑xs ∨ (if p i then x i else 0) = 0 | false |
Function.Surjective.monoid._proof_4 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Mul M₂] [inst_1 : Pow M₂ ℕ] [inst_2 : Monoid M₁] (f : M₁ → M₂)
(hf : Function.Surjective f) (mul : ∀ (x y : M₁), f (x * y) = f x * f y),
(∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n) → ∀ (n : ℕ) (y : M₂), y ^ (n + 1) = y ^ n * y | false |
NonUnitalSubring.coe_inf | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (p p' : NonUnitalSubring R), ↑(p ⊓ p') = ↑p ∩ ↑p' | true |
MulHom.coeFn.eq_1 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ (α : Type u_4) (β : Type u_5) [inst : Mul α] [inst_1 : CommSemigroup β],
MulHom.coeFn α β = { toFun := fun g => ⇑g, map_mul' := ⋯ } | true |
Fin.foldr_succ | Init.Data.Fin.Fold | ∀ {n : ℕ} {α : Sort u_1} (f : Fin (n + 1) → α → α) (x : α),
Fin.foldr (n + 1) f x = f 0 (Fin.foldr n (fun i => f i.succ) x) | true |
uniformContinuous_sub_const | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] (a : α),
UniformContinuous fun b => b - a | true |
CategoryTheory.Mon.instCartesianMonoidalCategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M N : CategoryTheory.Mon C) {T : CategoryTheory.Mon C} (f : T ⟶ M)
(g : T ⟶ N),
CategoryTheory.CategoryStruct.comp
((fun {T} f g => { hom := Categ... | false |
CategoryTheory.PreGaloisCategory.isGalois_iff_aux | Mathlib.CategoryTheory.Galois.GaloisObjects | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C] (X : C)
[inst_2 : CategoryTheory.PreGaloisCategory.IsConnected X],
CategoryTheory.PreGaloisCategory.IsGalois X ↔
Nonempty
(CategoryTheory.Limits.IsTerminal
(CategoryTheory.Limits.colimit (Categor... | true |
FreeLieAlgebra.instLieRing._proof_1 | Mathlib.Algebra.Lie.Free | ∀ (R : Type u_1) (X : Type u_2) [inst : CommRing R] (x y z : FreeLieAlgebra R X),
Quot.map₂ (fun x1 x2 => x1 * x2) ⋯ ⋯ (x + y) z =
Quot.map₂ (fun x1 x2 => x1 * x2) ⋯ ⋯ x z + Quot.map₂ (fun x1 x2 => x1 * x2) ⋯ ⋯ y z | false |
OrderedFinpartition.emb_invEmbedding | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition n) (j : Fin n), c.emb (c.index j) (c.invEmbedding j) = j | true |
BumpCovering.mk | Mathlib.Topology.PartitionOfUnity | {ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{s : optParam (Set X) Set.univ} →
(toFun : ι → C(X, ℝ)) →
(LocallyFinite fun i => Function.support ⇑(toFun i)) →
0 ≤ toFun → toFun ≤ 1 → (∀ x ∈ s, ∃ i, ⇑(toFun i) =ᶠ[nhds x] 1) → BumpCovering ι X s | true |
Mathlib.Tactic.Translate.Reorder.rec | Mathlib.Tactic.Translate.Reorder | {motive_1 : Mathlib.Tactic.Translate.Reorder → Sort u} →
{motive_2 : Array (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_3 : List (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_4 : ℕ × Mathlib.Tactic.Translate.Reorder → Sort u} →
((perm : List { l // 2 ≤ l.length }) →
... | false |
CategoryTheory.Pretriangulated.Opposite.complete_distinguished_triangle_morphism | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(T₁ T₂ : Categ... | true |
_private.Lean.Structure.0.Lean.getStructureFieldsFlattenedAux.match_1 | Lean.Structure | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) →
((parentStructName : Lean.Name) → motive (some parentStructName)) → (Unit → motive none) → motive x | false |
exists_lt_lt_of_not_covBy._to_dual_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LT α] {a b : α}, b < a → ¬b ⋖ a → ∃ c < a, b < c | false |
_private.Lean.Server.FileWorker.ExampleHover.0.Lean.Server.FileWorker.Hover.RWState.noConfusion | Lean.Server.FileWorker.ExampleHover | {P : Sort u} →
{t t' : Lean.Server.FileWorker.Hover.RWState✝} → t = t' → Lean.Server.FileWorker.Hover.RWState.noConfusionType✝ P t t' | false |
Lean.Name.isBlackListed | Mathlib.Lean.Expr.Basic | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → Lean.Name → m Bool | true |
Int16.toNatClampNeg_toISize | Init.Data.SInt.Lemmas | ∀ (x : Int16), x.toISize.toNatClampNeg = x.toNatClampNeg | true |
CategoryTheory.Limits.pushoutCoconeOfRightIsoIsLimit | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} →
(f : X ⟶ Y) →
(g : X ⟶ Z) →
[inst_1 : CategoryTheory.IsIso g] →
CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.pushoutCoconeOfRightIso f g) | true |
AddCommGroup.uniqueIntModule._proof_2 | Mathlib.Algebra.Module.NatInt | ∀ {M : Type u_1} [inst : AddCommGroup M] (P : Module ℤ M), P = inferInstance | false |
AddCommGrpCat.uliftFunctorFullyFaithful._proof_2 | Mathlib.Algebra.Category.Grp.Ulift | ∀ {X Y : AddCommGrpCat} (x : X ⟶ Y),
AddCommGrpCat.ofHom
(AddEquiv.ulift.toAddMonoidHom.comp
((AddCommGrpCat.Hom.hom (AddCommGrpCat.uliftFunctor.map x)).comp AddEquiv.ulift.symm.toAddMonoidHom)) =
AddCommGrpCat.ofHom
(AddEquiv.ulift.toAddMonoidHom.comp
((AddCommGrpCat.Hom.hom (AddCommG... | false |
CategoryTheory.Limits.Cofork.isColimitEquivOfIsos._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X ⟶ Y} {X' Y' : C}
(c : CategoryTheory.Limits.Cofork f g) {f' g' : X' ⟶ Y'} (c' : CategoryTheory.Limits.Cofork f' g') (e₀ : X ≅ X')
(e₁ : Y ≅ Y') (e : c.pt ≅ c'.pt)
(comm₁ : CategoryTheory.CategoryStruct.comp e₀.hom f' = CategoryTheor... | false |
Std.ExtHashMap.diff_eq | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], m₁.diff m₂ = m₁ \ m₂ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKeyD_le_maxKeyD_insert._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.createImportInitResults.go.eq_def | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | ∀ {α : Type} (cctx : Lean.Core.Context) (env : Lean.Environment)
(act :
Lean.Name →
Lean.ConstantInfo →
Lean.MetaM (List (α × List (Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry))))
(start stop : ℕ) (tree : Lean.Meta.RefinedDiscrTree.PreDiscrTree α)
(data : Lean.Meta.Refi... | true |
Std.Do.Iter.foldM_mapWithPostcondition | Std.Do.Triple.SpecLemmas | ∀ {ps : Std.Do.PostShape} {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} {o : Type w → Type w'''}
[inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad m] [inst_3 : Monad n] [inst_4 : Monad o]
[LawfulMonad m] [LawfulMonad n] [LawfulMonad o] [inst_8 : Std.Do.WPMonad o ps] [inst_... | true |
invertibleNeg | Mathlib.Algebra.Ring.Invertible | {R : Type u_1} →
[inst : Mul R] → [inst_1 : One R] → [inst_2 : HasDistribNeg R] → (a : R) → [Invertible a] → Invertible (-a) | true |
ContDiffBump._sizeOf_inst | Mathlib.Analysis.Calculus.BumpFunction.Basic | {E : Type u_1} → (c : E) → [SizeOf E] → SizeOf (ContDiffBump c) | false |
Lean.Level.isNeverZero._unsafe_rec | Lean.Level | Lean.Level → Bool | false |
AlgEquiv.ofBijective.congr_simp | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (f f_1 : A₁ →ₐ[R] A₂) (e_f : f = f_1) (hf : Function.Bijective ⇑f),
AlgEquiv.ofBijective f hf = AlgEquiv.ofBijective f_1 ⋯ | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.DerivedValMap | Lean.Compiler.LCNF.ExplicitRC | Type | true |
Lean.Expr.ProdTree.components._unsafe_rec | Mathlib.Tactic.ProdAssoc | Lean.Expr.ProdTree → List Lean.Expr | false |
QuadraticForm.dualProdProdIsometry_toFun | Mathlib.LinearAlgebra.QuadraticForm.Dual | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (a : Module.Dual R (M × N) × M × N),
QuadraticForm.dualProdProdIsometry a = ((a.1 ∘ₗ LinearMap.inl R M N, a.2.1), a.1 ∘ₗ LinearMap.inr R M N, a.2.2... | true |
lipschitzOnWith_neg_iff._simp_1 | Mathlib.Analysis.Normed.Group.Uniform | ∀ {α : Type u_4} {E : Type u_5} [inst : SeminormedAddCommGroup E] [inst_1 : PseudoEMetricSpace α] {K : NNReal}
{f : α → E} {s : Set α}, LipschitzOnWith K (-f) s = LipschitzOnWith K f s | false |
_private.Lean.Meta.Instances.0.Lean.Meta.computeSynthOrder.assignMVarsIn.match_1 | Lean.Meta.Instances | (motive : Option ℕ → Sort u_1) → (x : Option ℕ) → ((i : ℕ) → motive (some i)) → ((x : Option ℕ) → motive x) → motive x | false |
Lean.Elab.Command.openPrivate | Batteries.Tactic.OpenPrivate | Lean.ParserDescr | true |
_private.Mathlib.Data.Fintype.Perm.0.permsOfList.match_1.eq_1 | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_1} (motive : List α → Sort u_2) (h_1 : Unit → motive []) (h_2 : (a : α) → (l : List α) → motive (a :: l)),
(match [] with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_1 () | true |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.minEntryD.match_1.eq_2 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → (a : α) × β a → Sort u_3) (size : ℕ)
(k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (x : (a : α) × β a)
(h_1 : (fallback : (a : α) × β a) → motive Std.DTreeMap.Internal.Impl.leaf fallback)
(h_2 :
(size : ℕ) →
(k : α) ... | true |
Lean.Meta.Grind.add | Lean.Meta.Tactic.Grind.Core | Lean.Expr → Lean.Expr → optParam ℕ 0 → Lean.Meta.Grind.GoalM Unit | true |
Nonneg.unitsHomeomorphPos._proof_4 | Mathlib.Topology.Algebra.Field | ∀ (R : Type u_1) [inst : DivisionSemiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R], AddLeftMono R | false |
smul_zpow | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_3} {H : Type u_4} [inst : Group G] [inst_1 : Group H] [inst_2 : MulAction G H] [SMulCommClass G H H]
[IsScalarTower G H H] (g : G) (a : H) (n : ℤ), (g • a) ^ n = g ^ n • a ^ n | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.UniformSpace.hausdorff.isOpen_inter_nonempty_of_isOpen.match_1_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {U : Set α} (s : Set α) (motive : s ∈ {s | (s ∩ U).Nonempty} → Prop) (h : s ∈ {s | (s ∩ U).Nonempty}),
(∀ (x : α) (hx₁ : x ∈ s) (hx₂ : x ∈ U), motive ⋯) → motive h | false |
NonUnitalSubsemiring.coe_add._simp_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (s : NonUnitalSubsemiring R) (x y : ↥s), ↑x + ↑y = ↑(x + y) | false |
AddMemClass.add._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} {A : Type u_2} [inst : Add M] [inst_1 : SetLike A M] [hA : AddMemClass A M] (S' : A) (a b : ↥S'),
↑a + ↑b ∈ S' | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.sum_Iic_sub._proof_1_5 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ}, ∀ a_1 ≤ n, a_1 < n + 1 | false |
Ultrafilter.neBot' | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_2} (self : Ultrafilter α), (↑self).NeBot | true |
CategoryTheory.Projective.π_epi | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.EnoughProjectives C] (X : C),
CategoryTheory.Epi (CategoryTheory.Projective.π X) | true |
_private.Batteries.Data.List.Basic.0.List.zipWithLeft'TR.go.match_1.splitter | Batteries.Data.List.Basic | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
(motive : List α → List β → Array γ → Sort u_4) →
(x : List α) →
(x_1 : List β) →
(x_2 : Array γ) →
((bs : List β) → (acc : Array γ) → motive [] bs acc) →
((as : List α) → (acc : Array γ) → (as = [... | true |
Nat.sub_eq_iff_eq_add' | Init.Data.Nat.Basic | ∀ {b a c : ℕ}, b ≤ a → (a - b = c ↔ a = b + c) | true |
Std.TreeSet.le_min! | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → ∀ {k : α}, (cmp k t.min!).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true | true |
MultilinearMap.mkContinuousLinear._proof_2 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_4} {ι : Type u_1} {E : ι → Type u_2} {G : Type u_5} {G' : Type u_3} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[i... | false |
conjugate_le_conjugate_of_nonneg | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{a b : R}, a ≤ b → ∀ {c : R}, 0 ≤ c → c * a * c ≤ c * b * c | true |
AddMonoidHom.ofLeftInverse.eq_1 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {g : N →+ G}
(h : Function.LeftInverse ⇑g ⇑f),
AddMonoidHom.ofLeftInverse h =
{ toFun := ⇑f.rangeRestrict, invFun := ⇑g ∘ ⇑f.range.subtype, left_inv := h, right_inv := ⋯, map_add' := ⋯ } | true |
Lean.Doc.PostponedName.recOn | Lean.Elab.DocString.Builtin.Postponed | {motive : Lean.Doc.PostponedName → Sort u} →
(t : Lean.Doc.PostponedName) → ((name : Lean.Name) → motive { name := name }) → motive t | false |
List.singleton | Init.Data.List.Basic | {α : Type u} → α → List α | true |
Classical.byContradiction' | Mathlib.Logic.Basic | {α : Sort u_2} → (¬∀ (a : α), False) → α | true |
MeasureTheory.contDiffOn_convolution_left_with_param | Mathlib.Analysis.Calculus.ContDiff.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} {P : Type uP} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] [inst_3 : RCLike 𝕜] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace ℝ F] [inst_7 : NormedSpace 𝕜 F... | true |
CategoryTheory.AddMon.instSymmetricCategory._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (X : CategoryTheory.AddMon C) {Y Z : CategoryTheory.AddMon C}
(f : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft... | false |
CategoryTheory.instLaxMonoidalOfTypeFunctor._proof_4 | Mathlib.CategoryTheory.Monoidal.Functor.Types | ∀ (F : Type u_1 → Type u_2) [inst : Applicative F] [inst_1 : LawfulApplicative F] {X Y : Type u_1} (X' : Type u_1)
(f : X ⟶ Y),
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.ofTypeFunctor F).obj X')
((CategoryTheory.ofTypeFunctor F).map f))
... | false |
coe_smulCardAddSubgroup | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : AddGroup G] [inst_1 : Fintype G] (S : Set G) (hS : S.Nonempty),
↑(smulCardAddSubgroup S hS) = Fintype.card G • S | true |
_private.Mathlib.LinearAlgebra.Matrix.SesquilinearForm.0.mem_pairSelfAdjointMatricesSubmodule._simp_1_3 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M : Type u_5} {M₂ : Type u_7} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup M₂] [inst_4 : Module R M₂] {B F : M →ₗ[R] M →ₗ[R] M₂} (f : Module.End R M),
(f ∈ B.isPairSelfAdjointSubmodule F) = B.IsPairSelfAdjoint F ⇑f | false |
Subgroup.npow_mem_zpowers | Mathlib.Algebra.Group.Subgroup.ZPowers.Basic | ∀ {G : Type u_1} [inst : Group G] (g : G) (k : ℕ), g ^ k ∈ Subgroup.zpowers g | true |
UInt64.toUInt32_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ},
UInt64.size ≤ n →
(UInt64.ofNatTruncate n).toUInt32 = UInt32.ofNatLT (UInt32.size - 1) UInt64.toUInt32_ofNatTruncate_of_le._proof_1 | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.toRatVec | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | {ι : Type u_3} → (ι → ℕ) →+ ι → ℚ | true |
PreQuasiregular.instMonoid._proof_8 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (x : PreQuasiregular R), x * 1 = x | false |
MvPowerSeries.WithPiTopology.hasSum_iff_hasSum_coeff | Mathlib.RingTheory.MvPowerSeries.PiTopology | ∀ {σ : Type u_1} {R : Type u_2} [inst : TopologicalSpace R] [inst_1 : Semiring R] {ι : Type u_3}
{f : ι → MvPowerSeries σ R} {g : MvPowerSeries σ R},
HasSum f g ↔ ∀ (d : σ →₀ ℕ), HasSum (fun i => (MvPowerSeries.coeff d) (f i)) ((MvPowerSeries.coeff d) g) | true |
wellQuasiOrdered_iff_exists_monotone_subseq | Mathlib.Order.WellQuasiOrder | ∀ {α : Type u_1} {r : α → α → Prop} [IsPreorder α r],
WellQuasiOrdered r ↔ ∀ (f : ℕ → α), ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (g m)) (f (g n)) | true |
Lean.JsonNumber.mk.injEq | Lean.Data.Json.Basic | ∀ (mantissa : ℤ) (exponent : ℕ) (mantissa_1 : ℤ) (exponent_1 : ℕ),
({ mantissa := mantissa, exponent := exponent } = { mantissa := mantissa_1, exponent := exponent_1 }) =
(mantissa = mantissa_1 ∧ exponent = exponent_1) | true |
Polynomial.natDegree_map | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} {S : Type v} [inst : Ring R] [IsSimpleRing R] [inst_2 : Semiring S] [Nontrivial S] {p : Polynomial R}
(f : R →+* S), (Polynomial.map f p).natDegree = p.natDegree | true |
Submodule.smithNormalFormBotBasis_def | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsDomain R] [inst_4 : IsPrincipalIdealRing R] {N : Submodule R M} [inst_5 : Finite ι]
(b : Module.Basis ι R M) (h : Module.finrank R ↥N = Module.finrank R M) (i : ι),
↑((Submodule.smithNorm... | true |
NumberField.discr_ne_zero | Mathlib.NumberTheory.NumberField.Discriminant.Defs | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K], NumberField.discr K ≠ 0 | true |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.Iso.isTree_iff.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V} (motive : G.IsTree → Prop) (x : G.IsTree),
(∀ (hc : G.Connected) (ha : G.IsAcyclic), motive ⋯) → motive x | false |
BitVec.setWidth_eq_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {v : ℕ} {x : BitVec v} {w : ℕ}, w ≤ v → BitVec.setWidth w x = BitVec.extractLsb' 0 w x | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.