name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CalcParams.toSelectInsertParams | Mathlib.Tactic.Widget.Calc | CalcParams → SelectInsertParams | true |
CategoryTheory.Limits.PushoutCocone.isColimitOfFactors._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) (h : X ⟶ W)
[CategoryTheory.Epi h] (x : W ⟶ Y) (y : W ⟶ Z),
CategoryTheory.CategoryStruct.comp h x = f →
CategoryTheory.CategoryStruct.comp h y = g →
∀ (s : CategoryTheory.Limits.PushoutCocone f g),
... | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageD._proof_2 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (pq : κ),
data.deg pq + 1 + 1 = data.deg pq + 2 | false |
Lean.Grind.AC.Expr.denoteExpr._sunfold | Lean.Meta.Tactic.Grind.AC.DenoteExpr | {M : Type → Type} → [Monad M] → [Lean.Meta.Grind.AC.MonadGetStruct M] → Lean.Grind.AC.Expr → M Lean.Expr | false |
TopCat.subpresheafToTypes._proof_2 | Mathlib.Topology.Sheaves.LocalPredicate | ∀ {X : TopCat} {T : ↑X → Type u_2} (P : TopCat.PrelocalPredicate T) {X_1 Y Z : (TopologicalSpace.Opens ↑X)ᵒᵖ}
(f : X_1 ⟶ Y) (g : Y ⟶ Z),
(fun f_1 => ⟨fun x => ↑f_1 ((CategoryTheory.CategoryStruct.comp f g).unop x), ⋯⟩) =
CategoryTheory.CategoryStruct.comp (fun f_1 => ⟨fun x => ↑f_1 (f.unop x), ⋯⟩) fun f => ⟨fun... | false |
groupCohomology.infNatTrans_app | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ (k : Type u) {G : Type u} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal] (n : ℕ)
(A : Rep.{u, u, u} k G),
(groupCohomology.infNatTrans k S n).app A =
groupCohomology.map (QuotientGroup.mk' S) (Rep.ofHom (A.ρ.quotientToInvariants_lift S)) n | true |
_private.Lean.Server.FileWorker.InlayHints.0.Lean.Server.FileWorker.handleInlayHintsDidChange.updateOldInlayHints.match_3 | Lean.Server.FileWorker.InlayHints | (motive : Lean.Lsp.TextDocumentContentChangeEvent → Sort u_1) →
(c : Lean.Lsp.TextDocumentContentChangeEvent) →
((changeRange : Lean.Lsp.Range) →
(newText : String) → motive (Lean.Lsp.TextDocumentContentChangeEvent.rangeChange changeRange newText)) →
((x : Lean.Lsp.TextDocumentContentChangeEvent) → ... | false |
_private.Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup.0.Subgroup.subgroupOfContinuousMulEquivOfLe._proof_4 | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} (s : Set ↥H) (t : Set G),
(∀ (a : G) (b : a ∈ H), a ∈ t ↔ ⟨a, b⟩ ∈ s) →
∀ (a : G) (b : a ∈ K) (b_1 : ⟨a, b⟩ ∈ H.subgroupOf K), a ∈ t ↔ ⟨a, ⋯⟩ ∈ s | false |
_private.Mathlib.Algebra.Polynomial.Eval.Coeff.0.Polynomial.piEquiv._simp_3 | Mathlib.Algebra.Polynomial.Eval.Coeff | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | false |
PosNum.cast_add | Mathlib.Data.Num.Lemmas | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] (m n : PosNum), ↑(m + n) = ↑m + ↑n | true |
ContinuousAlgHom.coe_toContinuousLinearMap | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(e : A →A[R] B), ⇑e.toContinuousLinearMap = ⇑e | true |
_private.Lean.Elab.Tactic.Do.Syntax.0.Std.Do.elabTriple.match_4 | Lean.Elab.Tactic.Do.Syntax | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) → ((m α : Lean.Expr) → motive (m.app α)) → ((x : Lean.Expr) → motive x) → motive x | false |
Real.sqrt_le_iff | Mathlib.Data.Real.Sqrt | ∀ {x y : ℝ}, √x ≤ y ↔ 0 ≤ y ∧ x ≤ y ^ 2 | true |
Lean.Doc.instToMessageDataDocArg.match_1 | Lean.Elab.DocString | (motive : Lean.Doc.DocArg → Sort u_1) →
(x : Lean.Doc.DocArg) →
((x : Lean.Ident) → motive (Lean.Doc.DocArg.ident x)) →
((n : Lean.NumLit) → motive (Lean.Doc.DocArg.num n)) →
((s : Lean.StrLit) → motive (Lean.Doc.DocArg.str s)) → motive x | false |
Lean.Meta.Grind.Action.saveStateIfTracing | Lean.Meta.Tactic.Grind.Action | Lean.Meta.Grind.GrindM (Option Lean.Meta.Grind.SavedState) | true |
HasFPowerSeriesOnBall.eventually_eq_zero | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {x : E}
{r : ENNReal}, HasFPowerSeriesOnBall f 0 x r → ∀ᶠ (z : E) in nhds x, f z = 0 | true |
TopologicalSpace.Subtype.firstCountableTopology | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] (s : Set α) [FirstCountableTopology α], FirstCountableTopology ↑s | true |
ChevalleyThm.MvPolynomialC.numBound._mutual._proof_5 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ (n : ℕ),
(invImage (fun x => PSum.casesOn x (fun a => (a, 0)) fun a => (a, 1)) Prod.instWellFoundedRelation).1 (PSum.inr n)
(PSum.inr n.succ) | false |
_private.Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas.0.ZMod.eisenstein_lemma_aux₁ | Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] [hp2 : Fact (p % 2 = 1)] {a : ℕ},
↑a ≠ 0 →
↑(∑ x ∈ Finset.Ico 1 (p / 2).succ, a * x) =
↑{x ∈ Finset.Ico 1 (p / 2).succ | p / 2 < (↑a * ↑x).val}.card + ↑(∑ x ∈ Finset.Ico 1 (p / 2).succ, x) +
↑(∑ x ∈ Finset.Ico 1 (p / 2).succ, a * x / p) | true |
Affine.Simplex.isClosed_closedInterior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_4} {V : Type u_5} {P : Type u_6} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [OrderClosedTopology 𝕜] [CompactIccSpace 𝕜] [ContinuousAdd 𝕜] [inst_7 : AddCommGroup V]
[inst_8 : TopologicalSpace V] [IsTopologicalAddGroup V] [inst_10 : Module 𝕜 ... | true |
dist_one_right | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] (a : E), dist a 1 = ‖a‖ | true |
_private.Mathlib.Data.List.ModifyLast.0.List.modifyLast.go.match_1.splitter._sparseCasesOn_3 | Mathlib.Data.List.ModifyLast | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Std.TreeSet.Raw.Equiv.diff_right | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] {t₃ : Std.TreeSet.Raw α cmp},
t₁.WF → t₂.WF → t₃.WF → t₂.Equiv t₃ → (t₁ \ t₂).Equiv (t₁ \ t₃) | true |
CategoryTheory.Limits.kernel.mapIso_inv | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] {X' Y' : C} (f' : X' ⟶ Y')
[inst_3 : CategoryTheory.Limits.HasKernel f'] (p : X ≅ X') (q : Y ≅ Y')
(w : CategoryTheory.CategoryStruct.comp... | true |
Array.findIdx?_eq_bind_find?_idxOf? | Init.Data.Array.Find | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {xs : Array α} {p : α → Bool},
Array.findIdx? p xs = (Array.find? p xs).bind fun x => xs.idxOf? x | true |
Finsupp.lmapDomain | Mathlib.LinearAlgebra.Finsupp.Defs | {α : Type u_1} →
(M : Type u_2) →
(R : Type u_5) →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {α' : Type u_9} → (α → α') → (α →₀ M) →ₗ[R] α' →₀ M | true |
CategoryTheory.PreOneHypercover.cylinderHom._proof_5 | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (CategoryTheory.PreOneHypercover.cylinder f g).I₀),
CategoryTheory.CategoryStruct.comp (f.h₀ p... | false |
Std.ExtDHashMap.get!_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} [inst_1 : Inhabited (β k)], (m₁ ∪ m₂).get! k = m₂.getD k (m₁.get! k) | true |
MeasureTheory.IsProjectiveLimit.measure_univ_eq | Mathlib.MeasureTheory.Constructions.Projective | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)]
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} {μ : MeasureTheory.Measure ((i : ι) → α i)},
MeasureTheory.IsProjectiveLimit μ P → ∀ (I : Finset ι), μ Set.univ = (P I) Set.univ | true |
MeasureTheory.Measure.instCompleteSemilatticeInf._proof_2 | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {x : MeasurableSpace α} (x_1 : Set (MeasureTheory.Measure α)),
sInf x_1 ∈ lowerBounds x_1 ∧ sInf x_1 ∈ upperBounds (lowerBounds x_1) | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabElim.revertArgs.match_1 | Lean.Elab.App | (motive : List Lean.Expr × Lean.Expr → Sort u_1) →
(x : List Lean.Expr × Lean.Expr) →
((xs : List Lean.Expr) → (expectedType : Lean.Expr) → motive (xs, expectedType)) → motive x | false |
NonemptyInterval.addCommMonoid._proof_4 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α],
autoParam (∀ (x : NonemptyInterval α), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | false |
CategoryTheory.Limits.pullbackSymmetry_hom_comp_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.Limits.HasPullback f g] {Z_1 : C} (h : X ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullbackSymmetry f g).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.... | true |
NNReal.sub_def | Mathlib.Data.NNReal.Defs | ∀ {r p : NNReal}, r - p = (↑r - ↑p).toNNReal | true |
HomogeneousLocalization.localRingHom._proof_2 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {A : Type u_1} [inst : CommRing A] {B : Type u_2} [inst_1 : CommRing B], MonoidHomClass (A →+* B) A B | false |
_private.Mathlib.Order.UpperLower.CompleteLattice.0.UpperSet.symm_map._simp_1_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {x : α} {y : β}, (e.symm y = x) = (y = e x) | false |
Int.reduceMod._regBuiltin.Int.reduceMod.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.2193402128._hygCtx._hyg.21 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | false |
MvPolynomial.totalDegree_expand | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] {p : ℕ} (f : MvPolynomial σ R),
((MvPolynomial.expand p) f).totalDegree = f.totalDegree * p | true |
AddMonoidAlgebra.isCentralScalar | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} {N : Type u_5} [inst : Semiring R] [inst_1 : SMulZeroClass N R]
[inst_2 : SMulZeroClass Nᵐᵒᵖ R] [IsCentralScalar N R], IsCentralScalar N (AddMonoidAlgebra R M) | true |
SchwartzMap.fourier_lineDerivOp_eq | Mathlib.Analysis.Distribution.SchwartzSpace.Fourier | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_3} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
(f : SchwartzMap V E) (m : V),
FourierTransform.fourier (LineDeriv.lineDer... | true |
CategoryTheory.orderDualEquivalence._proof_7 | Mathlib.CategoryTheory.Category.Preorder | ∀ (X : Type u_1) [inst : Preorder X] {X_1 Y : Xᵒᵖ} (f : X_1 ⟶ Y),
OrderDual.toDual (Opposite.unop X_1) ≤ OrderDual.toDual (Opposite.unop Y) | false |
_private.Mathlib.RingTheory.SurjectiveOnStalks.0.RingHom.surjectiveOnStalks_iff_forall_maximal'._simp_1_1 | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {f : R →+* S},
f.SurjectiveOnStalks =
∀ (I : Ideal S) (x : I.IsMaximal), Function.Surjective ⇑(Localization.localRingHom (Ideal.comap f I) I f ⋯) | false |
FreeAddMagma.lift_symm_apply | Mathlib.Algebra.Free | ∀ {α : Type u} {β : Type v} [inst : Add β] (F : FreeAddMagma α →ₙ+ β) (a : α),
FreeAddMagma.lift.symm F a = (⇑F ∘ FreeAddMagma.of) a | true |
SymmetricAlgebra.lift_ι_apply | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {A : Type u_3}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] (f : M →ₗ[R] A) (a : M),
(SymmetricAlgebra.lift f) ((SymmetricAlgebra.ι R M) a) = f a | true |
exists_set_linearIndependent | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ (R : Type u_1) (M : Type u) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_1} R], ∃ s, Cardinal.mk ↑s = Module.rank R M ∧ LinearIndependent (ι := ↑s) R Subtype.val | true |
Int16.neg_sub | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, -(a - b) = b - a | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.sat_of_confirmRupHint_of_insertRat_fold._simp_1_11 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ {α : Type u_1} {a b : α}, (a ∈ [b]) = (a = b) | false |
_private.Mathlib.LinearAlgebra.FixedSubmodule.0.LinearEquiv.fixedReduce_eq_smul_iff._simp_1_3 | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
MulEquiv.op._proof_7 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Mul β] (f : α ≃* β) (x y : αᵐᵒᵖ),
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) (x * y) =
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) x * (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) y | false |
Filter.Tendsto.op_one_isBoundedUnder_le' | Mathlib.Analysis.Normed.Group.Bounded | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : SeminormedGroup E] [inst_1 : SeminormedGroup F]
[inst_2 : SeminormedGroup G] {f : α → E} {g : α → F} {l : Filter α},
Filter.Tendsto f l (nhds 1) →
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l (norm ∘ g) →
∀ (op : E → F → G),
(... | true |
Ord.mk.noConfusion | Init.Data.Ord.Basic | {α : Type u} →
{P : Sort u_1} →
{compare compare' : α → α → Ordering} →
{ compare := compare } = { compare := compare' } → (compare ≍ compare' → P) → P | false |
groupCohomology.coboundariesOfIsMulCoboundary₁_coe | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {G M : Type} [inst : Group G] [inst_1 : CommGroup M] [inst_2 : MulDistribMulAction G M] {f : G → M}
(hf : groupCohomology.IsMulCoboundary₁ f) (a : G),
↑(groupCohomology.coboundariesOfIsMulCoboundary₁ hf) a = (⇑Additive.ofMul ∘ f) a | true |
_private.Mathlib.Combinatorics.SetFamily.KruskalKatona.0.Finset.UV.familyMeasure_compression_lt_familyMeasure | Mathlib.Combinatorics.SetFamily.KruskalKatona | ∀ {n : ℕ} {U V : Finset (Fin n)} {hU : U.Nonempty} {hV : V.Nonempty},
U.max' hU < V.max' hV →
∀ {𝒜 : Finset (Finset (Fin n))},
UV.compression U V 𝒜 ≠ 𝒜 → Finset.UV.familyMeasure✝ (UV.compression U V 𝒜) < Finset.UV.familyMeasure✝¹ 𝒜 | true |
Std.Do.Spec.forIn'_array | Std.Do.Triple.SpecLemmas | ∀ {α β : Type u} {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps]
{xs : Array α} {init : β} {f : (a : α) → a ∈ xs → β → m (ForInStep β)} (inv : Std.Do.Invariant xs.toList β ps),
(∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
... | true |
_private.Lean.Compiler.LCNF.ReduceArity.0.Lean.Compiler.LCNF.FindUsed.visitArg.match_1 | Lean.Compiler.LCNF.ReduceArity | (motive : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(arg : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) →
(Unit → motive Lean.Compiler.LCNF.Arg.erased) →
((expr : Lean.Expr) →
(h :
autoParam (Lean.Compiler.LCNF.Purity.pure = Lean.Compiler.LCNF.Puri... | false |
_private.Init.Data.List.Sort.Lemmas.0.List.mergeSort_perm._proof_1_8 | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (xs : List α), ¬min ((xs.length + 1 + 1 + 1) / 2) (xs.length + 1 + 1) < xs.length + 1 + 1 → False | false |
LieModule.instIsNilpotentSubtypeMemLieSubmoduleGenWeightSpaceOfNatForallOfIsNoetherian | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u_2} {L : Type u_3} (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [IsNoetherian R M], LieModule.IsNilpotent L ↥(LieModule.genWeight... | true |
AlgebraicGeometry.instGeometricallyIntegralSndScheme | Mathlib.AlgebraicGeometry.Geometrically.Integral | ∀ {X Y S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S) [AlgebraicGeometry.GeometricallyIntegral f],
AlgebraicGeometry.GeometricallyIntegral (CategoryTheory.Limits.pullback.snd f g) | true |
String.posGT_eq_next._proof_2 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : String.Pos.Raw} {h : p < s.rawEndPos} (h' : String.Pos.Raw.IsValid s p), s.pos p h' ≠ s.endPos | false |
LocallyFinite.prod_right | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_1} {X : Type u_4} {Y : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{f : ι → Set X}, LocallyFinite f → ∀ (g : ι → Set Y), LocallyFinite fun i => f i ×ˢ g i | true |
Real.cos_add_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.cos (x + 2 * Real.pi) = Real.cos x | true |
CategoryTheory.Pretriangulated.instShiftSequenceOppositeAddCommGrpCatObjFunctorPreadditiveYonedaInt._proof_4 | Mathlib.CategoryTheory.Triangulated.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (B : C) (n a a' : ℤ)
(h : n + a = a') (A : Cᵒᵖ)
(x x_1 :
↑(((CategoryTheory.shiftFunctor Cᵒᵖ n).comp
... | false |
Lean.IR.FnBody | Lean.Compiler.IR.Basic | Type | true |
Function.Injective.surjective_comp_right | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} [Nonempty γ],
Function.Injective f → Function.Surjective fun g => g ∘ f | true |
Bool.noConfusionType | Init.Prelude | Sort u → Bool → Bool → Sort u | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.ContDiffWithinAt.of_le.match_1_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {m : WithTop ℕ∞} (motive : (n : WithTop ℕ∞) → ContDiffWithinAt 𝕜 n f s x → m ≤ ... | false |
_private.Mathlib.Combinatorics.Additive.Energy.0.Finset.mulEnergy_univ_left._simp_1_5 | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | false |
Differentiable.const_cpow | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {c : ℂ},
Differentiable ℂ f → (c ≠ 0 ∨ ∀ (x : E), f x ≠ 0) → Differentiable ℂ fun x => c ^ f x | true |
Std.Do.Spec.throw_ExceptT | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {ε α : Type u} {e : ε}
{Q : Std.Do.PostCond α (Std.Do.PostShape.except ε ps)} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps],
⦃Q.2.1 e⦄ MonadExceptOf.throw e ⦃Q⦄ | true |
SNum.testBit._sunfold | Mathlib.Data.Num.Bitwise | ℕ → SNum → Bool | false |
CategoryTheory.GrothendieckTopology.Point.sheafFiberComapIso_inv_app | Mathlib.CategoryTheory.Sites.Point.Comap | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {K : CategoryTheory.GrothendieckTopology D} (Φ : K.Point)
(F : CategoryTheory.Functor C D) [inst_2 : CategoryTheory.RepresentablyFlat F]
{J : CategoryTheory.GrothendieckTopology C} (hF : C... | true |
Lean.Elab.Command.InductiveView.rec | Lean.Elab.MutualInductive | {motive : Lean.Elab.Command.InductiveView → Sort u} →
((ref declId : Lean.Syntax) →
(modifiers : Lean.Elab.Modifiers) →
(isClass allowIndices allowSortPolymorphism : Bool) →
(shortDeclName declName : Lean.Name) →
(levelNames : List Lean.Name) →
(binders : Lean.Syntax)... | false |
_private.Batteries.Data.List.Lemmas.0.List.exists_or_eq_self_of_replaceF.match_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (p : α → Option α) (l : List α) (motive : (∃ a ∈ l, (p a).isSome = true) → Prop)
(h : ∃ a ∈ l, (p a).isSome = true), (∀ (w : α) (ha : w ∈ l) (pa : (p w).isSome = true), motive ⋯) → motive h | false |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.cRk_le_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {κ : Cardinal.{u}}, (M.cRank ≤ κ) = ∀ ⦃B : Set α⦄, M.IsBase B → Cardinal.mk ↑B ≤ κ | false |
LSeriesSummable.neg_iff._simp_1 | Mathlib.NumberTheory.LSeries.Linearity | ∀ {f : ℕ → ℂ} {s : ℂ}, LSeriesSummable (-f) s = LSeriesSummable f s | false |
Nat.maxPowDvdDiv.go_spec | Mathlib.Data.Nat.MaxPowDiv | ∀ {n p : ℕ} (hnp : 1 < p ∧ n ≠ 0),
(Nat.maxPowDvdDiv.go n p hnp).2 * p ^ (Nat.maxPowDvdDiv.go n p hnp).1 = n ∧ ¬p ∣ (Nat.maxPowDvdDiv.go n p hnp).2 | true |
Fin.preimage_castAdd_Ico_castAdd | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n), Fin.castAdd m ⁻¹' Set.Ico (Fin.castAdd m i) (Fin.castAdd m j) = Set.Ico i j | true |
_private.Lean.Compiler.IR.ExpandResetReuse.0.Lean.IR.ExpandResetReuse.CollectProjMap.collectFnBody._sparseCasesOn_1 | Lean.Compiler.IR.ExpandResetReuse | {motive_2 : Lean.IR.FnBody → Sort u} →
(t : Lean.IR.FnBody) →
((x : Lean.IR.VarId) →
(ty : Lean.IR.IRType) → (e : Lean.IR.Expr) → (b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.vdecl x ty e b)) →
((j : Lean.IR.JoinPointId) →
(xs : Array Lean.IR.Param) → (v b : Lean.IR.FnBody) → motive_2 (... | false |
ProbabilityTheory.Kernel.compProd_of_not_isSFiniteKernel_right | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel (α × β) γ),
¬ProbabilityTheory.IsSFiniteKernel η → κ.compProd η = 0 | true |
RCLike.ofReal_lt_ofReal._simp_1 | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {x y : ℝ}, (↑x < ↑y) = (x < y) | false |
Turing.PartrecToTM2.tr_supports | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (c : Turing.ToPartrec.Code) (k : Turing.PartrecToTM2.Cont'),
Turing.TM2.Supports Turing.PartrecToTM2.tr (Turing.PartrecToTM2.codeSupp c k) | true |
ContinuousMapZero.coeFnAddMonoidHom_apply | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : IsTopologicalSemiring R] (f : ContinuousMapZero X R),
ContinuousMapZero.coeFnAddMonoidHom f = ⇑f | true |
Set.Finite.convexHull_eq_image | Mathlib.Analysis.Convex.StdSimplex | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {E : Type u_3}
[inst_3 : AddCommGroup E] [inst_4 : Module R E] {s : Set E} (hs : s.Finite),
(convexHull R) s = ⇑(∑ x, (LinearMap.proj x).smulRight ↑x) '' stdSimplex R ↑s | true |
Lean.Grind.ToInt.Pow | Init.Grind.ToInt | (α : Type u) → [HPow α ℕ α] → (I : outParam Lean.Grind.IntInterval) → [Lean.Grind.ToInt α I] → Prop | true |
Nat.Prime.emultiplicity_choose_prime_pow | Mathlib.Data.Nat.Multiplicity | ∀ {p n k : ℕ}, Nat.Prime p → k ≤ p ^ n → k ≠ 0 → emultiplicity p ((p ^ n).choose k) = ↑(n - multiplicity p k) | true |
InfHom.noConfusionType | Mathlib.Order.Hom.Lattice | Sort u →
{α : Type u_6} →
{β : Type u_7} →
[inst : Min α] →
[inst_1 : Min β] →
InfHom α β → {α' : Type u_6} → {β' : Type u_7} → [inst' : Min α'] → [inst'_1 : Min β'] → InfHom α' β' → Sort u | false |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk'_map | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) {X Y : B} (a : X ⟶ Y),
(CategoryTheory.StrictlyUnitaryLaxFunctor.mk' S).map a = S.map a | true |
MulActionHom.comp._proof_3 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_2} {φ : M → N} {ψ : N → P} {χ : M → P} {X : Type u_6} [inst : SMul M X]
{Y : Type u_5} [inst_1 : SMul N Y] {Z : Type u_1} [inst_2 : SMul P Z] (g : Y →ₑ[ψ] Z) (f : X →ₑ[φ] Y)
[κ : CompTriple φ ψ χ] (m : M) (x : X), (ψ ∘ φ) m • g (f x) = χ m • g (f x) | false |
LLVM.constFalse | Lean.Compiler.IR.LLVMBindings | (ctx : LLVM.Context) → BaseIO (LLVM.Value ctx) | true |
_private.Batteries.Lean.EStateM.0.EStateM.bind.match_1.eq_1 | Batteries.Lean.EStateM | ∀ {ε σ α : Type u_1} (motive : EStateM.Result ε σ α → Sort u_2) (a : α) (s : σ)
(h_1 : (a : α) → (s : σ) → motive (EStateM.Result.ok a s))
(h_2 : (e : ε) → (s : σ) → motive (EStateM.Result.error e s)),
(match EStateM.Result.ok a s with
| EStateM.Result.ok a s => h_1 a s
| EStateM.Result.error e s => h_2 e... | true |
List.le_maximum_of_length_pos_iff._simp_1 | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] {l : List α} {b : α} (h : 0 < l.length),
(b ≤ List.maximum_of_length_pos h) = (↑b ≤ l.maximum) | false |
Ideal.le_comap_pow | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : FunLike F R S]
[rc : RingHomClass F R S] (f : F) {K : Ideal S} (n : ℕ), Ideal.comap f K ^ n ≤ Ideal.comap f (K ^ n) | true |
IsPrimitiveRoot.subOneIntegralPowerBasisOfPrimePow.eq_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p k : ℕ} {K : Type u} [inst : Field K] {ζ : K} [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[inst_2 : IsCyclotomicExtension {p ^ k} ℚ K] (hζ : IsPrimitiveRoot ζ (p ^ k)),
hζ.subOneIntegralPowerBasisOfPrimePow = PowerBasis.ofAdjoinEqTop' ⋯ ⋯ | true |
Std.DTreeMap.Internal.Impl.maxKey_eq_maxKey! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α], t.WF → ∀ {he : t.isEmpty = false}, t.maxKey he = t.maxKey! | true |
CategoryTheory.ComonObj._aux_Mathlib_CategoryTheory_Monoidal_Comon____macroRules_CategoryTheory_ComonObj_termε_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | Lean.Macro | false |
Bundle.Trivialization.preimage_subset_source | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) {s : Set B}, s ⊆ e.baseSet → proj ⁻¹' s ⊆ e.source | true |
Quiver.symmetrifyCostar.eq_1 | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] (u : U),
Quiver.symmetrifyCostar u =
Equiv.sigmaSumDistrib (fun u_1 => u_1 ⟶ Quiver.Symmetrify.of.obj u) (Quiver.Hom (Quiver.Symmetrify.of.obj u)) | true |
CategoryTheory.WithInitial.optionEquiv._proof_3 | Mathlib.CategoryTheory.WithTerminal.FinCategory | ∀ (C : Type u_1) (a : Option C),
(fun x =>
match x with
| CategoryTheory.WithInitial.of a => some a
| CategoryTheory.WithInitial.star => none)
((fun x =>
match x with
| some a => CategoryTheory.WithInitial.of a
| none => CategoryTheory.WithInitial.star)
... | false |
MeasureTheory.union_ae_eq_right | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, s ∪ t =ᵐ[μ] t ↔ μ (s \ t) = 0 | true |
Lean.Elab.Tactic.Simp.DischargeWrapper.ctorElim | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.Simp.DischargeWrapper → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.Tactic.Simp.DischargeWrapper) →
ctorIdx = t.ctorIdx → Lean.Elab.Tactic.Simp.DischargeWrapper.ctorElimType ctorIdx → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.