name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Parser.Term.bracketedBinder._regBuiltin.Lean.Parser.Term.bracketedBinder.docString_1 | Lean.Parser.Term.Basic | IO Unit | false |
Lean.Omega.LinearCombo.coeffs._default | Init.Omega.LinearCombo | List ℤ | false |
Urysohns.CU.lim | Mathlib.Topology.UrysohnsLemma | {X : Type u_1} → [inst : TopologicalSpace X] → {P : Set X → Set X → Prop} → Urysohns.CU P → X → ℝ | true |
ENNReal.instNoZeroDivisors | Mathlib.Data.ENNReal.Basic | NoZeroDivisors ENNReal | true |
jacobiTheta_two_add | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ (τ : ℂ), jacobiTheta (2 + τ) = jacobiTheta τ | true |
BoundedVariationOn.exists_tendsto_atTop | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] [CompleteSpace E]
[hE : Nonempty E] {f : α → E} {s : Set α},
BoundedVariationOn f s → ∃ l, Filter.Tendsto f (Filter.principal s ⊓ Filter.atTop) (nhds l) | true |
Nat.sub_lt_succ | Init.Data.Nat.Lemmas | ∀ (a b : ℕ), a - b < a.succ | true |
Subfield.relrank_comap_comap_eq_relrank_of_le | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A B : Subfield E) {L : Type v} [inst_1 : Field L] (f : L →+* E),
B ≤ f.fieldRange → (Subfield.comap f A).relrank (Subfield.comap f B) = A.relrank B | true |
_private.Mathlib.NumberTheory.LucasLehmer.0.LucasLehmer.residue_eq_zero_iff_sMod_eq_zero._simp_1_1 | Mathlib.NumberTheory.LucasLehmer | ∀ (a : ℤ) (b : ℕ), (↑a = 0) = (↑b ∣ a) | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.resolveLValAux.match_3 | Lean.Elab.App | (motive : Lean.Expr → Option Lean.Name → Sort u_1) →
(x : Lean.Expr) →
(suffix? : Option Lean.Name) →
((c : Lean.Name) → (us : List Lean.Level) → (suffix : Lean.Name) → motive (Lean.Expr.const c us) (some suffix)) →
((x : Lean.Expr) → (x_1 : Option Lean.Name) → motive x x_1) → motive x suffix? | false |
_private.Mathlib.Algebra.Category.ModuleCat.ProjectiveDimension.0.ModuleCat.projectiveDimension_eq_zero_of_projective._simp_1_3 | Mathlib.Algebra.Category.ModuleCat.ProjectiveDimension | ∀ {α : Type u_1}, (¬Subsingleton α) = Nontrivial α | false |
Set.ncard_Ico_nat | Mathlib.Order.Interval.Set.Nat | ∀ (a b : ℕ), (Set.Ico a b).ncard = b - a | true |
MonoidHom.CompTriple.IsId | Mathlib.Algebra.Group.Hom.CompTypeclasses | {M : Type u_1} → [inst : Monoid M] → (M →* M) → Prop | true |
Set.indicator_apply_le' | Mathlib.Algebra.Order.Group.Indicator | ∀ {α : Type u_2} {M : Type u_3} [inst : LE M] [inst_1 : Zero M] {s : Set α} {f : α → M} {a : α} {y : M},
(a ∈ s → f a ≤ y) → (a ∉ s → 0 ≤ y) → s.indicator f a ≤ y | true |
_private.Mathlib.Tactic.ReduceModChar.0.Tactic.ReduceModChar.normPow.match_17 | Mathlib.Tactic.ReduceModChar | (b : Q(ℕ)) →
(motive : (lit : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsNat «$b» «$lit») → Sort u_1) →
(__discr : (lit : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsNat «$b» «$lit»)) →
((nb : Q(ℕ)) → (pb : Q(Mathlib.Meta.NormNum.IsNat «$b» «$nb»)) → motive ⟨nb, pb⟩) → motive __discr | false |
Pi.card_Ioc | Mathlib.Data.Pi.Interval | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : Fintype ι] [inst_1 : DecidableEq ι] [inst_2 : (i : ι) → DecidableEq (α i)]
[inst_3 : (i : ι) → PartialOrder (α i)] [inst_4 : (i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) → α i),
(Finset.Ioc a b).card = ∏ i, (Finset.Icc (a i) (b i)).card - 1 | true |
UInt8.reduceOfNat._regBuiltin.UInt8.reduceOfNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.340 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
ComplexShape.ρ₁₂._proof_1 | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_1} {I₂ : Type u_3} {I₃ : Type u_2} {I₁₂ : Type u_5} {J : Type u_4} (c₁ : ComplexShape I₁)
(c₂ : ComplexShape I₂) (c₃ : ComplexShape I₃) (c₁₂ : ComplexShape I₁₂) (c : ComplexShape J)
[inst : TotalComplexShape c₁ c₂ c₁₂] [inst_1 : TotalComplexShape c₁₂ c₃ c] (x : I₁ × I₂ × I₃),
c₁₂.π c₃ c (c₁.π c₂ c₁... | false |
IccRightChart._proof_7 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (x y : ℝ) [h : Fact (x < y)] ⦃x_1 : EuclideanHalfSpace 1⦄,
x_1 ∈ {z | (↑z).ofLp 0 < y - x} → ⟨WithLp.toLp 2 fun x_2 => y - ↑⟨max (y - (↑x_1).ofLp 0) x, ⋯⟩, ⋯⟩ = x_1 | false |
Vector.compareLex_eq_compareLex_toArray | Init.Data.Ord.Vector | ∀ {α : Type u_1} {n : ℕ} {cmp : α → α → Ordering} {a b : Vector α n},
Vector.compareLex cmp a b = Array.compareLex cmp a.toArray b.toArray | true |
_private.Lean.Parser.Types.0.Lean.Parser.withCacheFn.match_1 | Lean.Parser.Types | (motive : Option Lean.Parser.ParserCacheEntry → Sort u_1) →
(x : Option Lean.Parser.ParserCacheEntry) →
((r : Lean.Parser.ParserCacheEntry) → motive (some r)) →
((x : Option Lean.Parser.ParserCacheEntry) → motive x) → motive x | false |
_private.Batteries.Data.Char.AsciiCasing.0.Char.toUpper_eq_of_isLower._proof_1_3 | Batteries.Data.Char.AsciiCasing | ∀ {c : Char}, c.val + 4294967264 = c.val - 32 | false |
_private.Init.Data.String.Legacy.0.String.splitOnAux._unary._proof_2 | Init.Data.String.Legacy | ∀ (s sep : String) (b i j : String.Pos.Raw) (r : List String),
¬String.Pos.Raw.atEnd s i = true →
(invImage
(fun x =>
PSigma.casesOn x fun b i =>
PSigma.casesOn i fun i j =>
PSigma.casesOn j fun j r => (s.rawEndPos.byteIdx - j.byteDistance i, sep.rawEndPos.byteI... | false |
_private.Lean.Meta.Tactic.Grind.SimpUtil.0._regBuiltin.Lean.Meta.Grind.simpOr.declare_26._@.Lean.Meta.Tactic.Grind.SimpUtil.902628210._hygCtx._hyg.11 | Lean.Meta.Tactic.Grind.SimpUtil | IO Unit | false |
TopCat.I.symm | Mathlib.Topology.Category.TopCat.Monoidal | TopCat.I ⟶ TopCat.I | true |
negPart_eq_neg | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] {a : α} [AddLeftMono α], a⁻ = -a ↔ a ≤ 0 | true |
Algebra.TensorProduct.leftComm._proof_3 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B], SMulCommClass R R (TensorProduct R B A) | false |
Int64.reduceEq._regBuiltin.Int64.reduceEq.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.4041591762._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
ZFSet.instDefinable | Mathlib.SetTheory.ZFC.Basic | (n : ℕ) → (i : Fin n) → ZFSet.Definable n fun s => s i | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_insertIfNew._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
BoundingSieve.squarefree_of_mem_divisors_prodPrimes | Mathlib.NumberTheory.SelbergSieve | ∀ {s : BoundingSieve} {d : ℕ}, d ∈ s.prodPrimes.divisors → Squarefree d | true |
Finsupp.curryAddEquiv._proof_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_3} [inst : AddZeroClass M] (x x_1 : α × β →₀ M),
Finsupp.curryEquiv.toFun (x + x_1) = Finsupp.curryEquiv.toFun x + Finsupp.curryEquiv.toFun x_1 | false |
Matrix.l2_opNorm_le_one_of_mem_doublyStochastic | Mathlib.Analysis.Convex.Birkhoff | ∀ {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] {M : Matrix n n ℝ}, M ∈ doublyStochastic ℝ n → ‖M‖ ≤ 1 | true |
Complex.UnitDisc.continuous_coe | Mathlib.Analysis.Complex.UnitDisc.Basic | Continuous Complex.UnitDisc.coe | true |
ByteArray.get_ofFn._proof_2 | Batteries.Data.ByteArray | ∀ {n : ℕ} (f : Fin n → UInt8) (i : Fin (ByteArray.ofFn f).size), ↑i < (ByteArray.ofFn f).size | false |
Set.enumerateCountable.match_1 | Mathlib.Data.Set.Countable | {α : Type u_1} →
{s : Set α} →
(motive : Option ↑s → Sort u_2) → (x : Option ↑s) → ((y : ↑s) → motive (some y)) → (Unit → motive none) → motive x | false |
exists_abs_lt | Mathlib.Algebra.Order.Ring.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : LinearOrder α] [IsOrderedRing α] [Nontrivial α] (a : α), ∃ b > 0, |a| < b | true |
Distributions.«termN[_;_]_{_,_,_}» | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | Lean.ParserDescr | true |
CategoryTheory.unmop_id_mop | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C},
(CategoryTheory.CategoryStruct.id { unmop := X }).unmop = CategoryTheory.CategoryStruct.id X | true |
Std.TreeMap.getElem?_insertManyIfNewUnit_list | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeMap α Unit cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp] {l : List α} {k : α},
(t.insertManyIfNewUnit l)[k]? = if k ∈ t ∨ l.contains k = true then some () else none | true |
Delone.DeloneSet.eq_of_mem_ball | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_1} [inst : MetricSpace X] (D : Delone.DeloneSet X) {r : NNReal},
r ≤ D.packingRadius / 2 → ∀ {x y z : X}, x ∈ D → y ∈ D → x ∈ Metric.ball z ↑r → y ∈ Metric.ball z ↑r → x = y | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.map_finCongr_Ioc._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
RingHom.isStandardSmoothOfRelativeDimension_localizationPreserves | Mathlib.RingTheory.RingHom.StandardSmooth | ∀ (n : ℕ),
RingHom.LocalizationPreserves fun {R S} [CommRing R] [CommRing S] => RingHom.IsStandardSmoothOfRelativeDimension n | true |
_private.Mathlib.CategoryTheory.Monoidal.Bimon_.0.CategoryTheory.Bimon.instBimonObjXXMon._simp_3 | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Bimon C),
CategoryTheory.ComonObj.comul.hom = CategoryTheory.ComonObj.comul | false |
IsSquare.mul_self._simp_2 | Mathlib.Algebra.Group.Even | ∀ {α : Type u_2} [inst : Mul α] (r : α), IsSquare (r * r) = True | false |
MeasureTheory.eLpNorm'_enorm_rpow | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε] (f : α → ε)
(p q : ℝ), 0 < q → MeasureTheory.eLpNorm' (fun x => ‖f x‖ₑ ^ q) p μ = MeasureTheory.eLpNorm' f (p * q) μ ^ q | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.ofSliceTo_lt_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos},
(q ≤ String.Pos.ofSliceTo p) = ∃ (h : q ≤ p₀), p₀.sliceTo q h ≤ p | false |
Module.Flat.isSMulRegular_of_nonZeroDivisors | Mathlib.RingTheory.Flat.TorsionFree | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {r : R},
r ∈ nonZeroDivisors R → ∀ [Module.Flat R M], IsSMulRegular M r | true |
_private.Init.Data.Int.Bitwise.Lemmas.0.Int.le_shiftRight_of_nonneg._proof_1_2 | Init.Data.Int.Bitwise.Lemmas | ∀ {n : ℤ} {s : ℕ}, 0 < 2 ^ s → ¬0 ≤ 2 ^ s → False | false |
CategoryTheory.Iso.toCoalgEquiv_refl | Mathlib.Algebra.Category.CoalgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {X : CoalgCat R},
(CategoryTheory.Iso.refl X).toCoalgEquiv = CoalgEquiv.refl R ↑X.toModuleCat | true |
Equiv.pointReflection | Mathlib.Algebra.AddTorsor.Defs | {G : Type u_1} → {P : Type u_2} → [inst : AddGroup G] → [AddTorsor G P] → P → Equiv.Perm P | true |
HasStrictFDerivAt.localInverse_def | Mathlib.Analysis.Calculus.InverseFunctionTheorem.FDeriv | ∀ {𝕜 : 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] {f : E → F}
{f' : E ≃L[𝕜] F} {a : E} [inst_5 : CompleteSpace E] (hf : HasStrictFDerivAt f (↑f') a),
HasStrict... | true |
Module.AEval.equiv_mapSubmodule._proof_3 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_2} {A : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (p : Submodule R M) (hp : p ∈ ((Algebra.lsmul R R M) a).invtSubmodule),
Function.LeftInv... | false |
summable_subtype_iff_indicator | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {s : Set β},
Summable (f ∘ Subtype.val) ↔ Summable (s.indicator f) | true |
thickenedIndicatorAux_subset | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (δ : ℝ) {E₁ E₂ : Set α},
E₁ ⊆ E₂ → thickenedIndicatorAux δ E₁ ≤ thickenedIndicatorAux δ E₂ | true |
TestFunction.instLocallyConvexSpaceReal | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_4}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞}, LocallyConvexSpace ℝ (TestFunction Ω F n) | true |
Lean.Level.addOffsetAux._unsafe_rec | Lean.Level | ℕ → Lean.Level → Lean.Level | false |
_private.Mathlib.RingTheory.WittVector.Verschiebung.0.WittVector.term𝕎 | Mathlib.RingTheory.WittVector.Verschiebung | Lean.ParserDescr | true |
IsRelLowerSet.eq_1 | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} [inst : LE α] (s : Set α) (P : α → Prop),
IsRelLowerSet s P = ∀ ⦃a : α⦄, a ∈ s → P a ∧ ∀ ⦃b : α⦄, b ≤ a → P b → b ∈ s | true |
ProbabilityTheory.tilted_mul_apply_cgf | Mathlib.Probability.Moments.Tilted | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ} {t : ℝ} [MeasureTheory.SFinite μ]
(s : Set Ω),
MeasureTheory.Integrable (fun ω => Real.exp (t * X ω)) μ →
(μ.tilted fun x => t * X x) s =
∫⁻ (a : Ω) in s, ENNReal.ofReal (Real.exp (t * X a - ProbabilityTheory.cgf X μ t)) ∂... | true |
Option.map_comp_map | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : β → γ), Option.map g ∘ Option.map f = Option.map (g ∘ f) | true |
CategoryTheory.Monoidal.FunctorCategory.tensorObj._proof_2 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(F G : CategoryTheory.Functor C D) (X : C),
CategoryTheory.MonoidalCategoryStruct.tensorHom (F.map (CategoryTheory.CategoryStruct.id X))
... | false |
Set.sumEquiv._proof_2 | Mathlib.Order.Hom.Set | ∀ {α : Type u_2} {β : Type u_1} {a b : Set (α ⊕ β)},
{ toFun := fun s => (Sum.inl ⁻¹' s, Sum.inr ⁻¹' s), invFun := fun s => Sum.inl '' s.1 ∪ Sum.inr '' s.2, left_inv := ⋯,
right_inv := ⋯ }
a ≤
{ toFun := fun s => (Sum.inl ⁻¹' s, Sum.inr ⁻¹' s), invFun := fun s => Sum.inl '' s.1 ∪ Sum.inr '' s.... | false |
_private.Init.Data.Fin.Basic.0.Fin.mlt | Init.Data.Fin.Basic | ∀ {n b a : ℕ}, a < n → b % n < n | true |
Int.ediv_emod_unique | Init.Data.Int.DivMod.Lemmas | ∀ {a b r q : ℤ}, 0 < b → (a / b = q ∧ a % b = r ↔ r + b * q = a ∧ 0 ≤ r ∧ r < b) | true |
LieModule.maxTrivSubmodule._proof_3 | Mathlib.Algebra.Lie.Abelian | ∀ (L : Type u_2) (M : Type u_1) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] {x : L}
{m : M}, m ∈ {m | ∀ (x : L), ⁅x, m⁆ = 0} → ∀ (y : L), ⁅y, ⁅x, m⁆⁆ = 0 | false |
Complex.eq_re_of_ofReal_le | Mathlib.Analysis.Complex.Order | ∀ {r : ℝ} {z : ℂ}, ↑r ≤ z → z = ↑z.re | true |
AlgebraicGeometry.reduce_to_affine_global | Mathlib.AlgebraicGeometry.Properties | ∀ (P : {X : AlgebraicGeometry.Scheme} → X.Opens → Prop) {X : AlgebraicGeometry.Scheme} (U : X.Opens),
(∀ (X : AlgebraicGeometry.Scheme) (U : X.Opens), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U) →
(∀ (X Y : AlgebraicGeometry.Scheme) (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f],
∃ U V, U... | true |
Submodule.orthogonal_le_iff_orthogonal_le | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K₀ K₁ : Submodule 𝕜 E} [K₀.HasOrthogonalProjection] [K₁.HasOrthogonalProjection], K₀ᗮ ≤ K₁ ↔ K₁ᗮ ≤ K₀ | true |
Std.Do.Spec.tryCatch_MonadExcept | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {ε : Type u_1} {α : Type u} {x : m α} {h : ε → m α}
[inst : MonadExceptOf ε m] [inst_1 : Std.Do.WP m ps] (Q : Std.Do.PostCond α ps),
⦃(Std.Do.wp (MonadExceptOf.tryCatch x h)).apply Q⦄ tryCatch x h ⦃Q⦄ | true |
Real.definition._proof_1._@.Mathlib.Data.Real.Basic.1175651576._hygCtx._hyg.8 | Mathlib.Data.Real.Basic | ∀ (x x_1 x_2 x_3 : CauSeq ℚ abs), x ≈ x_2 → x_1 ≈ x_3 → (x < x_1) = (x_2 < x_3) | false |
ISize.instRxcHasSize.eq_1 | Init.Data.Range.Polymorphic.SInt | ISize.instRxcHasSize = { size := fun lo hi => (hi.toInt + 1 - lo.toInt).toNat } | true |
String.Pos.Raw.ne_zero_of_lt | Init.Data.String.PosRaw | ∀ {a b : String.Pos.Raw}, a < b → b ≠ 0 | true |
dist_right_convexComboPair | Mathlib.Analysis.Convex.MetricSpace | ∀ {X : Type u_1} [inst : ConvexSpace ℝ X] [inst_1 : MetricSpace X] [IsConvexMetricSpace X] {s t : ℝ} (hs : 0 ≤ s)
(ht : 0 ≤ t) (h : s + t = 1) (x y : X), dist y (convexComboPair s t hs ht h x y) = s * dist x y | true |
CategoryTheory.Pseudofunctor.StrongTrans.naturality_id_inv_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} (α : F ⟶ G) (a : B) {Z : F.obj a ⟶ G.obj a}
(h : CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.id a)) (α.app a) ⟶ Z),
CategoryTheory.Categor... | true |
SimpleGraph.Walk.bypass.eq_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u : V}, SimpleGraph.Walk.nil.bypass = SimpleGraph.Walk.nil | true |
Submonoid.LocalizationMap.AwayMap.invSelf._proof_1._to_additive_1 | Mathlib.GroupTheory.MonoidLocalization.Away | ∀ {M : Type u_1} [inst : AddCommMonoid M] (x : M), x ∈ AddSubmonoid.multiples x | false |
Lean.Meta.CustomEliminators.mk | Lean.Meta.Tactic.ElimInfo | Lean.SMap (Bool × Array Lean.Name) Lean.Name → Lean.Meta.CustomEliminators | true |
CategoryTheory.symmetricOfHasFiniteProducts | Mathlib.CategoryTheory.Monoidal.OfHasFiniteProducts | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasTerminal C] →
[inst_2 : CategoryTheory.Limits.HasBinaryProducts C] → CategoryTheory.SymmetricCategory C | true |
bddBelow_upperClosure | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, BddBelow ↑(upperClosure s) ↔ BddBelow s | true |
MvPowerSeries.trunc'_trunc' | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : DecidableEq σ] [inst_1 : CommSemiring R] {n m : σ →₀ ℕ},
n ≤ m →
∀ (φ : MvPowerSeries σ R), (MvPowerSeries.trunc' R n) ↑((MvPowerSeries.trunc' R m) φ) = (MvPowerSeries.trunc' R n) φ | true |
Fintype.prod_unique | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} {ι : Type u_7} [inst : Fintype ι] [inst_1 : CommMonoid M] [inst_2 : Unique ι] (f : ι → M),
∏ x, f x = f default | true |
SimpleGraph.Walk.support_dropLast | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, ¬p.Nil → p.dropLast.support = p.support.dropLast | true |
Lean.SimplePersistentEnvExtensionDescr._sizeOf_inst | Lean.EnvExtension | (α σ : Type) → [SizeOf α] → [SizeOf σ] → SizeOf (Lean.SimplePersistentEnvExtensionDescr α σ) | false |
Lean.Lsp.ServerCapabilities.rec | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.ServerCapabilities → Sort u} →
((textDocumentSync? : Option Lean.Lsp.TextDocumentSyncOptions) →
(completionProvider? : Option Lean.Lsp.CompletionOptions) →
(hoverProvider documentHighlightProvider documentSymbolProvider definitionProvider declarationProvider
typeDefinition... | false |
Metric.Snowflaking.image_ofSnowflaking_closedEBall | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoEMetricSpace X] (x : Metric.Snowflaking X α hα₀ hα₁)
(d : ENNReal),
⇑Metric.Snowflaking.ofSnowflaking '' Metric.closedEBall x d =
Metric.closedEBall (Metric.Snowflaking.ofSnowflaking x) (d ^ α⁻¹) | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Coskeletal.0.SSet.StrictSegal.isPointwiseRightKanExtensionAt.fac_aux₂._proof_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.Coskeletal | ∀ {n : ℕ} (i : ℕ) (hj : i ≤ n), ⟨i, ⋯⟩ ≤ ⟨i, ⋯⟩ | false |
Int8.not_le._simp_1 | Init.Data.SInt.Lemmas | ∀ {n m : Int8}, (¬n ≤ m) = (m < n) | false |
Orientation.definition._proof_2._@.Mathlib.Analysis.InnerProductSpace.TwoDim.1773570744._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | SMulCommClass ℝ ℝ ℝ | false |
_private.Mathlib.MeasureTheory.Function.ContinuousMapDense.0.MeasureTheory.MemLp.exists_hasCompactSupport_integral_rpow_sub_le._simp_1_2 | Mathlib.MeasureTheory.Function.ContinuousMapDense | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Monoid.Coprod.toProd_surjective | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N], Function.Surjective ⇑Monoid.Coprod.toProd | true |
_private.Mathlib.NumberTheory.LSeries.MellinEqDirichlet.0.hasSum_mellin._simp_1_1 | Mathlib.NumberTheory.LSeries.MellinEqDirichlet | ∀ {ι : Type u_1} {α : Type u_3} {L : SummationFilter ι} [inst : DivisionSemiring α] [inst_1 : TopologicalSpace α]
[IsTopologicalSemiring α] {f : ι → α} {a : α} [T2Space α], a * ∑'[L] (x : ι), f x = ∑'[L] (x : ι), a * f x | false |
Ordnode.Emem | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → α → Ordnode α → Prop | true |
MvPolynomial.DirectSum.coeLinearMap_eq_finsum | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ (R : Type u_1) {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] (w : σ → M)
[inst_2 : DecidableEq M] (x : DirectSum M fun i => ↥(MvPolynomial.weightedHomogeneousSubmodule R w i)),
(DirectSum.coeLinearMap fun i => MvPolynomial.weightedHomogeneousSubmodule R w i) x = ∑ᶠ (m : M), ↑(x ... | true |
DeltaGeneratedSpace.of | Mathlib.Topology.Compactness.DeltaGeneratedSpace | Type u_3 → Type u_3 | true |
FreeGroup.toWord_inj._simp_2 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] {x y : FreeGroup α}, (x.toWord = y.toWord) = (x = y) | false |
Mathlib.MoveAdd.reorderUsing | Mathlib.Tactic.MoveAdd | {α : Type u_1} → [BEq α] → List α → List (α × Bool) → List α | true |
Mathlib.Tactic.Ring.Common.ExtractCoeff | Mathlib.Tactic.Ring.Common | Q(ℕ) → Type | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameState | Lean.Elab.DeclNameGen | Type | true |
Simps.ProjectionData.rec | Mathlib.Tactic.Simps.Basic | {motive : Simps.ProjectionData → Sort u} →
((name : Lean.Name) →
(expr : Lean.Expr) →
(projNrs : List ℕ) →
(isDefault isPrefix : Bool) →
motive { name := name, expr := expr, projNrs := projNrs, isDefault := isDefault, isPrefix := isPrefix }) →
(t : Simps.ProjectionData) → motiv... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.