name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
partialFunToPointed._proof_3 | Mathlib.CategoryTheory.Category.PartialFun | ∀ {X Y : PartialFun} (f : X ⟶ Y),
Option.elim' none (fun a => (f a).toOption) { X := Option X, point := none }.point =
Option.elim' none (fun a => (f a).toOption) { X := Option X, point := none }.point | false |
Lean.Elab.Term.LetIdDeclView.casesOn | Lean.Elab.Binders | {motive : Lean.Elab.Term.LetIdDeclView → Sort u} →
(t : Lean.Elab.Term.LetIdDeclView) →
((id : Lean.Syntax) →
(binders : Array Lean.Syntax) →
(type value : Lean.Syntax) → motive { id := id, binders := binders, type := type, value := value }) →
motive t | false |
MulEquiv.congr_arg | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N] {f : M ≃* N} {x x' : M}, x = x' → f x = f x' | true |
ModuleCat.isZero_of_iff_subsingleton | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
CategoryTheory.Limits.IsZero (ModuleCat.of R M) ↔ Subsingleton M | true |
Filter.Germ.coe_coeRingHom | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {R : Type u_5} [inst : Semiring R], ⇑(Filter.Germ.coeRingHom l) = Filter.Germ.ofFun | true |
_private.Mathlib.Topology.Separation.Basic.0.disjoint_nhdsWithin_of_mem_discrete.match_1_1 | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} {x : X} (motive : (∃ U ∈ nhds x, U ∩ s = {x}) → Prop)
(x_1 : ∃ U ∈ nhds x, U ∩ s = {x}), (∀ (V : Set X) (h : V ∈ nhds x) (h' : V ∩ s = {x}), motive ⋯) → motive x_1 | false |
inv_pow_strictAnti | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Semifield α] [inst_1 : PartialOrder α] [PosMulReflectLT α] {a : α} [IsStrictOrderedRing α],
1 < a → StrictAnti fun n => (a ^ n)⁻¹ | true |
IsPreorder.swap | Mathlib.Order.RelClasses | ∀ {α : Type u} (r : α → α → Prop) [IsPreorder α r], IsPreorder α (Function.swap r) | true |
Std.DTreeMap.Internal.Impl.ofList.eq_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (l : List ((a : α) × β a)),
Std.DTreeMap.Internal.Impl.ofList l = ↑(Std.DTreeMap.Internal.Impl.empty.insertMany l ⋯) | true |
Std.Do.Spec.forIn'_range._proof_5 | Std.Do.Triple.SpecLemmas | ∀ {xs : Std.Legacy.Range} (pref : List ℕ) (cur : ℕ) (suff : List ℕ),
xs.toList = pref ++ cur :: suff → pref ++ [cur] ++ suff = xs.toList | false |
WeierstrassCurve.toShortNF_spec | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) [inst_1 : Invertible 2] [inst_2 : Invertible 3],
(W.toShortNF • W).IsShortNF | true |
Aesop.RuleStats | Aesop.Stats.Basic | Type | true |
MulChar.ofUnitHom_eq | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'] (χ : Rˣ →* R'ˣ),
MulChar.ofUnitHom χ = MulChar.equivToUnitHom.symm χ | true |
Matrix.norm_map_eq | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} {β : Type u_6} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] [inst_3 : SeminormedAddCommGroup β] (A : Matrix m n α) (f : α → β),
(∀ (a : α), ‖f a‖ = ‖a‖) → ‖A.map f‖ = ‖A‖ | true |
Std.DTreeMap.Const.get?_eq_get? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.LawfulEqCmp cmp]
[Std.TransCmp cmp] {a : α}, Std.DTreeMap.Const.get? t a = t.get? a | true |
IntermediateField.mem_inf._simp_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {S T : IntermediateField F E}
{x : E}, (x ∈ S ⊓ T) = (x ∈ S ∧ x ∈ T) | false |
Unitization.unitsFstOne | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | (R : Type u_1) →
(A : Type u_2) →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : Module R A] →
[inst_3 : IsScalarTower R A A] → [inst_4 : SMulCommClass R A A] → Subgroup (Unitization R A)ˣ | true |
SubMulAction.ofStabilizer.snoc_castSucc | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] {a : α} {n : ℕ}
(x : Fin n ↪ ↥(SubMulAction.ofStabilizer G a)) (i : Fin n), (SubMulAction.ofStabilizer.snoc x) i.castSucc = ↑(x i) | true |
Units.rightOfMul.eq_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : Monoid M] (u : Mˣ) (a b : M) (hu : a * b = ↑u) (hc : Commute a b),
u.rightOfMul a b hu hc = u.leftOfMul b a ⋯ ⋯ | true |
Lean.Widget.LazyTraceChildren.indent | Lean.Widget.InteractiveDiagnostic | Lean.Widget.LazyTraceChildren → ℕ | true |
SemilinearIsometryClass.recOn | Mathlib.Analysis.Normed.Operator.LinearIsometry | {𝓕 : Type u_11} →
{R : Type u_12} →
{R₂ : Type u_13} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
{E : Type u_14} →
{E₂ : Type u_15} →
[inst_2 : SeminormedAddCommGroup E] →
[inst_3 : SeminormedAddCommGroup ... | false |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.tilted_tilted._simp_1_1 | Mathlib.MeasureTheory.Measure.Tilted | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
MonoidHom.copy._proof_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOne M] [inst_1 : MulOne N] (f : M →* N) (f' : M → N) (h : f' = ⇑f) (x y : M),
((↑f).copy f' h).toFun (x * y) = ((↑f).copy f' h).toFun x * ((↑f).copy f' h).toFun y | false |
ModularGroup.lcRow0Extend._proof_1 | Mathlib.NumberTheory.Modular | ∀ {cd : Fin 2 → ℤ}, IsCoprime (cd 0) (cd 1) → ↑(cd 0) ^ 2 + (-↑(cd 1)) ^ 2 ≠ 0 | false |
Float32.acos | Init.Data.Float32 | Float32 → Float32 | true |
Lean.Elab.Term.PostponeBehavior.no.elim | Lean.Elab.SyntheticMVars | {motive : Lean.Elab.Term.PostponeBehavior → Sort u} →
(t : Lean.Elab.Term.PostponeBehavior) → t.ctorIdx = 1 → motive Lean.Elab.Term.PostponeBehavior.no → motive t | false |
Equiv.subtypeEquiv_symm | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (a : α), p a ↔ q (e a)),
(e.subtypeEquiv h).symm = e.symm.subtypeEquiv ⋯ | true |
OrderIso.toRelIsoLT_ofRelIsoLT | Mathlib.Order.Hom.Basic | ∀ {α : Type u_6} {β : Type u_7} [inst : PartialOrder α] [inst_1 : PartialOrder β]
(e : (fun x1 x2 => x1 < x2) ≃r fun x1 x2 => x1 < x2), (OrderIso.ofRelIsoLT e).toRelIsoLT = e | true |
IsIntegrallyClosedIn.integralClosure_eq_bot | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[IsIntegrallyClosedIn R A] [IsDomain R] [Module.IsTorsionFree R A] [Nontrivial A], integralClosure R A = ⊥ | true |
LinearEquiv.ofIsUnitDet_apply | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {M' : Type u_3}
[inst_3 : AddCommGroup M'] [inst_4 : Module R M'] {ι : Type u_4} [inst_5 : DecidableEq ι] [inst_6 : Fintype ι]
{f : M →ₗ[R] M'} {v : Module.Basis ι R M} {v' : Module.Basis ι R M'} (h : IsUnit ((Linear... | true |
subtypeOrEquiv_apply | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} (p q : α → Prop) [inst : DecidablePred p] (h : Disjoint p q) (a : { x // p x ∨ q x }),
(subtypeOrEquiv p q h) a = (subtypeOrLeftEmbedding p q) a | true |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine.0.EuclideanGeometry.angle_midpoint_eq_pi._simp_1_3 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1] [AddLeftMono α],
(0 < 2) = True | false |
Lean.Lsp.InlayHintLabel.parts.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {p p_1 : Array Lean.Lsp.InlayHintLabelPart},
Lean.Lsp.InlayHintLabel.parts p = Lean.Lsp.InlayHintLabel.parts p_1 → p = p_1 | true |
Algebra.IsPushout.of_equiv | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type v₃} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {R' : Type u_6}
{S' : Type u_7} [inst_3 : CommSemiring R'] [inst_4 : CommSemiring S'] [inst_5 : Algebra R R'] [inst_6 : Algebra S S']
[inst_7 : Algebra R' S'] [inst_8 : Algebra R S'] [inst_9 : IsScalarTower R R' ... | true |
SSet.Truncated.Path.interval._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {m : ℕ} (j l : ℕ), j + l ≤ m → ∀ (i : Fin (l + 1)), j + ↑i < m + 1 | false |
String.Internal.foldlImpl | Init.Data.String.Iterate | (String → Char → String) → String → String → String | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_30 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls : ℕ) (ll lr : Std.DTreeMap.Internal.Impl α β) (ls lls : ℕ)
(l r : Std.DTreeMap.Internal.Impl α β) (lrs : ℕ) (lrl lrr : Std.DTreeMap.Internal.Impl α β),
¬(1 + (ll.size + 1 + lr.size) + (l.size + 1 + r.size + 1 + (lrl.size + 1 + lrr.size)) =
ll.size + 1 + lr.size + 1 ... | false |
Mathlib.Tactic.Monoidal.instMkEvalMonoidalM | Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | Mathlib.Tactic.BicategoryLike.MkEval Mathlib.Tactic.Monoidal.MonoidalM | true |
Equiv.Perm.IsCycle | Mathlib.GroupTheory.Perm.Cycle.Basic | {α : Type u_2} → Equiv.Perm α → Prop | true |
Std.TreeSet.isEmpty_iff_forall_contains | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp],
t.isEmpty = true ↔ ∀ (a : α), t.contains a = false | true |
finsuppTensorFinsupp'_apply_apply | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ (R : Type u_1) (ι : Type u_5) (κ : Type u_6) [inst : CommSemiring R] (f : ι →₀ R) (g : κ →₀ R) (a : ι) (b : κ),
((finsuppTensorFinsupp' R ι κ) (f ⊗ₜ[R] g)) (a, b) = f a * g b | true |
CategoryTheory.Functor.homAddMonoidHom.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v, u_1} C]
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] [inst_2 : CategoryTheory.Category.{w, u_2} D]
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] {M X : C} [inst_4 : CategoryTheory.AddMonObj M]
(F : CategoryTheory.Functor C D) [in... | true |
Lean.Compiler.LCNF.addBoxedVersions | Lean.Compiler.LCNF.ExplicitBoxing | Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.impure) →
Lean.Compiler.LCNF.CompilerM (Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.impure)) | true |
CategoryTheory.Discrete.productEquiv_functor_obj | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} (a : CategoryTheory.Discrete (J × K)),
CategoryTheory.Discrete.productEquiv.functor.obj a = ({ as := a.as.1 }, { as := a.as.2 }) | true |
GaloisConnection.isGLB_u_image | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
GaloisConnection l u → ∀ {s : Set β} {b : β}, IsGLB s b → IsGLB (u '' s) (u b) | true |
_private.Mathlib.Order.BooleanAlgebra.Basic.0.GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra._proof_3 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (y x z : α), y ⊔ y \ x ≤ y \ x ⊔ x ⊔ z | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.MutualClosure.pickMaxFVar? | Lean.Elab.MutualDef | Lean.LocalContext → Array Lean.FVarId → Option Lean.FVarId | true |
CategoryTheory.GrothendieckTopology.isColimitCofanMkYoneda._proof_4 | Mathlib.CategoryTheory.Sites.Subcanonical | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical] {ι : Type u_3} (X : ι → C) {c : CategoryTheory.Limits.Cofan X},
(∀ (s : CategoryTheory.Limits.Cofan fun i => J.yoneda.obj (X i)) {Y : C} {i j : ι} (a : Y ⟶ X i) (b : Y ⟶ X j),
C... | false |
Int16.div_self | Init.Data.SInt.Lemmas | ∀ {a : Int16}, a / a = if a = 0 then 0 else 1 | true |
Set.biUnion_lt_succ' | Mathlib.Data.Nat.Lattice | ∀ {α : Type u_1} (u : ℕ → Set α) (n : ℕ), ⋃ k, ⋃ (_ : k < n + 1), u k = u 0 ∪ ⋃ k, ⋃ (_ : k < n), u (k + 1) | true |
_private.Mathlib.RingTheory.PowerSeries.Trunc.0.PowerSeries.coeff_trunc_aux | Mathlib.RingTheory.PowerSeries.Trunc | ∀ {R : Type u_1} [inst : Semiring R] (m n : ℕ) (φ : PowerSeries R),
(PowerSeries.trunc_aux✝ n φ).coeff m = if m < n then (PowerSeries.coeff m) φ else 0 | true |
RCLike.ofReal_inv._simp_1 | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] (r : ℝ), (↑r)⁻¹ = ↑r⁻¹ | false |
Lean.IR.CollectUsedDecls.State.ctorIdx | Lean.Compiler.IR.EmitUtil | Lean.IR.CollectUsedDecls.State → ℕ | false |
_private.Mathlib.RingTheory.Localization.NumDen.0.IsFractionRing.num_zero._simp_1_1 | Mathlib.RingTheory.Localization.NumDen | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b : G₀}, (a / b = 0) = (a = 0 ∨ b = 0) | false |
CategoryTheory.PreOneHypercover.Hom.noConfusionType | Mathlib.CategoryTheory.Sites.Hypercover.One | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
E.Hom F →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
... | false |
Lean.PrettyPrinter.Formatter.Context.options | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter.Context → Lean.Options | true |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.handleCallHierarchyOutgoingCalls.match_7 | Lean.Server.Watchdog | (motive : Lean.Lsp.RefIdent × Lean.Lsp.RefInfo → Sort u_1) →
(x : Lean.Lsp.RefIdent × Lean.Lsp.RefInfo) →
((ident : Lean.Lsp.RefIdent) → (info : Lean.Lsp.RefInfo) → motive (ident, info)) → motive x | false |
CategoryTheory.functorMapReverse | Mathlib.CategoryTheory.Groupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {D : Type u_1} [inst_1 : CategoryTheory.Groupoid D]
(F : CategoryTheory.Functor C D), F.toPrefunctor.MapReverse | true |
Lean.Elab.Term.Do.Code.brecOn_1 | Lean.Elab.Do.Legacy | {motive_1 : Lean.Elab.Term.Do.Code → Sort u} →
{motive_2 : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u} →
{motive_3 : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Sort u} →
{motive_4 : List (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u} →
{motive_5 : List (L... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_alter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Submodule.restrictScalars.isScalarTower | Mathlib.Algebra.Module.Submodule.RestrictScalars | ∀ (S : Type u_1) (R : Type u_2) (M : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Semiring S]
[inst_3 : Module S M] [inst_4 : Module R M] [inst_5 : SMul S R] [inst_6 : IsScalarTower S R M] (p : Submodule R M),
IsScalarTower S R ↥(Submodule.restrictScalars S p) | true |
AddMonoid.exponent_eq_zero_iff_range_addOrderOf_infinite | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : AddMonoid G],
(∀ (g : G), 0 < addOrderOf g) → (AddMonoid.exponent G = 0 ↔ (Set.range addOrderOf).Infinite) | true |
Polynomial.aeval_sumIDeriv | Mathlib.Algebra.Polynomial.SumIteratedDerivative | ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_3) [inst_1 : CommRing A] [inst_2 : Algebra R A] (p : Polynomial R)
(q : ℕ),
∃ gp,
gp.natDegree ≤ p.natDegree - q ∧
∀ (r : A),
(Polynomial.X - Polynomial.C r) ^ q ∣ Polynomial.map (algebraMap R A) p →
(Polynomial.aeval r) (Polynomial.su... | true |
Nat.chineseRemainderOfMultiset.congr_simp | Mathlib.Data.Nat.ChineseRemainder | ∀ {ι : Type u_1} (a s : ι → ℕ) {m : Multiset ι} (a_1 : m.Nodup) (a_2 : ∀ i ∈ m, s i ≠ 0)
(a_3 : {x | x ∈ m}.Pairwise (Function.onFun Nat.Coprime s)),
Nat.chineseRemainderOfMultiset a s a_1 a_2 a_3 = Nat.chineseRemainderOfMultiset a s a_1 a_2 a_3 | true |
Unitary.instIsScalarTowerSubtypeMemSubmonoidUnitary | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : Monoid R] [inst_1 : Monoid S] [inst_2 : Monoid A]
[inst_3 : StarMul R] [inst_4 : StarMul S] [inst_5 : StarMul A] [inst_6 : MulAction R S] [inst_7 : MulAction R A]
[inst_8 : MulAction S A] [inst_9 : StarModule R S] [inst_10 : StarModule R A] [inst_11 : StarModul... | true |
Lean.Server.RequestHandler.casesOn | Lean.Server.Requests | {motive : Lean.Server.RequestHandler → Sort u} →
(t : Lean.Server.RequestHandler) →
((fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri) →
(handle : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)) →
motive { fileSource := ... | false |
CategoryTheory.ShortComplex.hasFiniteColimits | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{v_2, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteColimits C], CategoryTheory.Limits.HasFiniteColimits (CategoryTheory.ShortComplex C) | true |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Alt.body.match_1 | Lean.Compiler.IR.Basic | (motive : Lean.IR.Alt → Sort u_1) →
(x : Lean.IR.Alt) →
((info : Lean.IR.CtorInfo) → (b : Lean.IR.FnBody) → motive (Lean.IR.Alt.ctor info b)) →
((b : Lean.IR.FnBody) → motive (Lean.IR.Alt.default b)) → motive x | false |
add_lt_iff_neg_left._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α] [AddLeftStrictMono α] [AddLeftReflectLT α] {a b : α},
(a + b < a) = (b < 0) | false |
derivWithin_inter | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s t : Set 𝕜}, t ∈ nhds x → derivWithin f (s ∩ t) x = derivWithin f s x | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.extend_finset_to_connected._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | false |
Cardinal.term𝔠 | Mathlib.SetTheory.Cardinal.Continuum | Lean.ParserDescr | true |
TopologicalSpace.Compacts.instCompactSpaceSubtypeMem | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (K : TopologicalSpace.Compacts α), CompactSpace ↥K | true |
Std.Iterators.Types.Append.ctorElim | Init.Data.Iterators.Combinators.Monadic.Append | {α₁ α₂ : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{motive : Std.Iterators.Types.Append α₁ α₂ m β → Sort u} →
(ctorIdx : ℕ) →
(t : Std.Iterators.Types.Append α₁ α₂ m β) →
ctorIdx = t.ctorIdx → Std.Iterators.Types.Append.ctorElimType ctorIdx → motive t | false |
CategoryTheory.Limits.coprodComparison_inv_natural_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{w, u₂} D]
(F : CategoryTheory.Functor C D) {A A' B B' : C} [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct A B]
[inst_3 : CategoryTheory.Limits.HasBinaryCoproduct A' B']
[inst_4 : CategoryTheory.Limits.Has... | true |
Std.DTreeMap.Internal.Impl.Const.mergeWith._proof_1 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} (t : Std.DTreeMap.Internal.Impl.BalancedTree α fun x => β), t.impl.Balanced | false |
Mathlib.Tactic.ToAdditive.data | Mathlib.Tactic.Translate.ToAdditive | Mathlib.Tactic.Translate.TranslateData | true |
finSumNatEquiv_apply_right | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} (i : ℕ), (finSumNatEquiv n) (Sum.inr i) = n + i | true |
Matrix.card_GL_field | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Card | ∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] (n : ℕ),
Nat.card (GL (Fin n) 𝔽) = ∏ i, (Fintype.card 𝔽 ^ n - Fintype.card 𝔽 ^ ↑i) | true |
Std.ExtHashMap.insert.eq_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m : Std.ExtHashMap α β) (a : α) (b : β), m.insert a b = { inner := m.inner.insert a b } | true |
fourier_apply | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ} {n : ℤ} {x : AddCircle T}, (fourier n) x = ↑(n • x).toCircle | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsCycle.neighborSet_toSubgraph_internal._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (G' : G.Subgraph) (v w : V), (w ∈ G'.neighborSet v) = G'.Adj v w | false |
Lean.Grind.Linarith.Expr.brecOn | Init.Grind.Ordered.Linarith | {motive : Lean.Grind.Linarith.Expr → Sort u} →
(t : Lean.Grind.Linarith.Expr) →
((t : Lean.Grind.Linarith.Expr) → Lean.Grind.Linarith.Expr.below t → motive t) → motive t | false |
Std.DTreeMap.Raw.getEntryLED | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap.Raw α β cmp → α → (a : α) × β a → (a : α) × β a | true |
CategoryTheory.ShortComplex.HomologyMapData.ofZeros_right | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (hf₁ : S₁.f = 0) (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0)
(hg₂ : S₂.g = 0),
(CategoryTheory.ShortComplex.HomologyMapData.ofZeros φ hf₁ hg₁ hf₂ hg₂).right =
... | true |
MeasureTheory.measure_add_lintegral_eq | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd₂ G] (μ ν : MeasureTheory.Measure G)
[MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] {s : Set G} [MeasurableNeg G] [μ.IsAddLeftInvariant]
[ν.IsAddLeftInvariant],
MeasurableSet s →
∀ (f : G → ENNReal), Measurable f → μ s * ∫⁻ (... | true |
AlgebraicIndependent.comp | Mathlib.RingTheory.AlgebraicIndependent.Defs | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {A : Type u_5} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : Algebra R A],
AlgebraicIndependent R x → ∀ (f : ι' → ι), Function.Injective f → AlgebraicIndependent R (x ∘ f) | true |
CategoryTheory.Functor.preservesMonomorphisms_of_preserves_of_reflects | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {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)
(G : CategoryTheory.Functor D E) [(F.comp G).PreservesMonomorphisms] [G.ReflectsMonomorphisms],
F.Pre... | true |
_private.Mathlib.MeasureTheory.Measure.Tight.0.MeasureTheory.exists_measure_iUnion_gt_of_isCompact_closure._simp_1_11 | Mathlib.MeasureTheory.Measure.Tight | ∀ {α : Type u_1} {β : Type u_2} {s : α → Set β} [inst : LE α] {x : α}, ⋃ y, ⋃ (_ : y ≤ x), s y = Set.accumulate s x | false |
Lean.Meta.Grind.Theorems._sizeOf_inst | Lean.Meta.Tactic.Grind.Theorems | (α : Type) → [SizeOf α] → SizeOf (Lean.Meta.Grind.Theorems α) | false |
Aesop.FVarIdSubst.mk._flat_ctor | Aesop.RuleTac.FVarIdSubst | Std.HashMap Lean.FVarId Lean.FVarId → Aesop.FVarIdSubst | false |
commAlgCatEquivUnder_inverse_obj_carrier | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ (R : CommRingCat) (A : CategoryTheory.Under R), ↑((commAlgCatEquivUnder R).inverse.obj A) = ↑A.right | true |
_private.Mathlib.Tactic.FunProp.ToBatteries.0.Mathlib.Meta.FunProp.mkProdElem._proof_2 | Mathlib.Tactic.FunProp.ToBatteries | ∀ (xs : Array Lean.Expr) (n : ℕ), xs.size = n.succ → n < xs.size | false |
LinearPMap.instAddMonoid._proof_1 | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_3} {S : Type u_4} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_1} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_2} [inst_4 : AddCommGroup F] [inst_5 : Module S F] (f : E →ₛₗ.[σ] F), 0 + f = f | false |
Nonneg.instIsRightCancelAddSubtypeLeOfNat | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [inst_2 : AddLeftMono α] [IsRightCancelAdd α],
IsRightCancelAdd { x // 0 ≤ x } | true |
Std.ExtTreeSet.max!_eq_iff_get?_eq_self_and_forall | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α],
t ≠ ∅ → ∀ {km : α}, t.max! = km ↔ t.get? km = some km ∧ ∀ k ∈ t, (cmp k km).isLE = true | true |
Lean.Meta.ParamInfo.backDeps._default | Lean.Meta.Basic | Array ℕ | false |
Set.Nonempty.to_subtype | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s : Set α}, s.Nonempty → Nonempty ↑s | true |
abs_nonneg._simp_1 | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] [AddLeftMono α] [AddRightMono α] (a : α), (0 ≤ |a|) = True | false |
UInt32.toUInt8_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : UInt32), b < 8 → (a <<< b).toUInt8 = a.toUInt8 <<< b.toUInt8 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.