name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.CoordinateRing.norm_smul_basis._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Affine R},
1 = (WeierstrassCurve.Affine.CoordinateRing.basis W') 0 | null | false |
Additive.seminormedCommGroup._proof_1 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (a b : Additive E), a + b = b + a | null | false |
Real.leftDeriv_mul_log | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ∀ {x : ℝ}, x ≠ 0 → derivWithin (fun x => x * Real.log x) (Set.Iio x) x = Real.log x + 1 | null | true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.1240114214._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Affine.CoordinateRing.mk_ψ._simp_1_4 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R),
(WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C W.Ψ₂Sq) =
(WeierstrassCurve.Affine.CoordinateRing.mk W) W.ψ₂ ^ 2 | null | false |
VonNeumannAlgebra.mk.inj | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} {inst : NormedAddCommGroup H} {inst_1 : InnerProductSpace ℂ H} {inst_2 : CompleteSpace H}
{toStarSubalgebra : StarSubalgebra ℂ (H →L[ℂ] H)}
{centralizer_centralizer' : toStarSubalgebra.carrier.centralizer.centralizer = toStarSubalgebra.carrier}
{toStarSubalgebra_1 : StarSubalgebra ℂ (H →L[ℂ] H)}
... | null | true |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat._proof_3 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (pq : ℕ × ℕ), WithBotTop.coe (-↑pq.2) ≤ WithBotTop.coe (-↑pq.2 + 1) | null | false |
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.exists_range_eq_graph._simp_1_7 | Mathlib.LinearAlgebra.Prod | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
Int64.zero_sub | Init.Data.SInt.Lemmas | ∀ (a : Int64), 0 - a = -a | null | true |
Polynomial.HasSeparableContraction.dvd_degree' | Mathlib.RingTheory.Polynomial.SeparableDegree | ∀ {F : Type u_1} [inst : CommSemiring F] {q : ℕ} {f : Polynomial F} (hf : Polynomial.HasSeparableContraction q f),
∃ m, hf.degree * q ^ m = f.natDegree | null | true |
ContDiff.fun_smul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{𝕜' : Type u_3} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module 𝕜' F... | Eta-expanded form of `ContDiff.smul`
---
The scalar multiplication of two `C^n` functions is `C^n`. | true |
_private.Mathlib.Order.Atoms.0.SetLike.isCoatom_iff._simp_1_6 | Mathlib.Order.Atoms | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
Module.Flat.baseChange | Mathlib.RingTheory.Flat.Stability | ∀ (R : Type u) (S : Type v) (M : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [Module.Flat R M], Module.Flat S (TensorProduct R S M) | If `M` is a flat `R`-module and `S` is any `R`-algebra, `S ⊗[R] M` is `S`-flat. | true |
_private.Mathlib.Data.Nat.ModEq.0.Nat.ModEq.mul_right_cancel'._simp_1_1 | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, (a ≡ b [MOD n]) = (↑n ∣ ↑b - ↑a) | null | false |
Acc.of_subrel | Mathlib.Order.RelIso.Set | ∀ {α : Type u_1} {r : α → α → Prop} [IsTrans α r] {b : α} (a : { a // r a b }),
Acc (Subrel r fun x => r x b) a → Acc r ↑a | null | true |
Finset.ruzsa_triangle_inequality_addNeg_addNeg_addNeg | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] (A B C : Finset G),
(A + -C).card * B.card ≤ (A + -B).card * (C + -B).card | **Ruzsa's triangle inequality**. Addneg-addneg-addneg version. | true |
UpperSet.upper' | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} [inst : LE α] (self : UpperSet α), IsUpperSet self.carrier | The carrier of an `UpperSet` is an upper set. | true |
Frm.instCategory._proof_2 | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} (f : X.Hom Y), { hom' := { hom' := FrameHom.id ↑Y }.hom'.comp f.hom' } = f | null | false |
Lean.Meta.Grind.Arith.CommRing.EqCnstr.recOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive_1 : Lean.Meta.Grind.Arith.CommRing.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
((p : Lean.Grind.CommRing.Poly) →
(h : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof) →
(sugar id : ℕ) → motiv... | null | false |
ContinuousAt.integral_sub_linear_isLittleO_ae | Mathlib.MeasureTheory.Integral.Bochner.FundThmCalculus | ∀ {X : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [CompleteSpace E] [inst_4 : TopologicalSpace X] [OpensMeasurableSpace X]
{μ : MeasureTheory.Measure X} [MeasureTheory.IsLocallyFiniteMeasure μ] {x : X} {f : X → E},
ContinuousAt f x... | Fundamental theorem of calculus for set integrals, `nhds` version: if `μ` is a locally finite
measure and `f` is an almost everywhere measurable function that is continuous at a point `a`, then
`∫ x in s i, f x ∂μ = μ (s i) • f a + o(μ (s i))` at `li` provided that `s` tends to
`(𝓝 a).smallSets` along `li`. Since `μ (... | true |
AlgebraicGeometry.IsProper.toIsSeparated | Mathlib.AlgebraicGeometry.Morphisms.Proper | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [self : AlgebraicGeometry.IsProper f], AlgebraicGeometry.IsSeparated f | null | true |
CategoryTheory.IsUniversalColimit.nonempty_isColimit_prod_of_pullbackCone._auto_3 | Mathlib.CategoryTheory.Limits.VanKampen | Lean.Syntax | null | false |
CategoryTheory.shrinkCoyonedaEquiv | Mathlib.CategoryTheory.ShrinkYoneda | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] →
{X : Cᵒᵖ} →
{P : CategoryTheory.Functor C (Type w)} →
(CategoryTheory.shrinkCoyoneda.{w, v, u}.obj X ⟶ P) ≃ P.obj (Opposite.unop X) | The type of natural transformations `shrinkCoyoneda.{w}.obj X ⟶ P`
with `X : Cᵒᵖ` and `P : C ⥤ Type w` is equivalent to `P.obj (op X)`. | true |
BoxIntegral.Prepartition.recOn | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} →
{I : BoxIntegral.Box ι} →
{motive : BoxIntegral.Prepartition I → Sort u} →
(t : BoxIntegral.Prepartition I) →
((boxes : Finset (BoxIntegral.Box ι)) →
(le_of_mem' : ∀ J ∈ boxes, J ≤ I) →
(pairwiseDisjoint : (↑boxes).Pairwise (Function.onFun Disjoint BoxInteg... | null | false |
_private.Mathlib.Analysis.Convex.Segment.0.segment_symm.match_1_1 | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_2) {E : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y x_1 : E) (motive : x_1 ∈ segment 𝕜 x y → Prop) (x_2 : x_1 ∈ segment 𝕜 x y),
(∀ (a b : 𝕜) (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a + b = 1) (H : a • x + b • y = x_1), motive ⋯) → motive ... | null | false |
NumberField.Units.instNeZeroNatTorsionOrder | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], NeZero (NumberField.Units.torsionOrder K) | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Skeleton.0.SSet.mem_skeleton_obj_iff_of_nonDegenerate._simp_1_4 | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache.IsExtensionBy_trans_left | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf1 cnf2 cnf3 : Std.Sat.CNF ℕ} {new1 : ℕ} {hnew1 : new1 < aig.decls.size} {new2 : ℕ}
{hnew2 : new2 < aig.decls.size} (cache1 : Std.Sat.AIG.toCNF.Cache✝ aig cnf1)
(cache2 : Std.Sat.AIG.toCNF.Cache✝ aig cnf2) (cache3 : Std.Sat.AIG.toCNF.Cache✝ aig cnf3),
Std.Sat.AIG.toCNF.Cache.IsExtension... | null | true |
CategoryTheory.PreOneHypercover.equivalenceMulticospanOfIso_inverse | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (f : E ≅ F),
(CategoryTheory.PreOneHypercover.equivalenceMulticospanOfIso f).inverse =
CategoryTheory.PreOneHypercover.Hom.mapMulticospan f.inv | null | true |
OrderMonoidIso.toOrderIso_eq_coe | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β]
(f : α ≃*o β), f.toOrderIso = ↑f | null | true |
Function.support_inv | Mathlib.Algebra.GroupWithZero.Indicator | ∀ {ι : Type u_1} {G₀ : Type u_3} [inst : GroupWithZero G₀] (f : ι → G₀),
(Function.support fun a => (f a)⁻¹) = Function.support f | null | true |
RingCat.fullyFaithfulForget₂ToSemiRingCat | Mathlib.Algebra.Category.Ring.Basic | (CategoryTheory.forget₂ RingCat SemiRingCat).FullyFaithful | The forgetful functor from `RingCat` to `SemiRingCat` is fully faithful. | true |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.pseudoMetricAux._simp_3 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι}
[AddLeftMono N], (∀ i ∈ s, 0 ≤ f i) → (0 ≤ ∑ i ∈ s, f i) = True | null | false |
LinearPMap.mem_graph_snd_inj' | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_4} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_5}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] (f : E →ₗ.[R] F) {x y : E × F},
x ∈ f.graph → y ∈ f.graph → x.1 = y.1 → x.2 = y.2 | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Clz.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastClz.go_denote_eq._proof_1_8 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Clz | ∀ {w : ℕ} (idx idx curr : ℕ), curr + 1 < 2 ^ (curr + 1) → 2 ^ (curr + 1) < 2 ^ w → ¬curr + 1 < 2 ^ w → False | null | false |
Int.testBit_land | Mathlib.Data.Int.Bitwise | ∀ (m n : ℤ) (k : ℕ), (m.land n).testBit k = (m.testBit k && n.testBit k) | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Action.End.0.CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionOfMonoidalFunctorToEndofunctorMop._simp_12 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᴹᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp f.unmop g.unmop = (CategoryTheory.CategoryStruct.comp f g).unmop | null | false |
Lean.Compiler.LCNF.ExtractClosed.State.rec | Lean.Compiler.LCNF.ExtractClosed | {motive : Lean.Compiler.LCNF.ExtractClosed.State → Sort u} →
((decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
(fvarDecisionCache : Std.HashMap Lean.FVarId Bool) →
motive { decls := decls, fvarDecisionCache := fvarDecisionCache }) →
(t : Lean.Compiler.LCNF.ExtractClosed.Sta... | null | false |
MeasureTheory.JordanDecomposition.smul_posPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α) (r : NNReal),
(r • j).posPart = r • j.posPart | null | true |
_private.Init.Data.Nat.ToString.0.Nat.toDigitsCore_toDigitsCore | Init.Data.Nat.ToString | ∀ {b n d fuel nf df : ℕ} {cs : List Char},
1 < b →
0 < n →
d < b →
b * n + d < fuel →
n < nf → d < df → b.toDigitsCore nf n (b.toDigitsCore df d cs) = b.toDigitsCore fuel (b * n + d) cs | null | true |
List.dropSlice.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : ℕ → ℕ → List α → Sort u_2) →
(x x_1 : ℕ) →
(x_2 : List α) →
((x x_3 : ℕ) → motive x x_3 []) →
((m : ℕ) → (xs : List α) → motive 0 m xs) →
((n m : ℕ) → (x : α) → (xs : List α) → motive n.succ m (x :: xs)) → motive x x_1 x_2 | null | false |
Option.instMax | Init.Data.Option.Basic | {α : Type u_1} → [Max α] → Max (Option α) | null | true |
QuadraticMap.restrict._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_2} {M : Type u_1} {N : Type u_3} [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) (V : Submodule R M) (a : R) (v : ↥V),
Q.toFun (a • ↑v) = (a * a) • Q.toFun ↑v | null | false |
Std.HashMap.Raw.getKey?_union_of_not_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ ∪ m₂).getKey? k = m₁.getKey? k | null | true |
BesselPotentialSpace.instNormedAddCommGroup._proof_1 | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | ∀ {E : Type u_2} {F : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : FiniteDimensional ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
[inst_6 : CompleteSpace F] [inst_7 : NormedSpace ℂ F] {s : ℝ} {p : ENNReal} [hp : Fact (1 ≤ p)],
Func... | null | false |
CommRingCat.equalizer_ι_isLocalHom' | Mathlib.Algebra.Category.Ring.Constructions | ∀ (F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPairᵒᵖ CommRingCat),
IsLocalHom
(CommRingCat.Hom.hom (CategoryTheory.Limits.limit.π F (Opposite.op CategoryTheory.Limits.WalkingParallelPair.one))) | null | true |
Homotopy.mkInductiveAux₁._proof_2 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (one : P.X 1 ⟶ Q.X 2)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero + CategoryTheory.CategoryStruct.comp one (Q.d 2 1))
(su... | null | false |
neg_strictConvexOn_iff | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
{s : Set E} {f : E → β}, StrictConvexOn 𝕜 s (-f) ↔ StrictConcaveOn 𝕜 s f | A function `-f` is strictly convex iff `f` is strictly concave. | true |
_private.Mathlib.Data.EReal.Basic.0.EReal.coe_toReal_le._simp_1_2 | Mathlib.Data.EReal.Basic | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
MeasureTheory.MemLp.locallyIntegrable | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ : MeasureTheory.Measure X} [MeasureTheory.IsLocallyFiniteMeasure μ]
{p : ENNReal}, MeasureTheory.MemLp f p μ → 1 ≤ p → MeasureTheory.LocallyIntegrable f ... | null | true |
Mathlib.Tactic.SetM.setM | Mathlib.Tactic.Setm | Lean.ParserDescr | `setm patt` matches `patt`, a term containing named holes (like `?a`) to the goal, and creates
named local declarations for the matched holes with their assigned expressions as values. Moreover,
it will replace the matches with their new names. This tactic can be used to give a name to a
complicated subexpression appea... | true |
Std.ExtDHashMap.get_map | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} {γ : α → Type w}
[inst : LawfulBEq α] {f : (a : α) → β a → γ a} {k : α} {h' : k ∈ Std.ExtDHashMap.map f m},
(Std.ExtDHashMap.map f m).get k h' = f k (m.get k ⋯) | null | true |
_private.Mathlib.Data.List.Sort.0.List.«_aux_Mathlib_Data_List_Sort___macroRules__private_Mathlib_Data_List_Sort_0_List_term_≼__1_1» | Mathlib.Data.List.Sort | Lean.Macro | null | false |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.add_right_eq_self | Std.Tactic.BVDecide.Normalize.Equal | ∀ {w : ℕ} (a b : BitVec w), (a + b == a) = (b == 0#w) | null | true |
TopologicalSpace.Compacts.isPreconnected_Ioc | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {K L : TopologicalSpace.Compacts α},
IsPreconnected ↑L → IsPreconnected (Set.Ioc K L) | null | true |
Function.HasUncurry.noConfusionType | Mathlib.Logic.Function.Basic | Sort u →
{α : Type u_5} →
{β : Type u_6} →
{γ : Type u_7} →
Function.HasUncurry α β γ →
{α' : Type u_5} → {β' : Type u_6} → {γ' : Type u_7} → Function.HasUncurry α' β' γ' → Sort u | null | false |
Int.add_neg_mul_fmod_self_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b c : ℤ), (a + -(b * c)).fmod b = a.fmod b | null | true |
Lean.IR.Arg.var.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Arg → Sort u} →
(t : Lean.IR.Arg) → t.ctorIdx = 0 → ((id : Lean.IR.VarId) → motive (Lean.IR.Arg.var id)) → motive t | null | false |
_private.Mathlib.Algebra.Category.ModuleCat.Biproducts.0.lequivProdOfRightSplitExact'._proof_6 | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u_2} {A M B : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup A] [inst_2 : Module R A]
[inst_3 : AddCommGroup B] [inst_4 : Module R B] [inst_5 : AddCommGroup M] [inst_6 : Module R M] {j : A →ₗ[R] M}
{g : M →ₗ[R] B} (exac : j.range = g.ker),
(CategoryTheory.ShortComplex.moduleCatMkOfKerLERange (Module... | null | false |
ENNReal.inv_mul_ne_top | Mathlib.Basic.ENNReal.Inv | ∀ (a : ENNReal), a⁻¹ * a ≠ ⊤ | null | true |
_private.Std.Sync.Semaphore.0.Std.mkResolvedPromise | Std.Sync.Semaphore | {α : Type} → [Nonempty α] → α → BaseIO (IO.Promise α) | Creates a resolved promise.
| true |
_private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_collision._simp_1_7 | Mathlib.NumberTheory.Rayleigh | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [RightDistribClass R] (a b c : R), a * c + b * c = (a + b) * c | null | false |
UniformOnFun.instPseudoMetricSpaceOfBoundedSpace._proof_1 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : Finite ↑𝔖] [inst_1 : PseudoMetricSpace β] [BoundedSpace β]
(f g : UniformOnFun α β 𝔖),
edist f g = ENNReal.ofReal (⨆ x, dist ((UniformOnFun.toFun 𝔖) f ↑x) ((UniformOnFun.toFun 𝔖) g ↑x)) | null | false |
Subring.instCovariantClassHSMulLe | Mathlib.Algebra.Ring.Subring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R],
CovariantClass M (Subring R) HSMul.hSMul LE.le | null | true |
TopCat.Presheaf.SheafConditionPairwiseIntersections.isLimitMapConeOfIsLimitSheafConditionFork._proof_2 | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasProducts C]
{X : TopCat} (F : TopCat.Presheaf C X) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑X)
(j : (CategoryTheory.Pairwise ι)ᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id (C... | null | false |
Lean.Meta.Sym.AlphaShareCommon.State | Lean.Meta.Sym.AlphaShareCommon | Type | null | true |
MeasureTheory.IsLocallyFiniteMeasure.casesOn | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} →
{m0 : MeasurableSpace α} →
[inst : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : MeasureTheory.IsLocallyFiniteMeasure μ → Sort u} →
(t : MeasureTheory.IsLocallyFiniteMeasure μ) →
((finiteAtNhds : ∀ (x : α), μ.FiniteAtFilter (nhds x)) → motive ... | null | false |
lift_rank_add_lift_rank_le_rank_prod | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ (R : Type u) (M : Type v) (M' : Type v') [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M']
[inst_3 : Module R M] [inst_4 : Module R M'] [Nontrivial R],
Cardinal.lift.{v', v} (Module.rank R M) + Cardinal.lift.{v, v'} (Module.rank R M') ≤ Module.rank R (M × M') | null | true |
CategoryTheory.Limits.coprod.map_desc_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {V W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryCoproduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct Y Z]
(f : W ⟶ V) (g : X ⟶ V) (h : Y ⟶ W) (k : Z ⟶ X) {Z_1 : C} (h_1 : V ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Lim... | null | true |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.collectHeaders.match_1 | Lean.Elab.PreDefinition.WF.GuessLex | {α : Type} →
(motive : α × ℕ × String → Sort u_1) →
(x : α × ℕ × String) → ((x : α) → (fst : ℕ) → (footer : String) → motive (x, fst, footer)) → motive x | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.OfKernel.instRKHS._proof_2 | 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] [inst_3 : CompleteSpace V] {K : Matrix X X (V →L[𝕜] V)} [inst_4 : Fact K.PosSemidef],
ContinuousConstSMul 𝕜 (UniformSpace.Completion (RKHS.H₀ K)) | null | false |
Std.Internal.List.getValue?_filter_containsKey_of_containsKey_eq_false_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = false →
Std.Internal.List.getValue? k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) = none | null | true |
Option.elim | Init.Data.Option.Basic | {α : Type u_1} → {β : Sort u_2} → Option α → β → (α → β) → β | A case analysis function for `Option`.
Given a value for `none` and a function to apply to the contents of `some`, `Option.elim` checks
which constructor a given `Option` consists of, and uses the appropriate argument.
`Option.elim` is an elimination principle for `Option`. In particular, it is a non-dependent versio... | true |
CategoryTheory.Functor.CoreMonoidal.μIso_hom_natural_left._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | null | false |
SSet.Augmented.stdSimplex._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ (X : SimplexCategory),
{ left := SSet.stdSimplex.map (CategoryTheory.CategoryStruct.id X),
right :=
CategoryTheory.Limits.terminal.from
{ left := SSet.stdSimplex.obj X, right := ⊤_ Type u_1,
hom :=
{
app := fun x =>
Category... | null | false |
MeasureTheory.«term__[_|_]» | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | Lean.TrailingParserDescr | Conditional expectation of a function, with notation `μ[f | m]`.
It is defined as 0 if any one of the following conditions is true:
- `m` is not a sub-σ-algebra of `m₀`,
- `μ` is not σ-finite with respect to `m`,
- `f` is not integrable.
[Wikidata Q772232](https://www.wikidata.org/wiki/Q772232) | true |
Option.not_lt_pfilter | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α],
(∀ (x : α), ¬x < x) → ∀ {o : Option α} {p : (a : α) → o = some a → Bool}, ¬o < o.pfilter p | null | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.match_1 | Lean.Elab.Syntax | (motive : (Lean.Term × ℕ) × Option ℕ → Sort u_1) →
(x : (Lean.Term × ℕ) × Option ℕ) →
((newStx : Lean.Term) → (snd : ℕ) → (lhsPrec? : Option ℕ) → motive ((newStx, snd), lhsPrec?)) → motive x | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.degree_eq_zero._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(G.neighborSet v)], G.degree v = (G.neighborFinset v).card | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.flattenList.match_1.eq_2 | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (motive : List (BitVec n) → Sort u_1) (x : BitVec n) (rest : List (BitVec n)) (h_1 : Unit → motive [])
(h_2 : (x : BitVec n) → (rest : List (BitVec n)) → motive (x :: rest)),
(match x :: rest with
| [] => h_1 ()
| x :: rest => h_2 x rest) =
h_2 x rest | null | true |
_private.Mathlib.Analysis.Complex.ValueDistribution.Cartan.0.ValueDistribution.log_trailingCoeff_eq_zero_on_unitSphere | Mathlib.Analysis.Complex.ValueDistribution.Cartan | ∀ {f : ℂ → ℂ} {a : ℂ},
0 < meromorphicOrderAt f 0 → a ∈ Metric.sphere 0 |1| → Real.log ‖meromorphicTrailingCoeffAt (fun x => f x - a) 0‖ = 0 | null | true |
ZeroAtInftyContinuousMap.instSMulCommClass' | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β] {R : Type u_2}
{S : Type u_3} [inst_3 : Zero R] [inst_4 : Zero S] [inst_5 : SMulWithZero R β] [inst_6 : SMulWithZero S β]
[inst_7 : ContinuousConstSMul R β] [inst_8 : ContinuousConstSMul S β] [SMulCommClass R S β... | null | true |
Language.mem_one._simp_1 | Mathlib.Computability.Language | ∀ {α : Type u_1} (x : List α), (x ∈ 1) = (x = []) | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt16.reduceBNe.declare_145._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.3273093604._hygCtx.9.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.3273093604._hygCtx._hyg.326 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
LeftInvariantDerivation.instCoeDerivationContMDiffMapModelWithCornersSelfSomeENatTop._proof_2 | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], ContMDiffAdd (modelWithCornersSelf 𝕜 𝕜) (↑⊤) 𝕜 | null | false |
Std.DTreeMap.Internal.Impl.contains | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → [Ord α] → α → Std.DTreeMap.Internal.Impl α β → Bool | Returns `true` if the given key is contained in the map. | true |
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {Z : CategoryTheory.ObjectProperty.FullSubcategory fun a => a.len ≤ 2}
(h : { obj := { len := 1 }, property := SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1 } ⟶ Z),
CategoryTheory.CategoryStruct.comp
(SimplexCategory.Truncated.δ₂ 0 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1
Simp... | null | true |
Lean.Order.SeqLeft.monotone_seqLeft | Init.Internal.Order.Lemmas | ∀ {m : Type u → Type v} [inst : Monad m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m]
{α β : Type u} {γ : Type w} [inst_3 : Lean.Order.PartialOrder γ] [LawfulMonad m] (f : γ → m α) (g : γ → m β),
Lean.Order.monotone g → Lean.Order.monotone f → Lean.Order.monotone fun x => g x <* f... | null | true |
AddSemigroupAction | Mathlib.Algebra.Group.Action.Defs | (G : Type u_9) → Type u_10 → [AddSemigroup G] → Type (max u_10 u_9) | Type class for actions by additive semigroups, with notation `g +ᵥ p`.
The `AddSemigroupAction G P` typeclass says that the additive semigroup `G` acts additively on a
type `P`. More precisely this means that the action satisfies the axiom
`(g₁ + g₂) +ᵥ p = g₁ +ᵥ (g₂ +ᵥ p)`. A mathematician might simply say that the... | true |
CategoryTheory.Functor.mapAddGrpFunctor._proof_2 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
{F G : C ⥤ₗ D} (α : F ⟶ G) (A : CategoryTheory.AddGrp C),
CategoryTheory.Categor... | null | false |
CartanMatrix.Realisation.eq_one_or_neg_one_of_eq_zsmul_sRoot | Mathlib.LinearAlgebra.Matrix.Cartan.Realisation | ∀ {n : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype n] [inst_1 : DecidableEq n]
[inst_2 : CommRing R] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N] [inst_6 : Module R N]
(rl : CartanMatrix.Realisation n R M N) [CharZero R] [IsDomain R] {p : M × N},
p ∈ rl.idx ... | null | true |
PrimitiveSpectrum.gc | Mathlib.Topology.Order.HullKernel | ∀ {α : Type u_1} [inst : CompleteLattice α] {T : Set α},
GaloisConnection (fun S => OrderDual.toDual (PrimitiveSpectrum.kernel S)) fun a =>
PrimitiveSpectrum.hull T (OrderDual.ofDual a) | The pair of maps `kernel` and `hull` form an antitone Galois connection between the
subsets of `T` and `α`. | true |
TopCat.instCommRingHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier._proof_11 | Mathlib.Topology.Sheaves.CommRingCat | ∀ (X : TopCat) (R : TopCommRingCat) (x : ℕ),
CategoryTheory.ConcreteCategory.hom ↑x = CategoryTheory.ConcreteCategory.hom ↑x | null | false |
SeparationQuotient.instNonUnitalnonAssocSemiring | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalNonAssocSemiring R] →
[IsTopologicalSemiring R] → NonUnitalNonAssocSemiring (SeparationQuotient R) | null | true |
Std.Http.Protocol.H1.Error.timeout.elim | Std.Http.Protocol.H1.Error | {motive : Std.Http.Protocol.H1.Error → Sort u} →
(t : Std.Http.Protocol.H1.Error) → t.ctorIdx = 2 → motive Std.Http.Protocol.H1.Error.timeout → motive t | null | false |
ONote.mul.eq_def | Mathlib.SetTheory.Ordinal.Notation | ∀ (x x_1 : ONote),
x.mul x_1 =
match x, x_1 with
| ONote.zero, x => 0
| x, ONote.zero => 0
| o₁@h:(e₁.oadd n₁ a₁), e₂.oadd n₂ a₂ => if e₂ = 0 then e₁.oadd (n₁ * n₂) a₁ else (e₁ + e₂).oadd n₂ (o₁.mul a₂) | null | true |
AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.match_3 | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {N : Type u_1} [inst : AddCommMonoid N] {P : Type u_2} [inst_1 : AddCommMonoid P] (k : N ≃+ P) (v : P)
(motive : (∃ a, k a = v) → Prop) (x : ∃ a, k a = v), (∀ (z : N) (hz : k z = v), motive ⋯) → motive x | null | false |
AddSubgroup.closure_le_centralizer_centralizer | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_1} [inst : AddGroup G] (s : Set G),
AddSubgroup.closure s ≤ AddSubgroup.centralizer ↑(AddSubgroup.centralizer s) | null | true |
Batteries.AssocList.mapKey.eq_2 | Batteries.Data.AssocList.Basic | ∀ {α : Type u_1} {δ : Type u_2} {β : Type u_3} (f : α → δ) (a : α) (b : β) (es : Batteries.AssocList α β),
Batteries.AssocList.mapKey f (Batteries.AssocList.cons a b es) =
Batteries.AssocList.cons (f a) b (Batteries.AssocList.mapKey f es) | null | true |
Aesop.AddRapp.mk.injEq | Aesop.Tree.AddRapp | ∀ (toRuleApplication : Aesop.RuleApplication) (parent : Aesop.GoalRef) (appliedRule : Aesop.RegularRule)
(successProbability : Aesop.Percent) (toRuleApplication_1 : Aesop.RuleApplication) (parent_1 : Aesop.GoalRef)
(appliedRule_1 : Aesop.RegularRule) (successProbability_1 : Aesop.Percent),
({ toRuleApplication :=... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.