name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Mathlib.Tactic.LibraryRewrite.rw??Command | Mathlib.Tactic.Widget.LibraryRewrite | Lean.ParserDescr | true |
Submodule.comm_trans_rTensorOne | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (M : Submodule R S),
TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne = M.lTensorOne | true |
Std.DHashMap.Raw.getD.congr_simp | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α]
(m m_1 : Std.DHashMap.Raw α β),
m = m_1 → ∀ (a : α) (fallback fallback_1 : β a), fallback = fallback_1 → m.getD a fallback = m_1.getD a fallback_1 | true |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.SimpHaveResult | Lean.Meta.Sym.Simp.Have | Type | true |
ZSpan.fractRestrict_surjective | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι], Function.Surjective (ZSpan.fractRestrict b) | true |
Lean.Grind.IntModule.add_zsmul | Init.Grind.Module.Basic | ∀ {M : Type u} [self : Lean.Grind.IntModule M] (n m : ℤ) (a : M), (n + m) • a = n • a + m • a | true |
IsAlgClosure.isAlgClosed | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (R : Type u) {K : Type v} {inst : CommRing R} {inst_1 : Field K} {inst_2 : Algebra R K}
{inst_3 : Module.IsTorsionFree R K} [self : IsAlgClosure R K], IsAlgClosed K | true |
modularCyclotomicCharacter.congr_simp | Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | ∀ (L : Type u) [inst : CommRing L] [inst_1 : IsDomain L] {n : ℕ} [inst_2 : NeZero n]
(hn : Fintype.card ↥(rootsOfUnity n L) = n), modularCyclotomicCharacter L hn = modularCyclotomicCharacter L hn | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int8.instUpwardEnumerable._proof_2 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int8), Int8.minValue.toInt ≤ i.toInt → Int8.minValue.toInt ≤ i.toInt + ↑n | false |
Submodule.mem_toNonUnitalSubalgebra | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
{p : Submodule R A} {h_mul : ∀ (x y : A), x ∈ p → y ∈ p → x * y ∈ p} {x : A},
x ∈ p.toNonUnitalSubalgebra h_mul ↔ x ∈ p | true |
Subgroup.strictPeriods.eq_1 | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)),
𝒢.strictPeriods = AddSubgroup.comap Matrix.GeneralLinearGroup.upperRightHom.toAddMonoidHom (Subgroup.toAddSubgroup 𝒢) | true |
Lean.Elab.Term.elabMutualDef | Lean.Elab.MutualDef | Array Lean.Expr → Lean.Elab.Command.Scope → Array Lean.Elab.DefView → Lean.Elab.TermElabM Unit | true |
USize | Init.Prelude | Type | true |
PNat.findX._proof_2 | Mathlib.Data.PNat.Find | ∀ {p : ℕ+ → Prop} (n : { n // (∃ n_1, ∃ (_ : n = ↑n_1), p n_1) ∧ ∀ m < n, ¬∃ n, ∃ (_ : m = ↑n), p n }), 0 < ↑n | false |
CategoryTheory.Preadditive.isCoseparating_iff | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(P : CategoryTheory.ObjectProperty C),
P.IsCoseparating ↔
∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (G : C), P G → ∀ (h : Y ⟶ G), CategoryTheory.CategoryStruct.comp f h = 0) → f = 0 | true |
AlgebraicGeometry.Scheme.Cover.Hom.sigma._proof_1 | Mathlib.AlgebraicGeometry.Cover.Sigma | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {S : AlgebraicGeometry.Scheme}
[inst : AlgebraicGeometry.IsZariskiLocalAtSource P] [inst_1 : UnivLE.{u_1, u_2}]
{𝒰 𝒱 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S} (f : 𝒰 ⟶ 𝒱) (x : 𝒰.sigma.I₀)
(b : 𝒰.I₀),
Catego... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.toList_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
UInt8.reduceToNat._regBuiltin.UInt8.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.354 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
εNFA.IsPath.below.rec | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} {M : εNFA α σ} {motive : (a a_1 : σ) → (a_2 : List (Option α)) → M.IsPath a a_1 a_2 → Prop}
{motive_1 : {a a_1 : σ} → {a_2 : List (Option α)} → (t : M.IsPath a a_1 a_2) → εNFA.IsPath.below t → Prop},
(∀ (s : σ), motive_1 ⋯ ⋯) →
(∀ (t s u : σ) (a : Option α) (x : List (Option α)) (a_1... | false |
Int.mul_add_emod_self_right | Init.Data.Int.DivMod.Bootstrap | ∀ (a b c : ℤ), (a * b + c) % b = c % b | true |
Aesop.SearchM.State.ctorIdx | Aesop.Search.SearchM | {Q : Type} → {inst : Aesop.Queue Q} → Aesop.SearchM.State Q → ℕ | false |
Aesop.Check.script.steps | Aesop.Check | Aesop.Check | true |
SSet.N.iSup_subcomplex_eq_top | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ (X : SSet), ⨆ s, s.subcomplex = ⊤ | true |
SlashInvariantForm.constℝ_toFun | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetPlusMinusOne] (x : ℝ),
⇑(SlashInvariantForm.constℝ x) = Function.const UpperHalfPlane ↑x | true |
AlgebraicGeometry.IsAffineOpen.isLocalization_of_eq_basicOpen | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ (f : ↑(X.presheaf.obj (Opposite.op U))) {V : X.Opens} (i : V ⟶ U),
V = X.basicOpen f → IsLocalization.Away f ↑(X.presheaf.obj (Opposite.op V)) | true |
starRingEquiv | Mathlib.Algebra.Star.Basic | {R : Type u} → [inst : NonUnitalNonAssocSemiring R] → [StarRing R] → R ≃+* Rᵐᵒᵖ | true |
Finsupp.embDomain_refl | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M], Finsupp.embDomain (Function.Embedding.refl α) = id | true |
AlgebraicGeometry.StructureSheaf.globalSectionsIso._proof_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u_1) [inst : CommRing R],
NonUnitalRingHomClass (R →+* (AlgebraicGeometry.structureSheafInType R R).obj.obj (Opposite.op ⊤)) R
((AlgebraicGeometry.structureSheafInType R R).obj.obj (Opposite.op ⊤)) | false |
CategoryTheory.GrothendieckTopology.pointBot._proof_3 | Mathlib.CategoryTheory.Sites.Point.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.LocallySmall.{u_3, u_2, u_1} C]
(X : C) {U : C},
∀ R ∈ ⊥ U,
∀ (x : (CategoryTheory.shrinkYoneda.{u_3, u_2, u_1}.flip.obj (Opposite.op X)).obj U),
∃ Y f, ∃ (_ : R.arrows f), ∃ y, (CategoryTheory.shrinkYoneda.{u_3, u_2, ... | false |
Std.DTreeMap.Raw.Const.get!_eq_default | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : Inhabited β], t.WF → ∀ {a : α}, a ∉ t → Std.DTreeMap.Raw.Const.get! t a = default | true |
AnalyticOn.log | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | ∀ {f : ℝ → ℝ} {s : Set ℝ}, AnalyticOn ℝ f s → (∀ x ∈ s, 0 < f x) → AnalyticOn ℝ (fun z => Real.log (f z)) s | true |
IsGaloisGroup.algebraMap_ringEquiv_apply | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (A : Type u_2) (A' : Type u_3) (B : Type u_4) [inst : Group G] [inst_1 : CommSemiring A]
[inst_2 : Semiring B] [inst_3 : Algebra A B] [inst_4 : MulSemiringAction G B] [inst_5 : FaithfulSMul A B]
[hA : IsGaloisGroup G A B] [inst_6 : CommSemiring A'] [inst_7 : Algebra A' B] [inst_8 : FaithfulSMul A' ... | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.Const.entryAtIdxD.match_1.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : Type u_2} (motive : (Std.DTreeMap.Internal.Impl α fun x => β) → ℕ → α × β → Sort u_3) (size : ℕ)
(k : α) (v : β) (l r : Std.DTreeMap.Internal.Impl α fun x => β) (n : ℕ) (fallback : α × β)
(h_1 : (x : ℕ) → (fallback : α × β) → motive Std.DTreeMap.Internal.Impl.leaf x fallback)
(h_2 :
(siz... | true |
Lean.Server.Watchdog.ServerContext.referenceData | Lean.Server.Watchdog | Lean.Server.Watchdog.ServerContext → Std.Mutex Lean.Server.Watchdog.ReferenceData | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.u | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option Std.Time.Year.Offset | true |
Std.Internal.List.containsKey_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {he : l.isEmpty = false}, Std.Internal.List.containsKey (Std.Internal.List.minKey l he) l = true | true |
IsLocalRing.instCommRingResidueField._proof_7 | Mathlib.RingTheory.LocalRing.ResidueField.Defs | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsLocalRing R] (a : IsLocalRing.ResidueField R), a + 0 = a | false |
WittVector.wittMulN.congr_simp | Mathlib.RingTheory.WittVector.MulP | ∀ (p p_1 : ℕ) (e_p : p = p_1) [hp : Fact (Nat.Prime p)] (a a_1 : ℕ),
a = a_1 → ∀ (a_2 a_3 : ℕ), a_2 = a_3 → WittVector.wittMulN p a a_2 = WittVector.wittMulN p_1 a_1 a_3 | true |
Equiv.Perm.sign_permCongr | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u} [inst : DecidableEq α] {β : Type v} [inst_1 : Fintype α] [inst_2 : DecidableEq β] [inst_3 : Fintype β]
(e : α ≃ β) (p : Equiv.Perm α), Equiv.Perm.sign (e.permCongr p) = Equiv.Perm.sign p | true |
_private.Mathlib.Topology.Order.0.TopologicalSpace.nhds_generateFrom.match_1_1 | Mathlib.Topology.Order | ∀ {α : Type u_1} {g : Set (Set α)} {a : α} (s : Set α) (motive : s ∈ {s | a ∈ s ∧ s ∈ g} → Prop)
(x : s ∈ {s | a ∈ s ∧ s ∈ g}), (∀ (as : a ∈ s) (sg : s ∈ g), motive ⋯) → motive x | false |
typeToPartialFunIsoPartialFunToPointed._proof_6 | Mathlib.CategoryTheory.Category.PartialFun | ∀ {X Y : Type u_1} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((typeToPartialFun.comp partialFunToPointed).map f)
{ hom := { toFun := id, map_point := ⋯ }, inv := { toFun := id, map_point := ⋯ }, hom_inv_id := ⋯,
inv_hom_id := ⋯ }.hom =
CategoryTheory.CategoryStruct.comp
{ hom := { toFu... | false |
Batteries.RBNode.IsCut.le_lt_trans | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} [self : Batteries.RBNode.IsCut cmp cut] {x y : α}
[Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut x = Ordering.lt → cut y = Ordering.lt | true |
CoalgEquiv.ext | Mathlib.RingTheory.Coalgebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : CoalgebraStruct R A]
[inst_6 : CoalgebraStruct R B] {e e' : A ≃ₗc[R] B}, (∀ (x : A), e x = e' x) → e = e' | true |
CategoryTheory.FreeMonoidalCategory.Hom.tensor.inj | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} {W X Y Z : CategoryTheory.FreeMonoidalCategory C} {f : W.Hom Y} {g : X.Hom Z} {f_1 : W.Hom Y}
{g_1 : X.Hom Z}, f.tensor g = f_1.tensor g_1 → f = f_1 ∧ g = g_1 | true |
TendstoUniformlyOnFilter | Mathlib.Topology.UniformSpace.UniformConvergence | {α : Type u_1} → {β : Type u_2} → {ι : Type u_4} → [UniformSpace β] → (ι → α → β) → (α → β) → Filter ι → Filter α → Prop | true |
Int.natAbs_ediv_of_dvd | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, b ∣ a → (a / b).natAbs = a.natAbs / b.natAbs | true |
SimpleGraph.finsubgraphOfAdj | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | {V : Type u} → {G : SimpleGraph V} → {u v : V} → G.Adj u v → G.Finsubgraph | true |
Real.limsInf_of_not_isCobounded | Mathlib.Order.Filter.ENNReal | ∀ {f : Filter ℝ}, ¬Filter.IsCobounded (fun x1 x2 => x1 ≥ x2) f → f.limsInf = 0 | true |
StarAddMonoid.toStarModuleNat | Mathlib.Algebra.Star.Basic | ∀ {α : Type u_1} [inst : AddMonoid α] [inst_1 : StarAddMonoid α], StarModule ℕ α | true |
MvPolynomial.algHom_ext | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A]
{f g : MvPolynomial σ R →ₐ[R] A}, (∀ (i : σ), f (MvPolynomial.X i) = g (MvPolynomial.X i)) → f = g | true |
_private.Init.Meta.Defs.0.Lean.Name.beq.match_1.splitter._sparseCasesOn_6 | Init.Meta.Defs | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Algebra.id._proof_4 | Mathlib.Algebra.Algebra.Defs | ∀ (R : Type u_1) [inst : CommSemiring R] (x y : R),
(↑↑(RingHom.id R)).toFun (x + y) = (↑↑(RingHom.id R)).toFun x + (↑↑(RingHom.id R)).toFun y | false |
Std.HashMap.Raw.getD_map_of_getKey?_eq_some | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → γ} {k k' : α} {fallback : γ},
m.WF → m.getKey? k = some k' → (Std.HashMap.Raw.map f m).getD k fallback = (Option.map (f k') m[k]?).getD fallback | true |
QuotientAddGroup.preimage_image_mk_eq_iUnion_image | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] (N : AddSubgroup α) (s : Set α),
QuotientAddGroup.mk ⁻¹' (QuotientAddGroup.mk '' s) = ⋃ x, (fun x_1 => x_1 + ↑x) '' s | true |
PadicInt.instNormedCommRing._proof_2 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (a b : ℤ_[p]), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | false |
SSet.Truncated.HomotopyCategory.BinaryProduct.inverseCompMapHomotopyCategorySndIso._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ (X Y : SSet.Truncated 2)
(x : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.OneTruncation₂._proof_1 }))
⦃x_1 y : Y.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.OneTruncation₂._proof_1 })⦄
(e : SSet.Truncated.Edge x_1 y),
CategoryTheory.CategoryStruct.comp
(((Cate... | false |
MeasureTheory.StronglyMeasurable.of_subsingleton_cod | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} {f : α → β} [inst : TopologicalSpace β] [Subsingleton β],
MeasureTheory.StronglyMeasurable f | true |
_private.Batteries.Data.Array.Basic.0.Array.scanlMFast.loop._unary._proof_2 | Batteries.Data.Array.Basic | ∀ {β : Type u_1} (stop : USize) (init : β) (start : USize) (acc : Array β),
start < stop →
∀ (next : β),
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSigma.casesOn x fun init start =>
PSigma.casesOn start fun start acc => stop.toNat - min start.toNat stop.toNat)
⟨next, ⟨s... | false |
Orientation.inner_rightAngleRotation_self | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) (x : E), inner ℝ (o.rightAngleRotation x) x = 0 | true |
AddMonoidAlgebra.mapDomain_injective | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} [inst : Semiring R] {f : M → N},
Function.Injective f → Function.Injective (AddMonoidAlgebra.mapDomain f) | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastZeroExtend._proof_6 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend | ∀ (newWidth curr : ℕ), curr ≤ newWidth → ¬curr < newWidth → curr = newWidth | false |
Summable.nat_tsum_vanishing | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] {f : ℕ → G},
Summable f → ∀ ⦃e : Set G⦄, e ∈ nhds 0 → ∃ N, ∀ t ⊆ {n | N ≤ n}, ∑' (n : ↑t), f ↑n ∈ e | true |
Matroid.IsBasis.isBase_of_isBase_subset | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X B : Set α}, M.IsBasis I X → M.IsBase B → B ⊆ X → M.IsBase I | true |
Std.DTreeMap.Internal.Impl.Const.getD_insertMany!_list_of_contains_eq_false | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : BEq α] [Std.LawfulBEqOrd α],
t.WF →
∀ {l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Internal.Impl.Const.getD (↑(Std.DTreeMap.Int... | true |
Set.powersetCard.addActionHom_of_embedding_surjective | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : AddGroup G] (α : Type u_2) [inst_1 : AddAction G α] {n : ℕ} [inst_2 : DecidableEq α],
Function.Surjective ⇑(Set.powersetCard.addActionHom_of_embedding G α n) | true |
idRel_subset | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {s : SetRel α α}, idRel ⊆ s ↔ ∀ (a : α), (a, a) ∈ s | true |
LinearIsometryEquiv.ulift._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ (R : Type u_3) (E : Type u_2) [inst : Semiring R] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module R E]
(x : ULift.{u_1, u_2} E),
‖ContinuousLinearEquiv.ulift.toLinearEquiv x‖ = ‖ContinuousLinearEquiv.ulift.toLinearEquiv x‖ | false |
EReal.div_mul_cancel | Mathlib.Data.EReal.Inv | ∀ {a b : EReal}, b ≠ ⊥ → b ≠ ⊤ → b ≠ 0 → a / b * b = a | true |
Algebra.EssFiniteType.iff_of_algEquiv | Mathlib.RingTheory.EssentialFiniteness | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] (f : S ≃ₐ[R] T), Algebra.EssFiniteType R S ↔ Algebra.EssFiniteType R T | true |
Lean.ErrorExplanation.instFromJsonMetadata | Lean.ErrorExplanation | Lean.FromJson Lean.ErrorExplanation.Metadata | true |
_private.Mathlib.Analysis.Normed.Algebra.MatrixExponential.0.Matrix.exp_blockDiagonal'._simp_1_3 | Mathlib.Analysis.Normed.Algebra.MatrixExponential | ∀ {X : Type u_1} {l : Type u_3} {R : Type u_8} {m' : l → Type u_9} {n' : l → Type u_10} [inst : AddCommMonoid R]
[inst_1 : TopologicalSpace R] {L : SummationFilter X} [inst_2 : DecidableEq l] [T2Space R]
{f : X → (i : l) → Matrix (m' i) (n' i) R},
∑'[L] (x : X), Matrix.blockDiagonal' (f x) = Matrix.blockDiagonal'... | false |
Std.Roc.toArray_toList | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.Rxc.IsAlwaysFinite α], r.toList.toArray = r.toArray | true |
SmoothBumpCovering.c | Mathlib.Geometry.Manifold.PartitionOfUnity | {ι : Type uι} →
{E : Type uE} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type uH} →
[inst_2 : TopologicalSpace H] →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
[inst_3 : TopologicalSpace M] →
[inst_4 : ... | true |
DomMulAct.smul_Lp_neg | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {M : Type u_1} {α : Type u_3} {E : Type u_4} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E]
{μ : MeasureTheory.Measure α} {p : ENNReal} [inst_2 : SMul M α] [inst_3 : MeasureTheory.SMulInvariantMeasure M α μ]
[inst_4 : MeasurableConstSMul M α] (c : Mᵈᵐᵃ) (f : ↥(MeasureTheory.Lp E p μ)), c • -f = -(c • ... | true |
Equiv.Set.univ._proof_2 | Mathlib.Logic.Equiv.Set | ∀ (α : Type u_1) (x : α), ↑⟨x, trivial⟩ = ↑⟨x, trivial⟩ | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.FDeriv.0.mdifferentiable_iff_differentiable._simp_1_2 | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {f : E → E'}
{x : E}, MDiffAt f x = DifferentiableAt 𝕜 f x | false |
AlgebraicGeometry.Flat.instDescScheme | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X : AlgebraicGeometry.Scheme} {ι : Type v} [inst : Small.{u, v} ι] {Y : ι → AlgebraicGeometry.Scheme}
{f : (i : ι) → Y i ⟶ X} [∀ (i : ι), AlgebraicGeometry.Flat (f i)],
AlgebraicGeometry.Flat (CategoryTheory.Limits.Sigma.desc f) | true |
RingCon.quotientQuotientEquivQuotientₐ_symm_mk | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} (R : Type u_4) [inst : CommSemiring R] [inst_1 : Semiring M] [inst_2 : Algebra R M] {c d : RingCon M}
(h : c ≤ d) (x : M), (RingCon.quotientQuotientEquivQuotientₐ R h).symm ⟦x⟧ = ⟦⟦x⟧⟧ | true |
_private.Init.Data.Array.Zip.0.Array.getElem?_zipWithAll.match_1.splitter._sparseCasesOn_2 | Init.Data.Array.Zip | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Matrix.diagonal_ofNat' | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : NatCast α] (m : ℕ)
[inst_3 : m.AtLeastTwo], Matrix.diagonal (OfNat.ofNat m) = OfNat.ofNat m | true |
_private.Mathlib.LinearAlgebra.Matrix.Vec.0.Matrix.vec_inj._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Vec | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
PFunctor.M.IsPath | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → PFunctor.Approx.Path F → F.M → Prop | true |
MeasureTheory.prob_compl_eq_one_sub₀ | Mathlib.MeasureTheory.Measure.Typeclasses.Probability | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}
[MeasureTheory.IsProbabilityMeasure μ], MeasureTheory.NullMeasurableSet s μ → μ sᶜ = 1 - μ s | true |
Lean.Grind.OrderedAdd.neg_nonneg_iff | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.AddCommGroup M] [Lean.Grind.OrderedAdd M]
{a : M}, 0 ≤ -a ↔ a ≤ 0 | true |
one_lt_zpow_of_neg₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a : G₀} [ZeroLEOneClass G₀]
{n : ℤ}, 0 < a → a < 1 → n < 0 → 1 < a ^ n | true |
Lean.Doc.Part | Lean.DocString.Types | Type u → Type v → Type w → Type (max u v w) | true |
ODE.FunSpace.exists_isFixedPt_next | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E → E} {tmin tmax : ℝ}
{t₀ : ↑(Set.Icc tmin tmax)} {x₀ x : E} {a r L K : NNReal} [CompleteSpace E] (hf : IsPicardLindelof f t₀ x₀ a r L K)
(hx : x ∈ Metric.closedBall x₀ ↑r), ∃ α, Function.IsFixedPt (ODE.FunSpace.next hf hx) α | true |
Turing.FinTM2.inhabitedStmt._aux_1 | Mathlib.Computability.TuringMachine.Computable | (tm : Turing.FinTM2) → tm.Stmt | false |
NonUnitalAlgHom.range_comp | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type w'} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B]
[inst_5 : NonUnitalNonAssocSemiring C] [inst_6 : Module R C] (f : A →ₙₐ[R] B) (g : B →ₙₐ[R] C),
NonUnitalAlgHom.r... | true |
MonomialOrder.span_leadingTerm_eq_span_monomial | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {m : MonomialOrder σ} {B : Set (MvPolynomial σ R)},
(∀ p ∈ B, IsUnit (m.leadingCoeff p)) →
Ideal.span (m.leadingTerm '' B) = Ideal.span ((fun p => (MvPolynomial.monomial (m.degree p)) 1) '' B) | true |
Set.toFinset_eq_empty | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s], s.toFinset = ∅ ↔ s = ∅ | true |
CategoryTheory.GradedObject.Monoidal.ιTensorObj₃_eq | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ : CategoryTheory.GradedObject I C) [inst_3 : X₂.HasTensor X₃]
[inst_4 : X₁.HasTensor (CategoryTheory.GradedObject.Monoidal.tensorObj X₂ X₃)] (i₁ i₂ i₃ j : I) (h :... | true |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.Adapted.isStoppingTime_hittingBtwn_isStoppingTime._simp_1_9 | Mathlib.Probability.Process.HittingTime | ∀ {α : Type u} (x : α), (x ∈ ∅) = False | false |
Int.lt_trichotomy | Init.Data.Int.Order | ∀ (a b : ℤ), a < b ∨ a = b ∨ b < a | true |
Set.right_mem_Icc | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ∈ Set.Icc b a ↔ b ≤ a | true |
Aesop.Goal.mk | Aesop.Tree.Data | Aesop.GoalData Aesop.Rapp Aesop.MVarCluster → Aesop.Goal | true |
CategoryTheory.CommSq.cokernelCofork.congr_simp | Mathlib.Algebra.Homology.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X₁ X₂ X₃ X₄ : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X₂ X₃] {f : X₁ ⟶ X₂} {g : X₁ ⟶ X₃} {inl inl_1 : X₂ ⟶ X₄}
(e_inl : inl = inl_1) {inr inr_1 : X₃ ⟶ X₄} (e_inr : inr = inr_1) (sq : CategoryTheory.... | true |
monadMap_refl | Init.Control.Lawful.Instances | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (f : {α : Type u_1} → m α → m α), monadMap f = f | true |
Lean.Meta.Grind.simpOr | Lean.Meta.Tactic.Grind.SimpUtil | Lean.Meta.Simp.Simproc | true |
ENat.mul_top | Mathlib.Data.ENat.Basic | ∀ {m : ℕ∞}, m ≠ 0 → m * ⊤ = ⊤ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.