name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
linearIndependent_iUnion_finite | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {η : Type u_6}
{ιs : η → Type u_7} {f : (j : η) → ιs j → M},
(∀ (j : η), LinearIndependent R (f j)) →
(∀ (i : η) (t : Set η),
t.Finite →
i ∉ t → Disjoint (Submodule.span R (Set.range (f i))) (⨆ i ∈ ... | null | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.collectDirectVarsInPattern.go | Lean.Meta.IndPredBelow | Lean.Meta.Match.Pattern → Array Lean.FVarId → Array Lean.FVarId | null | true |
tsub_tsub_cancel_of_le | Mathlib.Algebra.Order.Sub.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [ExistsAddOfLE α] [AddLeftMono α]
[inst_4 : Sub α] [OrderedSub α] {a b : α} [AddLeftReflectLE α], a ≤ b → b - (b - a) = a | See `tsub_tsub_le` for an inequality. | true |
CommCStarAlgebra.casesOn | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
{motive : CommCStarAlgebra A → Sort u} →
(t : CommCStarAlgebra A) →
([toNormedCommRing : NormedCommRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedAlgebra : NormedAlgebra ℂ... | null | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory.0.MeasureTheory.SimpleFunc.exists_le_lowerSemicontinuous_lintegral_ge._simp_1_7 | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
HahnSeries.truncLT._proof_2 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_2} [inst : Zero R] [inst_1 : PartialOrder Γ] [inst_2 : DecidableLT Γ] (c : Γ),
{ coeff := fun i => if i < c then HahnSeries.coeff 0 i else 0, isPWO_support' := ⋯ } = 0 | null | false |
CategoryTheory.MorphismProperty.Comma.forget_obj | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) (P : CategoryTheory.MorphismProperty T)
(Q : CategoryTheory... | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.nthRoots_one_eq_biUnion_primitiveRoots' | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : DecidableEq R] {n : ℕ} [NeZero n],
Polynomial.nthRootsFinset n 1 = n.divisors.biUnion fun i => primitiveRoots i R | `nthRoots n` as a `Finset` is equal to the union of `primitiveRoots i R` for `i ∣ n`. | true |
deck._proof_2 | Mathlib.Topology.Covering.Deck | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] (p : E → X) {f : E ≃ₜ E},
f ∈ {h | p ∘ ⇑h = p} → f⁻¹ ∈ {h | p ∘ ⇑h = p} | null | false |
Convex.sdiff_singleton_eventually_mem_nhds | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_3} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [inst_3 : TopologicalSpace 𝕜]
[OrderTopology 𝕜] {s : Set 𝕜}, Convex 𝕜 s → ∀ (a : 𝕜), ∀ᶠ (x : 𝕜) in nhdsWithin a (s \ {a}), s \ {a} ∈ nhds x | null | true |
MeasurableEquiv.IicProdIoi | Mathlib.Probability.Kernel.IonescuTulcea.Maps | {ι : Type u_1} →
[inst : LinearOrder ι] →
[DecidableLE ι] →
{X : ι → Type u_2} →
[inst_2 : LocallyFiniteOrderBot ι] →
[inst_3 : (i : ι) → MeasurableSpace (X i)] →
(a : ι) → ((i : ↥(Finset.Iic a)) → X ↑i) × ((i : ↑(Set.Ioi a)) → X ↑i) ≃ᵐ ((n : ι) → X n) | Gluing `Iic a` and `Ioi a` into `ℕ`, version as a measurable equivalence
on dependent functions. | true |
Aesop.NormSimpRule.name | Aesop.Rule | Aesop.NormSimpRule → Aesop.RuleName | null | true |
_private.Mathlib.Tactic.DepRewrite.0.Lean.MVarId.depRewrite.match_1 | Mathlib.Tactic.DepRewrite | (motive : Array Lean.Expr → Sort u_1) →
(xs : Array Lean.Expr) → ((x h : Lean.Expr) → motive #[x, h]) → ((x : Array Lean.Expr) → motive x) → motive xs | null | false |
Lean.FileMap.getLastLine | Lean.Data.Position | Lean.FileMap → ℕ | The last line should always be `positions.size - 1`. | true |
Int.bit_val | Mathlib.Data.Int.Bitwise | ∀ (b : Bool) (n : ℤ), Int.bit b n = 2 * n + bif b then 1 else 0 | null | true |
forall_and_index | Mathlib.Basic.Logic.Basic | ∀ {p q : Prop} {r : p ∧ q → Prop}, (∀ (h : p ∧ q), r h) ↔ ∀ (hp : p) (hq : q), r ⋯ | null | true |
Vector.attach_append | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n m : ℕ} {xs : Vector α n} {ys : Vector α m},
(xs ++ ys).attach =
Vector.map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨x, ⋯⟩)
xs.attach ++
Vector.map
(fun x =>
match x with
| ⟨y, h⟩ => ⟨y, ⋯⟩)
ys.attach | null | true |
Std.HashMap.Raw.getD_of_isEmpty | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a : α} {fallback : β}, m.isEmpty = true → m.getD a fallback = fallback | null | true |
_private.Mathlib.RingTheory.ZMod.UnitsCyclic.0.ZMod.isCyclic_units_iff._simp_1_2 | Mathlib.RingTheory.ZMod.UnitsCyclic | IsCyclic (ZMod 1)ˣ = True | null | false |
SimpleGraph.Walk.IsPath.concat | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v},
p.IsPath → w ∉ p.support → ∀ (h : G.Adj v w), (p.concat h).IsPath | null | true |
StandardSubspace.recOn | Mathlib.Analysis.InnerProductSpace.StandardSubspace | {H : Type u_1} →
[inst : NormedAddCommGroup H] →
[inst_1 : InnerProductSpace ℂ H] →
{motive : StandardSubspace H → Sort u} →
(t : StandardSubspace H) →
((toClosedSubmodule : ClosedSubmodule ℝ H) →
(IsSeparating : toClosedSubmodule ⊓ toClosedSubmodule.mulI = ⊥) →
... | null | false |
ContinuousLinearMap.IsFredholm.fredholmPackage._proof_4 | Mathlib.Analysis.Normed.Operator.Fredholm.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
CategoryTheory.Limits.coconeOfDiagramTerminal_pt | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{X : J} (tX : CategoryTheory.Limits.IsTerminal X) (F : CategoryTheory.Functor J C),
(CategoryTheory.Limits.coconeOfDiagramTerminal tX F).pt = F.obj X | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Formula___delab_app__private_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Formula_0_termZ_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
RCLike.re_add_im_ax | Mathlib.Analysis.RCLike.Basic | ∀ {K : semiOutParam (Type u_1)} [self : RCLike K] (z : K),
(algebraMap ℝ K) (RCLike.re z) + (algebraMap ℝ K) (RCLike.im z) * RCLike.I = z | null | true |
ClosedSubmodule.coe_bot | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : Module R M] [inst_4 : T1Space M], ↑⊥ = {0} | null | true |
Std.Tactic.BVDecide.BoolExpr.Sat.eq_1 | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | ∀ {α : Type} (a : α → Bool) (x : Std.Tactic.BVDecide.BoolExpr α),
Std.Tactic.BVDecide.BoolExpr.Sat a x = (Std.Tactic.BVDecide.BoolExpr.eval a x = true) | null | true |
StarRing.star_add | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} {inst : NonUnitalNonAssocSemiring R} [self : StarRing R] (r s : R), star (r + s) = star r + star s | `star` commutes with addition | true |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.getMatch.match_3 | Lean.Meta.Sym.Simp.DiscrTree | {α : Type} →
(motive : Option (Lean.Meta.DiscrTree.Trie α) → Sort u_1) →
(x : Option (Lean.Meta.DiscrTree.Trie α)) →
(Unit → motive none) → ((c : Lean.Meta.DiscrTree.Trie α) → motive (some c)) → motive x | null | false |
_private.Mathlib.Tactic.NormNum.IsSquare.0.Mathlib.Meta.NormNum.evalIsSquareRat._proof_2 | Mathlib.Tactic.NormNum.IsSquare | ∀ (sa : Q(AddMonoidWithOne ℚ))
(__defeqres : PLift («$sa» =Q Rat.instDivisionRing.toAddGroupWithOne.toAddMonoidWithOne)),
«$sa» =Q Rat.instDivisionRing.toAddGroupWithOne.toAddMonoidWithOne | null | false |
Mathlib.Tactic.Order.AtomicFact.isSup.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs res : ℕ),
sizeOf (Mathlib.Tactic.Order.AtomicFact.isSup lhs rhs res) = 1 + sizeOf lhs + sizeOf rhs + sizeOf res | null | true |
_private.Init.GrindInstances.Ring.UInt.0.UInt64.intCast_ofNat._simp_1_2 | Init.GrindInstances.Ring.UInt | ∀ (a : ℕ), (a ∣ a) = True | null | false |
_private.Lean.Compiler.LCNF.ToImpureType.0.Lean.Compiler.LCNF.setCtorLayout.checkCtorLayout | Lean.Compiler.LCNF.ToImpureType | Lean.Compiler.LCNF.CtorLayout → Lean.CoreM Unit | null | true |
Real.natCastle_toNNReal'._simp_1 | Mathlib.Basic.NNReal.Defs | ∀ {n : ℕ} {r : ℝ}, (↑n ≤ r.toNNReal) = (↑n ≤ r ∨ n = 0) | null | false |
CategoryTheory.IsPushout.inl_snd | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.BicartesianSq | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [inst_3 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
CategoryTheory.IsPushout CategoryTheory.Limits.biprod.inl 0 CategoryTheory.Limits.biprod... | The square
```
X --inl--> X ⊞ Y
| |
0 snd
| |
v v
0 ---0-----> Y
```
is a pushout square.
| true |
Lean.Lsp.InitializedParams.rec | Lean.Data.Lsp.InitShutdown | {motive : Lean.Lsp.InitializedParams → Sort u} →
motive Lean.Lsp.InitializedParams.mk → (t : Lean.Lsp.InitializedParams) → motive t | null | false |
Rat.le_iff_lt_or_eq | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, a ≤ b ↔ a < b ∨ a = b | null | true |
derivWithin_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv | ∀ {f : ℝ → ℝ} {x : ℝ} {s : Set ℝ},
DifferentiableWithinAt ℝ f s x →
UniqueDiffWithinAt ℝ s x → derivWithin (fun x => Real.arctan (f x)) s x = 1 / (1 + f x ^ 2) * derivWithin f s x | null | true |
WithLp.ofLp_sub | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) {V : Type u_4} [inst : AddCommGroup V] (x y : WithLp p V), (x - y).ofLp = x.ofLp - y.ofLp | null | true |
Mathlib.Meta.NormNum.NormNumExt.pre._default | Mathlib.Tactic.NormNum.Core | Bool | null | false |
DirectSum.instLieRingModuleSubtypeMemSubmodule | Mathlib.Algebra.Lie.Graded | {ι : Type u_1} →
{κ : Type u_2} →
{R : Type u_5} →
{L : Type u_6} →
{M : Type u_7} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid ι] →
[inst_2 : CommRing R] →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
... | null | true |
LinearMap.charpoly._proof_1 | Mathlib.LinearAlgebra.Charpoly.Basic | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
_private.Mathlib.Topology.DenseEmbedding.0.IsDenseInducing.continuousAt_extend._simp_1_1 | Mathlib.Topology.DenseEmbedding | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Array.map_eq_flatMap | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α}, Array.map f xs = Array.flatMap (fun x => #[f x]) xs | null | true |
RBTree.RBNode.isOrdered.eq_2 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} (cmp : α → α → Ordering) (l r : Option α),
(∀ (l_1 r_1 : α), l = some l_1 → r = some r_1 → False) → RBTree.RBNode.isOrdered cmp RBTree.RBNode.nil l r = true | null | true |
CategoryTheory.Limits.IsLimit.mkConeMorphism_lift | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F}
(lift : (s : CategoryTheory.Limits.Cone F) → s ⟶ t)
(uniq : ∀ (s : CategoryTheory.Limits.Cone F) (m : s ⟶ t), m = lift s) (s :... | null | true |
SkewMonoidAlgebra.distribMulActionHom_ext | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N]
[inst_3 : DistribMulAction R M] [inst_4 : DistribMulAction R N] {α : Type u_6} {f g : SkewMonoidAlgebra M α →+[R] N},
(∀ (a : α) (m : M), f (SkewMonoidAlgebra.single a m) = g (SkewMonoidAlgebra.s... | null | true |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_exists_annihilator._simp_1_1 | Mathlib.RingTheory.Support | ∀ {a b : Prop}, (¬a → ¬b) = (b → a) | null | false |
MeasureTheory.analyticSet_iff_exists_polishSpace_range | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α},
MeasureTheory.AnalyticSet s ↔ ∃ β h, ∃ (_ : PolishSpace β), ∃ f, Continuous f ∧ Set.range f = s | A set is analytic if and only if it is the continuous image of some Polish space. | true |
AddGroupFilterBasis.casesOn | Mathlib.Topology.Algebra.FilterBasis | {A : Type u} →
[inst : AddGroup A] →
{motive : AddGroupFilterBasis A → Sort u_1} →
(t : AddGroupFilterBasis A) →
((toFilterBasis : FilterBasis A) →
(zero' : ∀ {U : Set A}, U ∈ toFilterBasis.sets → 0 ∈ U) →
(add' : ∀ {U : Set A}, U ∈ toFilterBasis.sets → ∃ V ∈ toFilterBasis.... | null | false |
Std.Tactic.BVDecide.Normalize.BitVec.and_contra | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), a &&& ~~~a = 0#w | null | true |
ZeroAtInftyContinuousMap.unitizationAlgEquiv._proof_4 | Mathlib.Topology.ContinuousMap.ZeroAtInftyUnitization | ∀ (X : Type u_2) (R : Type u_1) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace R] [inst_2 : CommRing R]
[inst_3 : IsTopologicalRing R], SMulCommClass R (ZeroAtInftyContinuousMap X R) (ZeroAtInftyContinuousMap X R) | null | false |
Nat.Partrec.Code.instDenumerable._private_1 | Mathlib.Computability.PartrecCode | ∀ (n : ℕ), (Nat.Partrec.Code.ofNatCode n).encodeCode = n | null | false |
CategoryTheory.MonoidalCategory.ofBifunctor.Triangle.associatorMap_app | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
(tensor : CategoryTheory.Functor C (CategoryTheory.Functor C C)) (unit : C)
(associator : CategoryTheory.bifunctorComp₁₂ tensor tensor ≅ CategoryTheory.bifunctorComp₂₃ tensor tensor) (X : C),
(CategoryTheory.MonoidalCategory.ofBifunctor.Triangle.assoc... | null | true |
RBTree.RBNode.Path.AllL._unsafe_rec | Batteries.Recycling.RBTree.Lemmas | {α : Type u_1} → (α → Prop) → RBTree.RBNode.Path α → Prop | null | false |
MulEquiv.isUnit_map._simp_2 | Mathlib.Algebra.Group.Units.Equiv | ∀ {F : Type u_1} {M : Type u_3} {N : Type u_4} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : EquivLike F M N]
[MulEquivClass F M N] (f : F) {x : M}, IsUnit (f x) = IsUnit x | null | false |
CategoryTheory.Limits.Types.isImage | Mathlib.CategoryTheory.Limits.Types.Images | {α β : Type u} → (f : α ⟶ β) → CategoryTheory.Limits.IsImage (CategoryTheory.Limits.Types.monoFactorisation f) | the factorisation through a mono has the universal property of the image. | true |
CategoryTheory.monoidalCategoryOp._proof_15 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(W X Y Z : Cᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.MonoidalCategoryStruct.associator (Opposite.unop W) (Opposite.unop X)
... | null | false |
CompHausLike.LocallyConstantModule.functor_obj_obj_map_hom_apply_apply | Mathlib.Condensed.Discrete.Module | ∀ {P : TopCat → Prop} (R : Type (max u w)) [inst : Ring R] [inst_1 : CompHausLike.HasExplicitFiniteCoproducts P]
[inst_2 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f))
(X : M... | null | true |
RingHom.StableUnderCompositionWithLocalizationAway | Mathlib.RingTheory.LocalProperties.Basic | ({R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) → Prop | A property `P` of ring homs satisfies `RingHom.StableUnderCompositionWithLocalizationAway`
if whenever `P` holds for `f` it also holds for the composition with
localization maps on the left and on the right. | true |
MonoidAlgebra.cardinalMk_of_fintype | Mathlib.Algebra.MonoidAlgebra.Cardinal | ∀ (R M : Type u) [inst : Semiring R] [inst_1 : Fintype M],
Cardinal.mk (MonoidAlgebra R M) = Cardinal.mk R ^ Fintype.card M | null | true |
swap_dist | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α], Function.swap dist = dist | null | true |
CommAlgCat.FiniteEtale.baseChangeSelfIso._proof_1 | Mathlib.RingTheory.Etale.Finite | ∀ (R : Type u_1) [inst : CommRing R] {A B : CommAlgCat.FiniteEtale R} (f : A ⟶ B),
CategoryTheory.CategoryStruct.comp ((CommAlgCat.FiniteEtale.baseChange R R).map f)
(CommAlgCat.FiniteEtale.isoMk (Algebra.TensorProduct.lid R ↑B.obj)).hom =
CategoryTheory.CategoryStruct.comp (CommAlgCat.FiniteEtale.isoMk (Al... | null | false |
ProbabilityTheory.bayesRisk.eq_1 | Mathlib.Probability.Decision.Risk.Defs | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_3} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
[inst : MeasurableSpace 𝓨] (ℓ : Θ → 𝓨 → ENNReal) (P : ProbabilityTheory.Kernel Θ 𝓧) (π : MeasureTheory.Measure Θ),
ProbabilityTheory.bayesRisk ℓ P π = ⨅ κ, ⨅ (_ : ProbabilityTheory.IsMarkovKernel κ), ProbabilityT... | null | true |
Real.expPartialHomeomorph._proof_1 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ (x : ℝ), Real.log (Real.exp x) = x | null | false |
CategoryTheory.Mon.comp.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N O : CategoryTheory.Mon C} (f : M.Hom N) (g : N.Hom O),
CategoryTheory.Mon.comp f g = { hom := CategoryTheory.CategoryStruct.comp f.hom g.hom, isMonHom_hom := ⋯ } | null | true |
_private.Mathlib.LinearAlgebra.Dual.BaseChange.0.IsBaseChange.toDualBaseChangeAux_tmul | Mathlib.LinearAlgebra.Dual.BaseChange | ∀ {R : Type u_1} [inst : CommSemiring R] {V : Type u_2} [inst_1 : AddCommMonoid V] [inst_2 : Module R V] {W : Type u_3}
[inst_3 : AddCommMonoid W] [inst_4 : Module R W] {A : Type u_4} [inst_5 : CommSemiring A] [inst_6 : Algebra R A]
[inst_7 : Module A W] [inst_8 : IsScalarTower R A W] {j : V →ₗ[R] W} (ibc : IsBaseC... | null | true |
HasLineDerivAt.unique | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {f₀' f₁' : F}
{x v : E}, HasLineDerivAt 𝕜 f f₀' x v → HasLineDerivAt 𝕜 f f₁' x v → f₀' = f₁' | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.genWrapper.build._unary._proof_4 | Lean.Elab.DocString | ∀ (argSpec : Array Lean.Doc.ArgSpec✝) (i : ℕ) (args : Array Lean.Expr),
i < argSpec.size →
∀ (v : Lean.Expr),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i args => argSpec.size - i) ⟨i + 1, args.push v⟩
⟨i, args⟩ | null | false |
LinearIsometryEquiv.continuousOn | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_4} {E₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | null | true |
inv_mul_lt_iff_lt_mul._simp_2 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LT α] [MulLeftStrictMono α] {a b c : α}, (b⁻¹ * a < c) = (a < b * c) | null | false |
Std.DHashMap.Internal.Raw₀.Const.get!_insertMany_list_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited β],
(↑m).WF →
∀ {l : List (α × β)} {k k' : α},
(k == k') = true →
∀ {v : β},
List.Pairwise (fun a b => (a.1 == b.1) = false) ... | null | true |
Ideal.Factors.isScalarTower | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : IsDedekindDomain S] (P : ↥(UniqueFactorizationMonoid.factors (Ideal.map (algebraMap R S) p)).toFinset),
IsScalarTower R (R ⧸ p) (S ⧸ ↑P) | null | true |
CategoryTheory.CommComon.id_hom | Mathlib.CategoryTheory.Monoidal.CommComon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommComon C),
(CategoryTheory.CategoryStruct.id A).hom.hom = CategoryTheory.CategoryStruct.id A.X | null | true |
CategoryTheory.Abelian.SpectralObject.dHomologyIso._proof_16 | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ (n₃ n₄ : ℤ), autoParam (n₃ + 1 = n₄) CategoryTheory.Abelian.SpectralObject.dHomologyIso._auto_7 → n₃ + 1 = n₄ | null | false |
AddMonoidAlgebra.add_divOf | Mathlib.Algebra.MonoidAlgebra.Division | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCommMonoid G] [inst_2 : IsCancelAdd G]
(x y : AddMonoidAlgebra k G) (g : G), (x + y).divOf g = x.divOf g + y.divOf g | null | true |
Module.End.hasGenEigenvalue_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} {k : ℕ}, f.HasGenEigenvalue μ k ↔ (f.genEigenspace μ) ↑k ≠ ⊥ | null | true |
monotone_or | Mathlib.Order.BoundedOrder.Monotone | ∀ {α : Type u} [inst : Preorder α] {p q : α → Prop}, Monotone p → Monotone q → Monotone fun x => p x ∨ q x | null | true |
AddHom.codRestrict._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_3} {N : Type u_1} {σ : Type u_2} [inst : Add M] [inst_1 : Add N] [inst_2 : SetLike σ N] (f : M →ₙ+ N)
(S : σ), (∀ (x : M), f x ∈ S) → ∀ (x y : M), f (x + y) ∈ S | null | false |
BoundedContinuousFunction.toContinuousMapMonoidHom.eq_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ (α : Type u) (R : Type u_2) [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : Monoid R]
[inst_3 : BoundedMul R] [inst_4 : ContinuousMul R],
BoundedContinuousFunction.toContinuousMapMonoidHom α R =
{ toFun := BoundedContinuousFunction.toContinuousMap, map_one' := ⋯, map_mul' := ⋯ } | null | true |
GradedTensorProduct.includeLeftRingHom._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_3} {ι : Type u_4} {A : Type u_1} {B : Type u_2} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
Path.truncate._proof_4 | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {a b : X} (γ : Path a b) (t₀ t₁ : ℝ),
Continuous (⇑γ.extend ∘ fun s => min (max (↑s) t₀) t₁) | null | false |
List.destutter | Mathlib.Data.List.Defs | {α : Type u_1} → (R : α → α → Prop) → [DecidableRel R] → List α → List α | Greedily create a sublist of `l` such that, for every two adjacent elements `a, b ∈ l`,
`R a b` holds. Mostly used with ≠; for example, `destutter (≠) [1, 2, 2, 1, 1] = [1, 2, 1]`,
`destutter (≠) [1, 2, 3, 3] = [1, 2, 3]`, `destutter (<) [1, 2, 5, 2, 3, 4, 9] = [1, 2, 5, 9]`. | true |
SimpleGraph.Reachable.dist_triangle_left | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V}, G.Reachable u v → ∀ (w : V), G.dist u w ≤ G.dist u v + G.dist v w | null | true |
MeasureTheory.AEEqFun.compQuasiMeasurePreserving._proof_2 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_3} {β : Type u_1} {γ : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace γ] [inst_2 : MeasurableSpace β] {ν : MeasureTheory.Measure β} (f : α → β)
(hf : MeasureTheory.QuasiMeasurePreserving f μ ν) (x x_1 : { f // MeasureTheory.AEStronglyMeasurable f ν }),
... | null | false |
Module.Finite.quotient | Mathlib.RingTheory.Finiteness.Basic | ∀ (R : Type u_5) {A : Type u_6} {M : Type u_7} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Ring A]
[inst_3 : Module A M] [inst_4 : Module R M] [inst_5 : SMul R A] [inst_6 : IsScalarTower R A M] [Module.Finite R M]
(N : Submodule A M), Module.Finite R (M ⧸ N) | null | true |
Homeomorph.coe_inv | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ {G : Type u_4} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [inst_2 : ContinuousInv G],
⇑(Homeomorph.inv G) = Inv.inv | null | true |
WeierstrassCurve.integralModel_b₂_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra R K] (W : WeierstrassCurve K)
[hW : WeierstrassCurve.IsIntegral R W], (algebraMap R K) (WeierstrassCurve.integralModel R W).b₂ = W.b₂ | null | true |
Lean.Grind.CommRing.Mon.denote.eq_2 | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α) (p : Lean.Grind.CommRing.Power)
(m : Lean.Grind.CommRing.Mon),
Lean.Grind.CommRing.Mon.denote ctx (Lean.Grind.CommRing.Mon.mult p m) =
Lean.Grind.CommRing.Power.denote ctx p * Lean.Grind.CommRing.Mon.denote ctx m | null | true |
ProjectiveSpectrum.homogeneousIdeal_le_vanishingIdeal_zeroLocus | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (I : HomogeneousIdeal 𝒜),
I ≤ ProjectiveSpectrum.vanishingIdeal (ProjectiveSpectrum.zeroLocus 𝒜 ↑I) | null | true |
CategoryTheory.Bicategory.LanLift.CommuteWith.isKan.congr_simp | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : b ⟶ a) (g : c ⟶ a)
[inst_1 : CategoryTheory.Bicategory.HasLeftKanLift f g] {x : B} (h : x ⟶ c)
[inst_2 : CategoryTheory.Bicategory.LanLift.CommuteWith f g h],
CategoryTheory.Bicategory.LanLift.CommuteWith.isKan f g h = CategoryTheory.Bicategory.... | null | true |
_private.Mathlib.Data.Finset.Max.0.Finset.min'_lt_max'_of_card._proof_1 | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} (s : Finset α), 1 < s.card → 0 < s.card | null | false |
SimpleGraph.card_commonNeighbors_le_degree_left | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj] (v w : V),
Fintype.card ↑(G.commonNeighbors v w) ≤ G.degree v | null | true |
Cardinal | Mathlib.SetTheory.Cardinal.Defs | Type (u + 1) | `Cardinal.{u}` is the type of cardinal numbers in `Type u`,
defined as the quotient of `Type u` by existence of an equivalence
(a bijection with explicit inverse). | true |
UniformContinuousConstVAdd.mk | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : VAdd M X],
(∀ (c : M), UniformContinuous fun x => c +ᵥ x) → UniformContinuousConstVAdd M X | null | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.preprocessHypothesis._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Intro | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Meta.ArgsPacker.0.Lean.Meta.ArgsPacker.Mutual.mkCodomain.go._unsafe_rec | Lean.Meta.ArgsPacker | Array Lean.Expr → Lean.Level → Lean.Expr → ℕ → Lean.MetaM Lean.Expr | null | false |
List.suffix_cons_append._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {a : α} {l₁ l₂ : List α}, (l₂ <:+ a :: (l₁ ++ l₂)) = True | null | false |
Array.le_findIdx_of_not | Init.Data.Array.Find | ∀ {α : Type u_1} {p : α → Bool} {xs : Array α} {i : ℕ} (h : i < xs.size),
(∀ (j : ℕ) (hji : j < i), p xs[j] = false) → i ≤ Array.findIdx p xs | If `¬ p xs[j]` for all `j < i`, then `i ≤ xs.findIdx p`. | true |
Topology.scottHausdorff._proof_7 | Mathlib.Topology.Order.ScottTopology | ∀ (α : Type u_1) (D : Set (Set α)) [inst : Preorder α] (s t : Set α),
(∀ ⦃d : Set α⦄,
d ∈ D →
d.Nonempty → DirectedOn (fun x1 x2 => x1 ≤ x2) d → ∀ ⦃a : α⦄, IsLUB d a → a ∈ s → ∃ b ∈ d, Set.Ici b ∩ d ⊆ s) →
(∀ ⦃d : Set α⦄,
d ∈ D →
d.Nonempty →
DirectedOn (fun x1 x2 => x1... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.