name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IrreducibleSpace.rec | Mathlib.Topology.Irreducible | {X : Type u_3} →
[inst : TopologicalSpace X] →
{motive : IrreducibleSpace X → Sort u} →
([toPreirreducibleSpace : PreirreducibleSpace X] → (toNonempty : Nonempty X) → motive ⋯) →
(t : IrreducibleSpace X) → motive t | null | false |
aeSeq.eq_1 | Mathlib.MeasureTheory.Function.AEMeasurableSequence | ∀ {ι : Sort u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : ι → α → β}
{μ : MeasureTheory.Measure α} (hf : ∀ (i : ι), AEMeasurable (f i) μ) (p : α → (ι → β) → Prop) (i : ι) (x : α),
aeSeq hf p i x = if x ∈ aeSeqSet hf p then AEMeasurable.mk (f i) ⋯ x else ⋯.some | null | true |
AddMonoidHom.compLeftContinuous.congr_simp | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ (α : Type u_1) {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_3}
[inst_2 : AddMonoid β] [inst_3 : ContinuousAdd β] [inst_4 : TopologicalSpace γ] [inst_5 : AddMonoid γ]
[inst_6 : ContinuousAdd γ] (g g_1 : β →+ γ) (e_g : g = g_1) (hg : Continuous ⇑g),
AddMonoidHom.compLeftCon... | null | true |
Std.ExtDTreeMap.Const.getKey?_filter | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{f : α → β → Bool} {k : α},
(Std.ExtDTreeMap.filter f t).getKey? k = (t.getKey? k).pfilter fun x h' => f x (Std.ExtDTreeMap.Const.get t x ⋯) | null | true |
TendstoLocallyUniformly.fun_sub | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3} {X : Type u_4}
[inst_3 : TopologicalSpace X] {F G : ι → X → α} {f g : X → α} {l : Filter ι},
TendstoLocallyUniformly F f l →
TendstoLocallyUniformly G g l → TendstoLocallyUniformly (fun i i_1 => F i i_1 - G i i_1... | Eta-expanded form of `TendstoLocallyUniformly.sub` | true |
Fin.lor._proof_1 | Init.Data.Fin.Basic | ∀ {n : ℕ}, ∀ a < n, ∀ (b : ℕ), a.lor b % n < n | null | false |
CategoryTheory.GrothendieckTopology.toPretopology._proof_4 | Mathlib.CategoryTheory.Sites.Pretopology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (J : CategoryTheory.GrothendieckTopology C) (X : C)
(S : CategoryTheory.Presieve X) (Ti : ⦃Y : C⦄ → (f : Y ⟶ X) → S f → CategoryTheory.Presieve Y),
S ∈ {R | CategoryTheory.Sieve.generate R ∈ J X} →
(∀ ⦃Y : C⦄ (f : Y ⟶ X) (H : S f), Ti f H ∈ {R | Cat... | null | false |
AntitoneOn.sup | Mathlib.Order.Lattice | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : SemilatticeSup β] {f g : α → β} {s : Set α},
AntitoneOn f s → AntitoneOn g s → AntitoneOn (f ⊔ g) s | Pointwise supremum of two antitone functions is an antitone function. | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_23 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (upper : ℕ) (h : upper < aig.decls.size) (state : Std.Sat.AIG.toCNF.State✝ aig)
(lhs rhs : Std.Sat.AIG.Fanin) (this : lhs.gate < upper ∧ rhs.gate < upper) (lstate : Std.Sat.AIG.toCNF.State✝ aig),
Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state lstate lhs.gate ⋯ →
∀ (rstate : Std.Sat.AIG.toC... | null | false |
_private.Mathlib.Algebra.Order.Antidiag.Nat.0.Nat.card_pair_lcm_eq.f._proof_1 | Mathlib.Algebra.Order.Antidiag.Nat | NeZero (2 + 1) | null | false |
CategoryTheory.Mon.instCartesianMonoidalCategory._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M N : CategoryTheory.Mon C),
{ hom := CategoryTheory.SemiCartesianMonoidalCategory.fst M.X N.X, isMonHom_hom := ⋯ } =
CategoryTheory.CategoryStruct.co... | null | false |
StrictMonoOn.continuousWithinAt_right_of_image_mem_nhdsWithin | Mathlib.Topology.Order.MonotoneContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : LinearOrder β] [inst_4 : TopologicalSpace β] [OrderTopology β] [DenselyOrdered β] {f : α → β} {s : Set α}
{a : α},
StrictMonoOn f s →
s ∈ nhdsWithin a (Set.Ici a) → f '' s ∈ nhdsWithin (f a) (Set.I... | If a function `f` with a densely ordered codomain is strictly monotone on a right neighborhood
of `a` and the image of this neighborhood under `f` is a right neighborhood of `f a`, then `f` is
continuous at `a` from the right. | true |
StarOrderedRing.mk | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_3} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R],
(∀ (x y : R), x ≤ y ↔ ∃ p ∈ AddSubmonoid.closure (Set.range fun s => star s * s), y = x + p) → StarOrderedRing R | null | true |
Real.cos_add_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.cos (x + Real.pi) = -Real.cos x | null | true |
Int.Linear.Poly.eval? | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | Int.Linear.Poly → Lean.Meta.Grind.GoalM (Option ℚ) | Tries to evaluate the polynomial `p` using the partial model/assignment built so far.
The result is `none` if the polynomial contains variables that have not been assigned.
| true |
Sylow.inhabited | Mathlib.GroupTheory.Sylow | {p : ℕ} → {G : Type u_1} → [inst : Group G] → Inhabited (Sylow p G) | null | true |
IsBaseChange.linearMapRightBaseChangeEquiv._proof_3 | Mathlib.RingTheory.TensorProduct.IsBaseChangeHom | ∀ {R : Type u_5} [inst : CommSemiring R] {S : Type u_1} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (M : Type u_2)
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{P : Type u_4} [inst_7 : AddCommMonoid P] [inst_8 : Module R P] [inst_9 : Module S ... | null | false |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.node4L.match_1.eq_2 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (motive : Ordnode α → α → Ordnode α → α → Ordnode α → Sort u_2) (l : Ordnode α) (x z : α)
(r : Ordnode α)
(h_1 :
(l : Ordnode α) →
(x : α) →
(size : ℕ) →
(ml : Ordnode α) →
(y : α) → (mr : Ordnode α) → (z : α) → (r : Ordnode α) → motive l x (Ordnode.node size... | null | true |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.discharge?'.match_3 | Lean.Meta.Tactic.Simp.Rewrite | (motive : Except Lean.Exception Lean.Meta.Simp.DischargeResult → Sort u_1) →
(x : Except Lean.Exception Lean.Meta.Simp.DischargeResult) →
(Unit → motive (Except.ok Lean.Meta.Simp.DischargeResult.proved)) →
(Unit → motive (Except.ok Lean.Meta.Simp.DischargeResult.notProved)) →
(Unit → motive (Except.... | null | false |
ModularForm.E₆ | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Basic | ModularForm (Matrix.SpecialLinearGroup.mapGL ℝ).range 6 | The normalised level 1 Eisenstein series of weight 6. | true |
_private.Init.Grind.Ring.CommSemiringAdapter.0.Lean.Grind.CommRing.Expr.toPolyS.match_4.eq_9 | Init.Grind.Ring.CommSemiringAdapter | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (k : ℤ) (h_1 : (n : ℤ) → motive (Lean.Grind.CommRing.Expr.num n))
(h_2 : (x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x))
(h_3 : (a b : Lean.Grind.CommRing.Expr) → motive (a.add b))
(h_4 : (a b : Lean.Grind.CommRing.Expr) → motive (a.mul b))... | null | true |
String.Pos.Splits.cast | Init.Data.String.Lemmas.Splits | ∀ {s₁ s₂ : String} {p : s₁.Pos} {t₁ t₂ : String} (h : s₁ = s₂), p.Splits t₁ t₂ → (p.cast h).Splits t₁ t₂ | null | true |
BitVec.slt_trichotomy | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w), x.slt y = true ∨ x = y ∨ y.slt x = true | For all bitvectors `x, y`, either `x` is signed less than `y`,
or is equal to `y`, or is signed greater than `y`. | true |
CategoryTheory.NatTrans.unop_whiskerRight | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} {E : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} E]
{H : CategoryTheory.Functor Dᵒᵖ Eᵒᵖ} (α : F ⟶ G),
CategoryTheory.NatTrans.unop (CategoryTheo... | null | true |
Set.union_diff_self | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ∪ t \ s = s ∪ t | **Alias** of `Set.union_sdiff_self`. | true |
intervalIntegral.derivWithin_integral_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
∀ {s t : Set ℝ} [intervalIntegral.FTCFilter b (nhdsWithin b s) (nhdsWithin b t)],
StronglyMeasurableAtFilter f (nhdsWithin b t) MeasureTheory.vol... | Fundamental theorem of calculus: if `f : ℝ → E` is integrable on `a..b` and `f x` is continuous
on the right or on the left at `b`, then the right (resp., left) derivative of
`u ↦ ∫ x in a..u, f x` at `b` equals `f b`. | true |
Matrix.mul_transvection_apply_same | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {n : Type u_1} {R : Type u₂} [inst : DecidableEq n] [inst_1 : CommRing R] (i j : n) [inst_2 : Fintype n]
{m : Type u_4} (a : m) (c : R) (M : Matrix m n R), (M * Matrix.transvection i j c) a j = M a j + c * M a i | null | true |
SSet.Subcomplex.Pairing.hint._@.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing.1340996045._hygCtx._hyg.3 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} →
{A : X.Subcomplex} → A.Pairing → {Y : SSet} → {B : Y.Subcomplex} → (e : Y ≅ X) → A.preimage e.hom = B → Prop | A unification hint for the type (II) simplices of `Pairing.ofIso`. | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.mem_of_necessary_assignment._simp_1_4 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
AddCommGroup.modEq_iff_eq_add_zsmul | Mathlib.Algebra.Group.ModEq | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a b : G}, a ≡ b [PMOD p] ↔ ∃ z, b = a + z • p | null | true |
CommMonCat.fullyFaithfulForgetToMonCat.eq_1 | Mathlib.Algebra.Category.MonCat.Basic | CommMonCat.fullyFaithfulForgetToMonCat =
{ preimage := fun {X Y} f => CommMonCat.ofHom (MonCat.Hom.hom f),
map_preimage := @CommMonCat.fullyFaithfulForgetToMonCat._proof_1,
preimage_map := @CommMonCat.fullyFaithfulForgetToMonCat._proof_2 } | null | true |
NonUnitalNonAssocSemiring.mem_center_iff | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] (a : α),
a ∈ NonUnitalSubsemiring.center α ↔
AddMonoid.End.mulRight a = AddMonoid.End.mulLeft a ∧ AddMonoid.End.mulLeft a ∈ (CentroidHom.toEndRingHom α).rangeS | null | true |
TwoPointing.prop_fst | Mathlib.Data.TwoPointing | TwoPointing.prop.toProd.1 = False | null | true |
equicontinuousWithinAt_empty._simp_1 | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] [h : IsEmpty ι]
(F : ι → X → α) (S : Set X) (x₀ : X), EquicontinuousWithinAt F S x₀ = True | null | false |
CategoryTheory.Limits.FintypeCat.instPreservesFiniteColimitsFintypeCatForgetFunObjFinite | Mathlib.CategoryTheory.Limits.FintypeCat | CategoryTheory.Limits.PreservesFiniteColimits (CategoryTheory.forget FintypeCat) | Help typeclass inference to infer preservation of finite colimits for the forgetful functor. | true |
Std.DTreeMap.instCoeTypeForall_2 | Std.Data.DTreeMap.AdditionalOperations | {α : Type u} → Coe (Type v) (α → Type v) | null | true |
Lean.Meta.Grind.AC.EqCnstr.casesOn | Lean.Meta.Tactic.Grind.AC.Types | {motive_1 : Lean.Meta.Grind.AC.EqCnstr → Sort u} →
(t : Lean.Meta.Grind.AC.EqCnstr) →
((lhs rhs : Lean.Grind.AC.Seq) →
(h : Lean.Meta.Grind.AC.EqCnstrProof) → (id : ℕ) → motive_1 { lhs := lhs, rhs := rhs, h := h, id := id }) →
motive_1 t | null | false |
PresheafOfModules.Sheafify.SMulCandidate.mk'._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[CategoryTheory.Presheaf.IsLocallyInjective J α] {M₀ : PresheafOfModules R₀}
{A : CategoryTheory.Sheaf J AddCom... | null | false |
IccRightChart._proof_1 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (x y : ℝ) [h : Fact (x < y)] (z : EuclideanHalfSpace 1), max (y - (↑z).ofLp 0) x ∈ Set.Icc x y | null | false |
Set.inl_compl_union_inr_compl | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, Sum.inl '' sᶜ ∪ Sum.inr '' tᶜ = (Sum.inl '' s ∪ Sum.inr '' t)ᶜ | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic.0.IntervalIntegrable.comp_mul_left._simp_1_6 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity.0.ContinuousOn.cfc_fun._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} {p : Filter ι} [inst : UniformSpace β] {𝔖 : Set (Set α)}
{F : ι → UniformOnFun α β 𝔖} {f : UniformOnFun α β 𝔖},
Filter.Tendsto F p (nhds f) = ∀ s ∈ 𝔖, TendstoUniformlyOn (⇑(UniformOnFun.toFun 𝔖) ∘ F) ((UniformOnFun.toFun 𝔖) f) p s | null | false |
HomotopicalAlgebra.PrepathObject.RightHomotopy.op._proof_4 | Mathlib.AlgebraicTopology.ModelCategory.RightHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {P : HomotopicalAlgebra.PrepathObject Y}
{f g : X ⟶ Y} (h : P.RightHomotopy f g), CategoryTheory.CategoryStruct.comp P.op.i₁ h.h.op = g.op | null | false |
Stream'.Seq.ofList._proof_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u_1} (l : List α) {n : ℕ}, (fun x => l[x]?) n = none → (fun x => l[x]?) (n + 1) = none | null | false |
LocallyConstant.mk | Mathlib.Topology.LocallyConstant.Basic | {X : Type u_5} →
{Y : Type u_6} → [inst : TopologicalSpace X] → (toFun : X → Y) → IsLocallyConstant toFun → LocallyConstant X Y | null | true |
AddCommGrpCat.limitCone._proof_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} J] (F : CategoryTheory.Functor J AddCommGrpCat)
[Small.{u_1, max u_1 u_2} ↑(F.comp (CategoryTheory.forget AddCommGrpCat)).sections],
Small.{u_1, max u_1 u_2}
↑((F.comp (CategoryTheory.forget₂ AddCommGrpCat AddGrpCat)).comp (CategoryTheory.forget AddGrp... | null | false |
CategoryTheory.Functor.instMonoidalActionMapAction | Mathlib.CategoryTheory.Action.Monoidal | {V : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
{G : Type u_2} →
[inst_1 : Monoid G] →
{W : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_2, u_3} W] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
[inst_4 : CategoryTheory.MonoidalCategory W] →... | A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. | true |
borel_anti | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1}, Antitone (@borel α) | null | true |
Homeomorph.neg._proof_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G],
Continuous (Equiv.neg G).toFun | null | false |
SimpleGraph.UnitDistEmbedding.noConfusion | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | {P : Sort u} →
{V : Type u_1} →
{G : SimpleGraph V} →
{E : Type u_3} →
{inst : MetricSpace E} →
{t : G.UnitDistEmbedding E} →
{V' : Type u_1} →
{G' : SimpleGraph V'} →
{E' : Type u_3} →
{inst' : MetricSpace E'} →
... | null | false |
Std.DTreeMap.Internal.Impl.maxEntry.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : (x : Std.DTreeMap.Internal.Impl α β) → x.isEmpty = false → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(x_1 : x.isEmpty = false) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.In... | null | false |
IsOrderedModule.of_smul_one_mono | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] [inst_3 : Preorder α]
[inst_4 : Preorder β] [inst_5 : MulOneClass β] [PosMulMono β] [MulPosMono β] [IsScalarTower α β β],
(Monotone fun x => x • 1) → IsOrderedModule α β | null | true |
alternatingGroup.isCoatom_stabilizer_of_ncard_lt_ncard_compl | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {s : Set α},
s.Nontrivial → s.ncard < sᶜ.ncard → IsCoatom (MulAction.stabilizer (↥(alternatingGroup α)) s) | Note : The proof of this statement is close to that
of `Equiv.Perm.isCoatom_stabilizer_of_ncard_lt_ncard_compl`,
and while it would not be absolutely impossible to abstract both proofs,
the result would be slightly awkward because the
details of the results involved in the proof differ in annoying details.
And it would... | true |
Std.TreeMap.instSliceableRioSlice | Std.Data.TreeMap.Slice | {α : Type u} →
{β : Type v} →
(cmp : autoParam (α → α → Ordering) Std.TreeMap.instSliceableRioSlice._auto_1) →
Std.Rio.Sliceable (Std.TreeMap α β cmp) α (Std.DTreeMap.Internal.Const.RioSlice α β) | null | true |
HurwitzZeta.sinKernel.eq_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : UnitAddCircle) (x : ℝ), HurwitzZeta.sinKernel a x = ⋯.lift a | null | true |
toAlgHom_comp_sectionOfRetractionKerToTensorAux | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] (l : TensorProduct P S Ω[P⁄R] →ₗ[P] ↥(RingHom.ker (algebraMap P S)))
(hl : l ∘ₗ KaehlerDifferential.kerToTensor R P S = LinearMap.id) (σ : S → P)
(hσ : ∀ (x ... | null | true |
UInt64.instLawfulOrderOrd | Init.Data.Ord.UInt | Std.LawfulOrderOrd UInt64 | null | true |
CategoryTheory.WithInitial.mkCommaObject_right_map | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(F : CategoryTheory.Functor (CategoryTheory.WithInitial C) D) {X Y : C} (f : X ⟶ Y),
(CategoryTheory.WithInitial.mkCommaObject F).right.map f = F.map (CategoryTheory.WithInitial.incl.map f) | null | true |
_private.Mathlib.Data.Finset.Slice.0.Set.sized_iUnion._simp_1_2 | Mathlib.Data.Finset.Slice | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Bimod.comp | 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 O : Bimod A B} → M.Hom N → N.Hom O → M.Hom O | Composition of bimodule object morphisms. | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctor_obj | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {S' : C} {p : S' ⟶ S} {ι' : Type t'} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'}
{α : ι' → ι} {p' : (j : ι') → ... | null | true |
SimpleGraph.Subgraph.topIso._proof_3 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (x : ↑⊤.verts), ⟨↑x, ⋯⟩ = x | null | false |
BotHom.instDistribLattice._proof_4 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Bot α] [inst_1 : DistribLattice β] [inst_2 : OrderBot β] (x x_1 : BotHom α β),
⇑(x ⊓ x_1) = ⇑(x ⊓ x_1) | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.toOption.eq_3 | Init.Data.String.Pattern.String | ∀ {s : String.Slice} (needle : String.Slice) (table : Vector ℕ needle.utf8ByteSize)
(ht : table = String.Slice.Pattern.ForwardSliceSearcher.buildTable needle) (stackPos needlePos : String.Pos.Raw)
(hn : needlePos < needle.rawEndPos),
String.Slice.Pattern.ForwardSliceSearcher.toOption✝
(String.Slice.Pattern.... | null | true |
ProbabilityTheory.variance_sub_const | Mathlib.Probability.Moments.Variance | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω}
[MeasureTheory.IsProbabilityMeasure μ],
MeasureTheory.AEStronglyMeasurable X μ →
∀ (c : ℝ), ProbabilityTheory.variance (fun ω => X ω - c) μ = ProbabilityTheory.variance X μ | null | true |
Mathlib.Tactic.Ring.Common.Cache.ctorIdx | Mathlib.Tactic.Ring.Common | {u : Lean.Level} → {α : Q(Type u)} → {sα : Q(CommSemiring «$α»)} → Mathlib.Tactic.Ring.Common.Cache sα → ℕ | null | false |
List.head_append_right | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ l₂ : List α} (w : l₁ ++ l₂ ≠ []) (h : l₁ = []), (l₁ ++ l₂).head w = l₂.head ⋯ | null | true |
CategoryTheory.CommShift₂Setup._sizeOf_inst | Mathlib.CategoryTheory.Shift.CommShiftTwo | (D : Type u_5) →
{inst : CategoryTheory.Category.{v_5, u_5} D} →
(M : Type u_6) →
{inst_1 : AddCommMonoid M} →
{inst_2 : CategoryTheory.HasShift D M} → [SizeOf D] → [SizeOf M] → SizeOf (CategoryTheory.CommShift₂Setup D M) | null | false |
_private.Init.Data.Option.Instances.0.Option.eq_none_of_isNone.match_1_1 | Init.Data.Option.Instances | ∀ {α : Type u_1} (motive : (x : Option α) → x.isNone = true → Prop) (x : Option α) (x_1 : x.isNone = true),
(∀ (x : none.isNone = true), motive none x) → motive x x_1 | null | false |
Order.IsIdeal.Directed | Mathlib.Order.Ideal | ∀ {P : Type u_2} [inst : LE P] {I : Set P}, Order.IsIdeal I → DirectedOn (fun x1 x2 => x1 ≤ x2) I | The ideal is upward directed. | true |
CategoryTheory.Pretriangulated.productTriangle.π_hom₃ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
(T : J → CategoryTheory.Pretriangulated.Triangle C) [inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁]
[inst_3 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₂]
[inst_4 : CategoryTheor... | null | true |
GrpCat.fullyFaithfulForget₂ToMonCat._proof_2 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : GrpCat} (f : X ⟶ Y), GrpCat.ofHom (MonCat.Hom.hom ((CategoryTheory.forget₂ GrpCat MonCat).map f)) = f | null | false |
QuadraticMap.isOrtho_comm | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {Q : QuadraticMap R M N} {x y : M}, Q.IsOrtho x y ↔ Q.IsOrtho y x | null | true |
SimpleGraph.Subgraph.instFinite | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} [Finite V], Finite G.Subgraph | null | true |
Subgroup.finite_quotient_of_finiteIndex | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [H.FiniteIndex], Finite (G ⧸ H) | null | true |
Matroid.IsCocircuit.delete_isCocircuit | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {K D : Set α}, M.IsCocircuit K → D ⊂ K → (M.delete D).IsCocircuit (K \ D) | null | true |
CategoryTheory.Limits.Pi.map_π | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : β → C}
[inst_1 : CategoryTheory.Limits.HasProduct f] [inst_2 : CategoryTheory.Limits.HasProduct g] (p : (b : β) → f b ⟶ g b)
(b : β),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.map p) (CategoryTheory.Limits.Pi.π g b) =
... | null | true |
MeasureTheory.AEEqFun.mul_toGerm | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Mul γ] [inst_3 : ContinuousMul γ] (f g : α →ₘ[μ] γ), (f * g).toGerm = f.toGerm * g.toGerm | null | true |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Iic_top._simp_1_1 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] {a x : α}, (x ∈ Finset.Iic a) = (x ≤ a) | null | false |
Lean.Meta.RefinedDiscrTree.Key.labelledStar.inj | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ∀ {id id_1 : ℕ},
Lean.Meta.RefinedDiscrTree.Key.labelledStar id = Lean.Meta.RefinedDiscrTree.Key.labelledStar id_1 → id = id_1 | null | true |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.match_syntax.expand.match_7 | Lean.Elab.Quotation | (motive : Option (Array (Lean.Syntax × Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → Sort u_1) →
(x : Option (Array (Lean.Syntax × Array (Lean.TSyntax `term) × Lean.TSyntax `term))) →
((tuples : Array (Lean.Syntax × Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → motive (some tuples)) →
(Unit → mo... | null | false |
Nat.Prime.one_le | Mathlib.Data.Nat.Prime.Defs | ∀ {p : ℕ}, Nat.Prime p → 1 ≤ p | null | true |
_private.Mathlib.Combinatorics.SetFamily.LYM.0.Finset.slice_union_shadow_falling_succ._simp_1_4 | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : DecidableEq α] {k : ℕ} {𝒜 : Finset (Finset α)} {s : Finset α},
(s ∈ Finset.falling k 𝒜) = ((∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k) | null | false |
MvPolynomial.coeff_linearCombination_X_pow | Mathlib.Algebra.MvPolynomial.Coeff | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R] (a : σ →₀ R) (s : σ →₀ ℕ) (n : ℕ),
MvPolynomial.coeff s ((Finsupp.linearCombination R MvPolynomial.X) a ^ n) =
if (s.sum fun x m => m) = n then ↑s.multinomial * s.prod fun r m => a r ^ m else 0 | null | true |
Batteries.Tactic.DeclCache._sizeOf_1 | Batteries.Util.Cache | {α : Type} → [SizeOf α] → Batteries.Tactic.DeclCache α → ℕ | null | false |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkHCongrWithArity'.prove._sparseCasesOn_3 | Mathlib.Lean.Meta.CongrTheorems | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
UpperSet.Ici_ne_top._simp_2 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (UpperSet.Ici a = ⊤) = False | null | false |
CategoryTheory.ObjectProperty.fullMonoidalClosedSubcategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C) [inst_2 : P.IsMonoidal] [inst_3 : CategoryTheory.MonoidalClosed C]
[inst_4 : P.IsMonoidalClosed] (X : P.FullSubcategory) ⦃X_1 Y : P.FullSubcategory⦄ (f : X_1 ⟶ Y),
Cate... | null | false |
Nat.cast_div_charZero._simp_1 | Mathlib.Data.Nat.Cast.Field | ∀ {K : Type u_1} [inst : DivisionSemiring K] {m n : ℕ} [CharZero K], n ∣ m → ↑m / ↑n = ↑(m / n) | null | false |
Decidable.not_and_iff_not_or_not | Init.PropLemmas | ∀ {a b : Prop} [Decidable a], ¬(a ∧ b) ↔ ¬a ∨ ¬b | null | true |
_private.Lean.IdentifierSuggestion.0.Lean.throwUnknownNameWithSuggestions.match_1 | Lean.IdentifierSuggestion | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → (Unit → motive none) → ((prefixName : Lean.Name) → motive (some prefixName)) → motive x | null | false |
Manifold.delabMDifferentiable | Mathlib.Geometry.Manifold.Notation | Lean.PrettyPrinter.Delaborator.Delab | Delaborator for `MDifferentiable` using the custom elaborator, and special-casing
arguments that can use the `T%` elaborator. | true |
_private.Std.Time.Format.Basic.0.Std.Time.exactlyChars.go._unary._proof_1 | Std.Time.Format.Basic | ∀ (size : ℕ) (acc : String) (count : ℕ),
¬count ≥ size →
∀ (res : Char),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun acc count => size - count)
⟨acc.push res, count.succ⟩ ⟨acc, count⟩ | null | false |
Module.End.hasEigenvalue_iff | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R}, f.HasEigenvalue μ ↔ f.eigenspace μ ≠ ⊥ | null | true |
SupHom.subtypeVal | Mathlib.Order.Hom.Lattice | {β : Type u_3} →
[inst : SemilatticeSup β] → {P : β → Prop} → (Psup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)) → SupHom { x // P x } β | `Subtype.val` as a `SupHom`. | true |
CStarMatrix.of_add_of | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Add A] (f g : Matrix m n A),
CStarMatrix.ofMatrix f + CStarMatrix.ofMatrix g = CStarMatrix.ofMatrix (f + g) | null | true |
Lean.Expr.hasLooseBVarInExplicitDomain | Lean.Expr | Lean.Expr → ℕ → Bool → Bool | Returns true if `e` contains the loose bound variable `bvarIdx` in an explicit parameter,
or in the range if `considerRange == true`.
Additionally, if the bound variable appears in an implicit parameter,
it transitively looks for that implicit parameter.
| true |
List.eraseIdx_nil | Init.Data.List.Basic | ∀ {α : Type u} {i : ℕ}, [].eraseIdx i = [] | null | true |
CategoryTheory.Adjunction.homEquiv_naturality_right_square | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X' X : C} {Y Y' : D} (f : X' ⟶ X)
(g : X ⟶ G.obj Y') (h : X' ⟶ G.obj Y) (k : Y ⟶ Y'),
CategoryTheory.CategoryStru... | null | true |
LinearEquiv.coe_injective | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {modM : Module R M} {modM₂ : Module S M₂} {σ : R →+* S}
{σ' : S →+* R} [inst_4 : RingHomInvPair σ σ'] [inst_5 : RingHomInvPair σ' σ], Function.Injective DFu... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.