name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
IsOfFinOrder.pow_inj_mod | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G] {x : G}, IsOfFinOrder x → ∀ {n m : ℕ}, x ^ n = x ^ m ↔ n % orderOf x = m % orderOf x | true |
_private.Mathlib.Order.SupClosed.0.Set.Finite.infClosure._simp_1_5 | Mathlib.Order.SupClosed | ∀ {α : Type u_1} {s t : Finset α}, (s ∈ t.powerset) = (s ⊆ t) | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.Basic.0.hasMFDerivWithinAt_insert._simp_1_3 | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
Computation.get._proof_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} (s : Computation α) [h : s.Terminates], (↑s (Nat.find ⋯)).isSome = true | false |
Lean.Meta.Grind.instInhabitedTheoremGuard.default | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.TheoremGuard | true |
IO.AsyncList.waitUntil._unsafe_rec | Lean.Server.AsyncList | {α : Type u_1} → {ε : Type u_2} → (α → Bool) → IO.AsyncList ε α → Lean.Server.ServerTask (List α × Option ε) | false |
Real.sinh_injective | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | Function.Injective Real.sinh | true |
IsLocalRing.ResidueField.lift_residue_apply | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_4} {S : Type u_5} [inst : CommRing R] [inst_1 : IsLocalRing R] [inst_2 : Field S] (f : R →+* S)
[inst_3 : IsLocalHom f] (x : R), (IsLocalRing.ResidueField.lift f) ((IsLocalRing.residue R) x) = f x | true |
Composition.reverse_surjective | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ}, Function.Surjective Composition.reverse | true |
Metric.sphere.instHasDistribNeg | Mathlib.Analysis.Normed.Field.UnitBall | {𝕜 : Type u_1} →
[inst : SeminormedRing 𝕜] → [inst_1 : NormMulClass 𝕜] → [inst_2 : NormOneClass 𝕜] → HasDistribNeg ↑(Metric.sphere 0 1) | true |
AddCommute.symm_iff | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : Add S] {a b : S}, AddCommute a b ↔ AddCommute b a | true |
Fintype.card_compl_eq_card_compl | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} [Finite α] (p q : α → Prop) [inst : Fintype { x // p x }] [inst_1 : Fintype { x // ¬p x }]
[inst_2 : Fintype { x // q x }] [inst_3 : Fintype { x // ¬q x }],
Fintype.card { x // p x } = Fintype.card { x // q x } → Fintype.card { x // ¬p x } = Fintype.card { x // ¬q x } | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_680 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α)
(h :
List.findIdxNth (fun x => decide (x = w)) [g (g a)] (List.idxOfNth w [g (g a)] 1) + 1 ≤
(List.filter (fun x => decide (x = w)) [a, g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w))
[a, g a, g (g a)])[L... | false |
Matroid.IsMinor.trans_isStrictMinor | Mathlib.Combinatorics.Matroid.Minor.Order | ∀ {α : Type u_1} {M M' N : Matroid α}, N ≤m M → M <m M' → N <m M' | true |
IsValuativeTopology.isOpen_sphere | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {Γ₀ : Type u_3}
[inst_2 : LinearOrderedCommGroupWithZero Γ₀] [_t : TopologicalSpace R] [IsValuativeTopology R] {v : Valuation R Γ₀}
[v.Compatible] {r : MonoidWithZeroHom.ValueGroup₀ v}, r ≠ 0 → IsOpen {x | v.restrict x = r} | true |
CategoryTheory.Mat_.embeddingLiftIso._proof_4 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive] ... | false |
multipliable_of_ne_finset_one | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {L : SummationFilter β} {f : β → α}
{s : Finset β}, (∀ b ∉ s, f b = 1) → ∀ [L.HasSupport], Multipliable f L | true |
CategoryTheory.MonoOver.bot_arrow_eq_zero | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {B : C}, ⊥.arrow = 0 | true |
_private.Mathlib.Data.List.ProdSigma.0.List.sigma_nil.match_1_1 | Mathlib.Data.List.ProdSigma | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (head : α) (l : List α), motive (head :: l)) → motive x | false |
Metric.exists_edist_lt_of_hausdorffEDist_lt | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {s t : Set α} {r : ENNReal},
x ∈ s → Metric.hausdorffEDist s t < r → ∃ y ∈ t, edist x y < r | true |
Plausible.TotalFunction.PiPred.sampleableExt | Plausible.Functions | {α : Type u} → [Plausible.SampleableExt (α → Bool)] → Plausible.SampleableExt (α → Prop) | true |
DFinsupp.lsum_lsingle | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} (S : Type u_4) {M : ι → Type u_5} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : DecidableEq ι]
[inst_4 : Semiring S] [inst_5 : (i : ι) → Module S (M i)] [inst_6 : ∀ (i : ι), SMulCommClass R S (M i)],
(DFinsupp.lsum S) DFi... | true |
Filter.productSetoid | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → Filter α → (ε : α → Type u_5) → Setoid ((a : α) → ε a) | true |
String.Pos.Raw.isValidForSlice_eq_true_iff._simp_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw},
(String.Pos.Raw.isValidForSlice s p = true) = String.Pos.Raw.IsValidForSlice s p | false |
_private.Init.Data.List.Find.0.List.getLast?_filterMap._simp_1_1 | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α},
(List.filterMap f l).reverse = List.filterMap f l.reverse | false |
Lean.ClassEntry.outLevelParams | Lean.Class | Lean.ClassEntry → Array ℕ | true |
ProofWidgets.GetExprPresentationsParams.noConfusion | ProofWidgets.Presentation.Expr | {P : Sort u} →
{t t' : ProofWidgets.GetExprPresentationsParams} →
t = t' → ProofWidgets.GetExprPresentationsParams.noConfusionType P t t' | false |
NONote.lt_wf | Mathlib.SetTheory.Ordinal.Notation | WellFounded fun x1 x2 => x1 < x2 | true |
WithCStarModule.pi_norm_le_sum_norm | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_2} {E : ι → Type u_3}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] (x : WithCStarModule A ((i :... | true |
Lean.LeanOptionValue.ofString.elim | Lean.Util.LeanOptions | {motive : Lean.LeanOptionValue → Sort u} →
(t : Lean.LeanOptionValue) → t.ctorIdx = 0 → ((s : String) → motive (Lean.LeanOptionValue.ofString s)) → motive t | false |
Sym2.instFintype | Mathlib.Data.Finset.Sym | {α : Type u_1} → [Fintype α] → Fintype (Sym2 α) | true |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.Basic.0.Mathlib.Meta.Positivity.evalUpperHalfPlaneIm._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ (α : Q(Type)) (_zα : Q(Zero «$α»)) (__defeqres : PLift («$_zα» =Q Real.instZero)), «$_zα» =Q Real.instZero | false |
ContinuousLinearMapWOT.zero_apply | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_4} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [inst_8 : IsTopologi... | true |
CategoryTheory.AddGrp.braiding_hom_hom_hom | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (G H : CategoryTheory.AddGrp C), (β_ G H).hom.hom.hom = (β_ G.X H.X).hom | true |
Lean.PrettyPrinter.Delaborator.annotateGoToSyntaxDef | Mathlib.Lean.PrettyPrinter.Delaborator | Lean.Term → Lean.PrettyPrinter.Delaborator.DelabM Lean.Term | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.ENNReal.0.ENNReal.tsum_set_const._simp_1_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_4} (s : Set α), ↑s.encard = ∑' (x : ↑s), 1 | false |
ContinuousOn.zpow | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G]
[inst_3 : TopologicalSpace α] {f : α → G} {s : Set α}, ContinuousOn f s → ∀ (z : ℤ), ContinuousOn (fun x => f x ^ z) s | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.hq | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ {A : Type u} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
(self : Algebra.Smooth.DescentAux✝ A B) (i : Algebra.Smooth.DescentAux.vars✝ self),
(MvPolynomial.eval (Algebra.Smooth.DescentAux.P✝ self).relation) (Algebra.Smooth.DescentAux.q✝ self i) =
Algebra.Smooth.DescentAux.h✝... | true |
_private.Mathlib.Analysis.Normed.Algebra.Unitization.0.Unitization.instNormOneClass._simp_1 | Mathlib.Analysis.Normed.Algebra.Unitization | ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (a ⊔ b = a) = (b ≤ a) | false |
PosNum.one | Mathlib.Data.Num.Basic | PosNum | true |
CategoryTheory.ShortComplex.RightHomologyMapData.id_φQ | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData),
(CategoryTheory.ShortComplex.RightHomologyMapData.id h).φQ = CategoryTheory.CategoryStruct.id h.Q | true |
MeasureTheory.setToFun_toL1 | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : CompleteSpace F] {T : Set α → E →L[ℝ] F} {C : ℝ} {f : α → E}
(hT : MeasureTheory.Domina... | true |
_private.Init.Data.List.ToArray.0.Array.isEqvAux.match_1.splitter | Init.Data.List.ToArray | {α : Type u_1} →
(xs : Array α) →
(motive : (x : ℕ) → x ≤ xs.size → Sort u_2) →
(x : ℕ) →
(x_1 : x ≤ xs.size) →
((x : 0 ≤ xs.size) → motive 0 x) → ((i : ℕ) → (h : i + 1 ≤ xs.size) → motive i.succ h) → motive x x_1 | true |
infPrime_toDual | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a : α}, InfPrime (OrderDual.toDual a) ↔ SupPrime a | true |
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.computePrioritizedCompletionPartitions.match_5 | Lean.Server.Completion.CompletionInfoSelection | (motive : Option String.Pos.Raw → Sort u_1) →
(size₂? : Option String.Pos.Raw) →
((size₂ : String.Pos.Raw) → motive (some size₂)) → ((x : Option String.Pos.Raw) → motive x) → motive size₂? | false |
CategoryTheory.GrothendieckTopology.MayerVietorisSquare.sequenceIso | Mathlib.CategoryTheory.Sites.SheafCohomology.MayerVietoris | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
[inst_1 : CategoryTheory.HasWeakSheafify J (Type v)] →
[inst_2 : CategoryTheory.HasSheafify J AddCommGrpCat] →
[inst_3 : CategoryTheory.HasExt (CategoryTheory.Sheaf J AddCommGrpCat)] →
... | true |
DividedPowers.Quotient.dividedPowers._proof_1 | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommRing A] {J : Ideal A}, Function.Surjective ⇑(Ideal.Quotient.mk J) | false |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.cardFactors_eq_sum_factorization._simp_1_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {ι : Type u_1} [inst : DecidableEq ι] (l : List ι), l.length = ∑ a ∈ l.toFinset, List.count a l | false |
RCLike.normSq._proof_2 | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.re 1 * RCLike.re 1 + RCLike.im 1 * RCLike.im 1 = 1 | false |
CategoryTheory.Limits.IndObjectPresentation.yoneda_ι_app | Mathlib.CategoryTheory.Limits.Indization.IndObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C) (x : CategoryTheory.Discrete PUnit.{v + 1}),
(CategoryTheory.Limits.IndObjectPresentation.yoneda X).ι.app x =
CategoryTheory.CategoryStruct.id (((CategoryTheory.Functor.fromPUnit X).comp CategoryTheory.yoneda).obj x) | true |
instContainConstants | Mathlib.RingTheory.Derivation.DifferentialRing | ∀ (A : Type u_1) [inst : CommRing A] [inst_1 : Differential A], Differential.ContainConstants A A | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.norm_jacobiTheta₂_term_le._simp_1_3 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a b : α} [AddRightMono α], (-a ≤ -b) = (b ≤ a) | false |
WittVector.init_nsmul | Mathlib.RingTheory.WittVector.InitTail | ∀ {p : ℕ} {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (m : ℕ) (x : WittVector p R) (n : ℕ),
WittVector.init n (m • x) = WittVector.init n (m • WittVector.init n x) | true |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.kerFun_dense._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] {H : Type u_4} [inst_3 : NormedAddCommGroup H] [inst_4 : InnerProductSpace 𝕜 H]
[inst_5 : RKHS 𝕜 H X V] [inst_6 : CompleteSpace H] [inst_7 : CompleteSpace V] (x : X) (v : V) (f : H)... | false |
DirichletCharacter.sum_char_inv_mul_char_eq | Mathlib.NumberTheory.DirichletCharacter.Orthogonality | ∀ (R : Type u_1) [inst : CommRing R] {n : ℕ} [NeZero n] [HasEnoughRootsOfUnity R (Monoid.exponent (ZMod n)ˣ)]
[inst_3 : IsDomain R] {a : ZMod n}, IsUnit a → ∀ (b : ZMod n), ∑ χ, χ a⁻¹ * χ b = if a = b then ↑n.totient else 0 | true |
_private.Mathlib.Data.List.Chain.0.List.isChain_cons_iff._simp_1_5 | Mathlib.Data.List.Chain | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | false |
List.zipWith5 | Mathlib.Data.List.Defs | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
{δ : Type u_4} →
{ε : Type u_5} → {ζ : Type u_6} → (α → β → γ → δ → ε → ζ) → List α → List β → List γ → List δ → List ε → List ζ | true |
Lean.Parser.SyntaxStack.empty | Lean.Parser.Types | Lean.Parser.SyntaxStack | true |
Std.Internal.List.getValueCast!_eraseKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {k a : α}
[inst_2 : Inhabited (β a)],
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getValueCast! a (Std.Internal.List.eraseKey k l) =
if (k == a) = true then default else Std.Internal.List.getValueCast... | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.divCoeffs.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c : Lean.Meta.Grind.Arith.Cutsat.LeCnstr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.divCoeffs c) = 1 + sizeOf c | true |
Pi.single_mul | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] [inst_1 : DecidableEq ι] (i : ι) (x y : α i),
Pi.single i (x * y) = Pi.single i x * Pi.single i y | true |
equicontinuous_iInf_dom | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {κ : Type u_2} {X' : Type u_4} {α : Type u_6} [uα : UniformSpace α] {t : κ → TopologicalSpace X'}
{F : ι → X' → α} {k : κ}, Equicontinuous F → Equicontinuous F | true |
Aesop.ForwardRule.mk | Aesop.Rule.Forward | Aesop.ForwardRuleInfo → Aesop.RuleName → Aesop.RuleTerm → Aesop.ForwardRulePriority → Aesop.ForwardRule | true |
Batteries.RBMap.findEntry?_some | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2} {x : α} {y : α × β} [Std.TransCmp cmp]
{t : Batteries.RBMap α β cmp}, t.findEntry? x = some y ↔ y ∈ t.toList ∧ cmp x y.1 = Ordering.eq | true |
AddAction.IsTrivialBlock.isBlock | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] {B : Set X},
AddAction.IsTrivialBlock B → AddAction.IsBlock G B | true |
Computability.Γ'.comma.sizeOf_spec | Mathlib.Computability.Encoding | sizeOf Computability.Γ'.comma = 1 | true |
List.mem_getLast?_append_of_mem_getLast? | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α} {x : α}, x ∈ l₂.getLast? → x ∈ (l₁ ++ l₂).getLast? | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Module.0.Module.support_subset_preimage_comap._simp_1_3 | Mathlib.RingTheory.Spectrum.Prime.Module | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] {f : F}
{K : Ideal S} [inst_3 : RingHomClass F R S] {x : R}, (x ∈ Ideal.comap f K) = (f x ∈ K) | false |
CategoryTheory.instPreservesFiniteColimitsObjFunctorExactFunctor | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : C ⥤ₑ D), CategoryTheory.Limits.PreservesFiniteColimits F.obj | true |
Bimod.Hom.ext_iff | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C}
{A B : CategoryTheory.Mon C} {M N : Bimod A B} {x y : M.Hom N}, x = y ↔ x.hom = y.hom | true |
_private.Mathlib.RingTheory.OreLocalization.OreSet.0.OreLocalization.nonempty_oreSet_iff.match_1_1 | Mathlib.RingTheory.OreLocalization.OreSet | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} (motive : Nonempty (OreLocalization.OreSet S) → Prop)
(x : Nonempty (OreLocalization.OreSet S)), (∀ (val : OreLocalization.OreSet S), motive ⋯) → motive x | false |
Lean.Expr.mkDataForBinder | Lean.Expr | UInt64 → ℕ → UInt32 → Bool → Bool → Bool → Bool → Lean.Expr.Data | true |
Lean.Expr.data | Lean.Expr | Lean.Expr → Lean.Expr.Data | true |
_private.Mathlib.Logic.Basic.0.and_symm_left._simp_1_1 | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
ContinuousAlternatingMap.mk.injEq | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {ι : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] (toContinuousMultilinearMap : ContinuousMultilinearMap R (fun x => M) N)
(... | true |
BoundedLatticeHom.comp | Mathlib.Order.Hom.BoundedLattice | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : Lattice α] →
[inst_1 : Lattice β] →
[inst_2 : Lattice γ] →
[inst_3 : BoundedOrder α] →
[inst_4 : BoundedOrder β] →
[inst_5 : BoundedOrder γ] → BoundedLatticeHom β γ → BoundedLatticeHom α β ... | true |
_private.Aesop.Search.Expansion.Norm.0.Aesop.normSimpCore.match_1 | Aesop.Search.Expansion.Norm | (motive : Aesop.SimpResult → Sort u_1) →
(result : Aesop.SimpResult) →
((usedTheorems : Lean.Meta.Simp.UsedSimps) → motive (Aesop.SimpResult.solved usedTheorems)) →
(Unit → motive Aesop.SimpResult.unchanged) →
((newGoal : Lean.MVarId) →
(usedTheorems : Lean.Meta.Simp.UsedSimps) → motive ... | false |
ContinuousMultilinearMap.restrictScalars | Mathlib.Topology.Algebra.Module.Multilinear.Basic | (R : Type u) →
{ι : Type v} →
{M₁ : ι → Type w₁} →
{M₂ : Type w₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 : Module R M₂] →
[i... | true |
Monoid.exponent_ne_zero_of_finite | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : LeftCancelMonoid G] [Finite G], Monoid.exponent G ≠ 0 | true |
MulOpposite.instCommGroup._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : CommGroup α] (a b : αᵐᵒᵖ), a * b = b * a | false |
himp_iInf_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] {a : α} {f : ι → α}, a ⇨ ⨅ x, f x = ⨅ x, a ⇨ f x | true |
Std.TreeMap.isSome_minKey?_insertIfNew | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
(t.insertIfNew k v).minKey?.isSome = true | true |
AddMonoidAlgebra.toDirectSum_intCast | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | ∀ {ι : Type u_1} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Ring M] (z : ℤ),
(↑z).toDirectSum = ↑z | true |
Lean.Lsp.InlayHintKind._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.InlayHintKind → ℕ | false |
StieltjesFunction.length_subadditive_Icc_Ioo | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R) [OrderTopology R]
[CompactIccSpace R] {a b : R} {c d : ℕ → R},
Set.Icc a b ⊆ ⋃ i, Iotop (c i) (d i) → ENNReal.ofReal (↑f b - ↑f a) ≤ ∑' (i : ℕ), ENNReal.ofReal (↑f (d i) - ↑f (c i)) | true |
Finset.Iio_mul_Iic_subset' | Mathlib.Algebra.Group.Pointwise.Finset.Interval | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : PartialOrder α] [inst_2 : DecidableEq α] [MulLeftStrictMono α]
[MulRightStrictMono α] [inst_5 : LocallyFiniteOrderBot α] (a b : α), Finset.Iio a * Finset.Iic b ⊆ Finset.Iio (a * b) | true |
Std.Time.Internal.UnitVal.instRepr | Std.Time.Internal.UnitVal | {α : ℚ} → Repr (Std.Time.Internal.UnitVal α) | true |
AddSubmonoid.LocalizationMap.symm_comp_ofAddEquivOfLocalizations_apply | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) {k : N ≃+ P} (x : M),
k.symm ((f.ofAddEquivOfLocalizations k) x) = f x | true |
WithZero.total_le | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Preorder α] [Std.Total fun x1 x2 => x1 ≤ x2], Std.Total fun x1 x2 => x1 ≤ x2 | true |
IsSumNonzeroSq.rec | Mathlib.Algebra.Ring.IsFormallyReal | ∀ {R : Type u_1} [inst : Mul R] [inst_1 : Add R] [inst_2 : Zero R] {motive : (a : R) → IsSumNonzeroSq a → Prop},
(∀ {a : R} (ha : a ≠ 0), motive (a * a) ⋯) →
(∀ {a s : R} (ha : a ≠ 0) (hs : IsSumNonzeroSq s), motive s hs → motive (a * a + s) ⋯) →
∀ {a : R} (t : IsSumNonzeroSq a), motive a t | false |
Lean.Meta.abstractNestedProofs | Lean.Meta.AbstractNestedProofs | Lean.Expr → optParam Bool true → Lean.MetaM Lean.Expr | true |
Std.ExtDHashMap.mem_modify._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, (k' ∈ m.modify k f) = (k' ∈ m) | false |
Tactic.ComputeAsymptotics.WellFormedBasis.nil | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | Tactic.ComputeAsymptotics.WellFormedBasis [] | true |
Lean.Compiler.LCNF.mkDeclExt._auto_1 | Lean.Compiler.LCNF.PhaseExt | Lean.Syntax | false |
ShrinkingLemma.PartialRefinement.ctorIdx | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
{inst : TopologicalSpace X} →
{u : ι → Set X} → {s : Set X} → {p : Set X → Prop} → ShrinkingLemma.PartialRefinement u s p → ℕ | false |
MeasureTheory.distribHaarChar._proof_2 | Mathlib.MeasureTheory.Measure.Haar.DistribChar | ∀ {G : Type u_1} (A : Type u_2) [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : DistribMulAction G A]
[inst_3 : TopologicalSpace A] [ContinuousConstSMul G A], MeasurableConstSMul G A | false |
CategoryTheory.GrothendieckTopology.Point.skyscraperPresheafFunctor_obj_obj | Mathlib.CategoryTheory.Sites.Point.Skyscraper | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (Φ : J.Point)
{A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A] [inst_2 : CategoryTheory.Limits.HasProducts A] (k : A)
(j : Cᵒᵖ), (Φ.skyscraperPresheafFunctor.obj k).obj j = ∏ᶜ fun t => k | true |
Lean.IR.declMapExt | Lean.Compiler.IR.CompilerM | Lean.SimplePersistentEnvExtension Lean.IR.Decl Lean.IR.DeclMap | true |
List.suffix_insert | Mathlib.Data.List.Infix | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l : List α), l <:+ List.insert a l | true |
AddSubgroupClass.toAddGroup._proof_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_2} (H : S) [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G],
autoParam (∀ (a b : ↥H), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.