name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Algebra.mem_sup_left | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {S T : Subalgebra R A}
{x : A}, x ∈ S → x ∈ S ⊔ T | null | true |
Bundle.ContMDiffRiemannianMetric.toContinuousRiemannianMetric | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | {EB : Type u_1} →
[inst : NormedAddCommGroup EB] →
[inst_1 : NormedSpace ℝ EB] →
{HB : Type u_2} →
[inst_2 : TopologicalSpace HB] →
{IB : ModelWithCorners ℝ EB HB} →
{n : WithTop ℕ∞} →
{B : Type u_3} →
[inst_3 : TopologicalSpace B] →
... | A smooth Riemannian metric defines in particular a continuous Riemannian metric. | true |
Aesop.Match.mk.sizeOf_spec | Aesop.Forward.Match.Types | ∀ (subst : Aesop.Substitution) (patInstSubsts : Array Aesop.Substitution) (level : Aesop.SlotIndex)
(forwardDeps conclusionDeps : Array Aesop.PremiseIndex),
sizeOf
{ subst := subst, patInstSubsts := patInstSubsts, level := level, forwardDeps := forwardDeps,
conclusionDeps := conclusionDeps } =
1 +... | null | true |
MeromorphicAt.meromorphicTrailingCoeffAt_fun_zpow | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {n : ℤ} {f : 𝕜 → 𝕜},
MeromorphicAt f x → meromorphicTrailingCoeffAt (fun z => f z ^ n) x = meromorphicTrailingCoeffAt f x ^ n | The trailing coefficient of the power of a function is the power of the trailing coefficient.
| true |
Std.Tactic.BVDecide.instDecidableEqBVBinOp._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (x y : Std.Tactic.BVDecide.BVBinOp), ¬x.ctorIdx = y.ctorIdx → x = y → False | null | false |
Rack.PreEnvelGroupRel'.act_incl.elim | Mathlib.Algebra.Quandle | {R : Type u} →
[inst : Rack R] →
{motive : (a a_1 : Rack.PreEnvelGroup R) → Rack.PreEnvelGroupRel' R a a_1 → Sort u_1} →
{a a_1 : Rack.PreEnvelGroup R} →
(t : Rack.PreEnvelGroupRel' R a a_1) →
t.ctorIdx = 9 →
((x y : R) →
motive
(((Rack.PreEnve... | null | false |
AddSubgroup.instIsAddFGSubtypeMemMap | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_1} {G' : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup G'] {H : AddSubgroup G} (f : G →+ G')
[IsAddFG ↥H], IsAddFG ↥(AddSubgroup.map f H) | null | true |
IsLocalization.AtPrime.mem_primesOver_of_isPrime | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ (Rₚ : Type u_3) [inst : CommRing Rₚ] [inst_1 : IsLocalRing Rₚ] (Sₚ : Type u_4) [inst_2 : CommRing Sₚ]
[inst_3 : Algebra Rₚ Sₚ] {Q : Ideal Sₚ} [Q.IsMaximal] [Algebra.IsIntegral Rₚ Sₚ],
Q ∈ (IsLocalRing.maximalIdeal Rₚ).primesOver Sₚ | The nonzero prime ideals of `Sₚ` are prime ideals over the maximal ideal of `Rₚ`.
See `Localization.AtPrime.primesOverEquivPrimesOver` for the bijection between the prime ideals
of `Sₚ` over the maximal ideal of `Rₚ` and the primes ideals of `S` above `p`.
| true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_diff_iff._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) | null | false |
CategoryTheory.Functor.descColimitType_comp_ι | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J (Type w₀)) (c : F.CoconeTypes)
(j : J), F.descColimitType c ∘ F.ιColimitType j = c.ι j | null | true |
Lean.Elab.Term.BodyInfo.casesOn | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.BodyInfo → Sort u} →
(t : Lean.Elab.Term.BodyInfo) → ((value? : Option Lean.Expr) → motive { value? := value? }) → motive t | null | false |
LinearMap.BilinForm.isSymm_toMatrix_iff_isSymm | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (b : Module.Basis n R₁ M₁)
{B : LinearMap.BilinForm R₁ M₁}, ((LinearMap.BilinForm.toMatrix b) B).IsSymm ↔ B.IsSymm | null | true |
Matrix.conjTransposeAddEquiv_symm | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ (m : Type u_2) (n : Type u_3) (α : Type v) [inst : AddMonoid α] [inst_1 : StarAddMonoid α],
(Matrix.conjTransposeAddEquiv m n α).symm = Matrix.conjTransposeAddEquiv n m α | null | true |
MeasureTheory.hasFiniteIntegral_iff_enorm | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {ε : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε] {f : α → ε},
MeasureTheory.HasFiniteIntegral f μ ↔ ∫⁻ (a : α), ‖f a‖ₑ ∂μ < ⊤ | null | true |
smul_sdiv_smul_cancel_right | Mathlib.Algebra.Torsor.Defs | ∀ {G : Type u_1} {P : Type u_2} [inst : Group G] [T : Torsor G P] (v₁ v₂ : G) (p : P), v₁ • p /ₛ v₂ • p = v₁ / v₂ | null | true |
_private.Aesop.RuleSet.Member.0.Aesop.LocalRuleSetMember.name.match_1 | Aesop.RuleSet.Member | (motive : Aesop.LocalRuleSetMember → Sort u_1) →
(x : Aesop.LocalRuleSetMember) →
((m : Aesop.GlobalRuleSetMember) → motive (Aesop.LocalRuleSetMember.global m)) →
((r : Aesop.LocalNormSimpRule) → motive (Aesop.LocalRuleSetMember.localNormSimpRule r)) → motive x | null | false |
Lean.Sym.UInt16.lt_eq_false | Init.Sym.Lemmas | ∀ (a b : UInt16), decide (a < b) = false → (a < b) = False | null | true |
_private.Mathlib.Analysis.Calculus.TaylorIntegral.0.map_add_eq_sum_add_integral_iteratedFDeriv._simp_1_3 | Mathlib.Analysis.Calculus.TaylorIntegral | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
IsLocalization.mapFrameHom._proof_1 | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_2} [inst : CommSemiring R] (S : Type u_1) [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
Ideal.map (algebraMap R S) ⊤ = ⊤ | null | false |
CategoryTheory.Abelian.SpectralObject.opcyclesMap_fromOpcycles | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) {i' j' k' : ι} (f' : i' ⟶ j')
(g' : j' ⟶ k') (fg : i ⟶ k) (h : Categ... | null | true |
AlgebraicGeometry.Scheme.isPullback_of_openCover | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z W : AlgebraicGeometry.Scheme} (fWX : W ⟶ X) (fWY : W ⟶ Y) (fXZ : X ⟶ Z) (fYZ : Y ⟶ Z) (𝒰 : X.OpenCover),
(∀ (i : 𝒰.toPreZeroHypercover.1),
CategoryTheory.IsPullback (AlgebraicGeometry.Scheme.Cover.pullbackHom 𝒰 fWX i)
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Precoverage.ZeroHyper... | null | true |
Polynomial.SplittingField.instCommRing._aux_3 | Mathlib.FieldTheory.SplittingField.Construction | {K : Type u_1} → [inst : Field K] → (f : Polynomial K) → f.SplittingField → f.SplittingField → f.SplittingField | null | false |
PSet.Lift.match_3 | Mathlib.SetTheory.ZFC.PSet | (motive : PSet.{u_1} → Sort u_2) →
(x : PSet.{u_1}) → ((α : Type u_1) → (A : α → PSet.{u_1}) → motive { «Type» := α, Func := A }) → motive x | null | false |
CategoryTheory.LocallyDiscrete.rec | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | {C : Type u} →
{motive : CategoryTheory.LocallyDiscrete C → Sort u_1} →
((as : C) → motive { as := as }) → (t : CategoryTheory.LocallyDiscrete C) → motive t | null | false |
_private.Batteries.Data.BinaryHeap.Basic.0.Batteries.BinaryHeap.toSortedArray.loop._unsafe_rec | Batteries.Data.BinaryHeap.Basic | {α : Type u_1} → [inst : Ord α] → Batteries.BinaryHeap α → Array α → Array α | null | false |
CategoryTheory.ExponentiableMorphism.mk._flat_ctor | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I J : C} →
{f : I ⟶ J} →
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] →
(pushforward : CategoryTheory.Functor (CategoryTheory.Over I) (CategoryTheory.Over J)) →
(CategoryTheory.ChosenPullbacksAlong.pullback f ⊣ pus... | null | false |
_private.Mathlib.Logic.Encodable.Basic.0.Encodable.chooseX.match_3 | Mathlib.Logic.Encodable.Basic | {α : Type u_1} →
{p : α → Prop} →
(motive : (o : Option α) → Encodable.good✝ p o → Sort u_2) →
(o : Option α) →
(a : Encodable.good✝ p o) → ((a : α) → (h : Encodable.good✝ p (some a)) → motive (some a) h) → motive o a | null | false |
Dense.extend_spec | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] {s : Set α} {f : ↑s → β}
[CompleteSpace β] (hs : Dense s),
UniformContinuous f → ∀ (a : α), Filter.Tendsto f (Filter.comap Subtype.val (nhds a)) (nhds (hs.extend f a)) | null | true |
MaxTropical.instDistribOfAddLeftMonoOfAddRightMono._proof_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : Add R] [AddLeftMono R] (x x_1 x_2 : MaxTropical R),
x * (x_1 + x_2) = x * x_1 + x * x_2 | null | false |
_private.Mathlib.Data.Int.Fib.Basic.0.Int.fib_two_mul_add_one_pos._proof_1_1 | Mathlib.Data.Int.Fib.Basic | ∀ {n : ℤ}, 0 < Int.fib (2 * n + 1) | null | false |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux._simp_1_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
(s.sup f ≤ a) = ∀ b ∈ s, f b ≤ a | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Pred.0.String.Pos.revSkipWhile_prop_eq_self_iff_get._simp_1_2 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {P : Char → Prop} [inst : DecidablePred P] {s : String.Slice} {pos : s.Pos},
(pos.revSkipWhile P = pos) = ∀ (h : pos ≠ s.startPos), ¬P ((pos.prev h).get ⋯) | null | false |
ProbabilityTheory.IsPreLocalizingSequence.recOn | Mathlib.Probability.Process.LocalProperty | {ι : Type u_1} →
{Ω : Type u_2} →
{mΩ : MeasurableSpace Ω} →
[inst : Preorder ι] →
[inst_1 : TopologicalSpace ι] →
[inst_2 : OrderTopology ι] →
{𝓕 : MeasureTheory.Filtration ι mΩ} →
{τ : ℕ → Ω → WithTop ι} →
{P : MeasureTheory.Measure Ω} →
... | null | false |
CategoryTheory.Presieve.shrinkFunctorHomEquiv._proof_2 | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X : C} {S : CategoryTheory.Sieve X}
[inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C] (X_1 : Cᵒᵖ)
(f : (CategoryTheory.Sieve.shrinkFunctor.{u_1, u_2, u_3} S).toFunctor.obj X_1),
↑f ∈ (CategoryTheory.Sieve.shrinkFunctor.{u_1, u_2, u_3} S).obj X... | null | false |
Homotopy.extendEquiv | Mathlib.Algebra.Homology.Embedding.ExtendHomotopy | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Preadditive C] →
{K L : ... | If `e : c.Embedding c'` is an embedding of complex shapes,
`f` and `g` are morphism between cochain complexes of shape `c`,
this is the bijection between homotopies between `f` and `g`,
and homotopies between the extensions `extendMap f e` and `extendMap g e`. | true |
Fin.modn_val | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (a : Fin n) (b : ℕ), ↑(a.modn b) = ↑a % b | null | true |
Equiv.Perm.IsCycleOn.inv | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {s : Set α}, f.IsCycleOn s → f⁻¹.IsCycleOn s | **Alias** of the reverse direction of `Equiv.Perm.isCycleOn_inv`. | true |
Std.DTreeMap.Internal.Impl.minKeyD._unary._proof_2 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2} (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β) (size_1 : ℕ)
(k_1 : α) (v_1 : β k_1) (l_1 r : Std.DTreeMap.Internal.Impl α β)
(h : l = Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) (r_1 : Std.DTreeMap.Internal.Impl α β) (fallback : α),
(invImage (fun ... | null | false |
AlgebraicGeometry.exists_eq_pow_mul_of_isAffineOpen._proof_2 | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ (X : AlgebraicGeometry.Scheme) (U : X.Opens) (f : ↑(X.presheaf.obj (Opposite.op U))), X.basicOpen f ≤ U | null | false |
Nat.mod_div_self | Init.Data.Nat.Lemmas | ∀ (m n : ℕ), m % n / n = 0 | null | true |
CategoryTheory.GrothendieckTopology.isClosed_iff_close_eq_self | Mathlib.CategoryTheory.Sites.Closed | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J₁ : CategoryTheory.GrothendieckTopology C) {X : C}
(S : CategoryTheory.Sieve X), J₁.IsClosed S ↔ J₁.close S = S | The sieve `S` is closed iff its closure is equal to itself. | true |
Lean.Linter.MissingDocs.hasTacticAlt | Lean.Linter.MissingDocs | Lean.Syntax → Bool | null | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary.eq_def | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap)
(_x :
(idx : Std.Time.Month.Ordinal) ×'
(acc : ℤ) ×' (_ : ↑ordinal > acc) ×' acc = (Std.Time.Month.Ordinal.cumulativeDays leap idx).val),
Std.Time.ValidDate.ofOrdinal.go._unary✝ ordinal _x =
PSigma.casesOn _x fun idx acc =>
PSigma.case... | null | false |
Rat.cast_fract | Mathlib.Data.Rat.Floor | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : FloorRing α] (x : ℚ),
↑(Int.fract x) = Int.fract ↑x | null | true |
List.Perm.union_right | Batteries.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α} [inst : BEq α] [LawfulBEq α] (t₁ : List α), l₁.Perm l₂ → (l₁ ∪ t₁).Perm (l₂ ∪ t₁) | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastRotateLeft._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (target : aig.ShiftTarget w),
∀ idx < w, ¬idx < target.distance % w → idx - target.distance % w < w | null | false |
RCLike.sqrt_eq_ite | Mathlib.Analysis.RCLike.Sqrt | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {a : 𝕜},
RCLike.sqrt a =
if h : RCLike.im RCLike.I = 1 then (RCLike.complexRingEquiv h).symm ((RCLike.complexRingEquiv h) a).sqrt
else ↑√(RCLike.re a) | null | true |
CategoryTheory.Arrow.cechNerve | Mathlib.AlgebraicTopology.CechNerve | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(f : CategoryTheory.Arrow C) →
[∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] →
CategoryTheory.SimplicialObject C | The Čech nerve associated to an arrow. | true |
CategoryTheory.Functor.IsWellOrderContinuous.restriction_setIci | Mathlib.CategoryTheory.Limits.Shapes.Preorder.WellOrderContinuous | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J]
{F : CategoryTheory.Functor J C} [F.IsWellOrderContinuous] (j : J), (⋯.functor.comp F).IsWellOrderContinuous | null | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toSheafedSpace | Mathlib.Geometry.RingedSpace.OpenImmersion | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : AlgebraicGeometry.PresheafedSpace C} →
(Y : AlgebraicGeometry.SheafedSpace C) →
(f : X ⟶ Y.toPresheafedSpace) →
[H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] → AlgebraicGeometry.SheafedSpace C | If `X ⟶ Y` is an open immersion, and `Y` is a SheafedSpace, then so is `X`. | true |
Lean.MonadResolveName.mk._flat_ctor | Lean.ResolveName | {m : Type → Type} → m Lean.Name → m (List Lean.OpenDecl) → Lean.MonadResolveName m | null | false |
AddCommGrpCat.coyonedaType._proof_3 | Mathlib.Algebra.Category.Grp.Yoneda | ∀ {X Y : Type u_1ᵒᵖ} (f : X ⟶ Y) ⦃X_1 Y_1 : AddCommGrpCat⦄ (f_1 : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
({ obj := fun G => ↧(Opposite.unop X → ↑G),
map := fun {X_2 Y} f =>
AddCommGrpCat.ofHom
(AddMonoidHom.pi fun i => (AddCommGrpCat.Hom.hom f).comp (Pi.evalAddM... | null | false |
Isometry.comp_continuousOn_iff | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β} {γ : Type u_3}
[inst_2 : TopologicalSpace γ], Isometry f → ∀ {g : γ → α} {s : Set γ}, ContinuousOn (f ∘ g) s ↔ ContinuousOn g s | null | true |
CategoryTheory.CostructuredArrow.prodInverse._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_2, u_6} D] {C' : Type u_3} [inst_2 : CategoryTheory.Category.{u_7, u_3} C']
{D' : Type u_8} [inst_3 : CategoryTheory.Category.{u_4, u_8} D'] (S : CategoryTheory.Functor C D)
(S' : CategoryTheory.Func... | null | false |
ConvexOn.integrable_apply_rnDeriv_of_integrable_compProd | Mathlib.MeasureTheory.Measure.Decomposition.IntegralRNDeriv | ∀ {𝓧 : Type u_1} {m𝓧 : MeasurableSpace 𝓧} {μ ν : MeasureTheory.Measure 𝓧} {𝓨 : Type u_2} {m𝓨 : MeasurableSpace 𝓨}
{κ η : ProbabilityTheory.Kernel 𝓧 𝓨} {f : ℝ → ℝ} [MeasureTheory.IsFiniteMeasure μ] [MeasureTheory.IsFiniteMeasure ν]
[ProbabilityTheory.IsMarkovKernel κ] [ProbabilityTheory.IsMarkovKernel η],
... | For `f` a convex function on `Ici 0`, if `f ((μ ⊗ₘ κ).rnDeriv (ν ⊗ₘ η) (a, b))` is integrable,
then `f (μ.rnDeriv ν a)` is integrable. | true |
Metric.isPreconnected_ball | Mathlib.Analysis.Normed.Module.Connected | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [NormedSpace ℝ E] {x : E} {r : ℝ}, IsPreconnected (Metric.ball x r) | null | true |
ExteriorAlgebra.baseChangeEquiv_symm_apply | Mathlib.LinearAlgebra.ExteriorAlgebra.BaseChange | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Type u_3)
[inst_3 : CommRing S] [inst_4 : Algebra R S] (s : S) (m : M),
(ExteriorAlgebra.baseChangeEquiv R M S).symm ((ExteriorAlgebra.ι S) (s ⊗ₜ[R] m)) = s ⊗ₜ[R] (ExteriorAlgebra.ι R) m | null | true |
Module.instFinitePolynomialAEval' | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (φ : M →ₗ[R] M)
[Module.Finite R M], Module.Finite (Polynomial R) (Module.AEval' φ) | null | true |
_private.Mathlib.GroupTheory.ArchimedeanDensely.0.LinearOrderedCommGroupWithZero.wellFoundedOn_setOfPred_ge_gt_iff_nonempty_discrete_of_ne_zero._simp_1_6 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (a ≤ 0) = (a = 0) | null | false |
Real.sin_nonpos_of_nonpos_of_neg_pi_le | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ {x : ℝ}, x ≤ 0 → -Real.pi ≤ x → Real.sin x ≤ 0 | null | true |
USize.toBitVec64_ofNatLT | Init.Data.UInt.IntToBitVec | ∀ {n : ℕ} (hn : n < USize.size) (h : System.Platform.numBits = 64), (USize.ofNatLT n hn).toBitVec64 h = n#'⋯ | null | true |
Array.sum_div_length_le_max_of_max?_eq_some_int | Init.Data.Array.Int | ∀ {x : ℤ} {xs : Array ℤ}, xs.max? = some x → xs.sum / ↑xs.size ≤ x | null | true |
AddGroup.fintypeOfKerOfCodom._proof_2 | Mathlib.GroupTheory.QuotientGroup.Finite | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] (g : G →+ H),
∀ x ∈ g.ker, ∃ y, (AddSubgroup.topEquiv.toAddMonoidHom.comp (AddSubgroup.inclusion ⋯)) y = x | null | false |
Lean.Parser.registerAlias | Lean.Parser.Extension | Lean.Name →
Lean.Name →
Lean.Parser.ParserAliasValue →
optParam (Option Lean.SyntaxNodeKind) none → optParam Lean.Parser.ParserAliasInfo { } → IO Unit | null | true |
Vector.isEqv_self | Init.Data.Vector.DecidableEq | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] (xs : Vector α n), (xs.isEqv xs fun x1 x2 => decide (x1 = x2)) = true | null | true |
Std.ExtDHashMap.Const.getD_insertIfNew | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {fallback v : β},
Std.ExtDHashMap.Const.getD (m.insertIfNew k v) a fallback =
if (k == a) = true ∧ k ∉ m then v else Std.ExtDHashMap.Const.getD m a fallback | null | true |
Aesop.UnsafeQueueEntry | Aesop.Tree.UnsafeQueue | Type | null | true |
_private.Mathlib.NumberTheory.LucasLehmer.0.mersenne_mod_three._proof_1_2 | Mathlib.NumberTheory.LucasLehmer | ∀ (j : ℕ), 2 * (j + 1) = 2 * j + 1 + 1 | null | false |
_private.Mathlib.RingTheory.FractionalIdeal.Norm.0.FractionalIdeal.absNorm_span_singleton._simp_1_5 | Mathlib.RingTheory.FractionalIdeal.Norm | ∀ {α : Type u} [inst : Semiring α] {x y : α}, (x ∈ Ideal.span {y}) = ∃ a, a * y = x | null | false |
Lean.instToExprLiteral | Lean.ToExpr | Lean.ToExpr Lean.Literal | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne.0.SimplexCategory.δ_comp_toMk₁_of_lt._proof_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne | ∀ {n : ℕ} (j i : Fin (n + 2)),
j.castSucc < i.succ →
∀ (k : Fin ({ len := n }.len + 1)),
(CategoryTheory.ConcreteCategory.hom (SimplexCategory.toMk₁ i.succ)) (j.succAbove k) =
(CategoryTheory.ConcreteCategory.hom (SimplexCategory.toMk₁ i)) k | null | false |
PiLp.edist_eq_card | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {ι : Type u_2} {β : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → EDist (β i)] (f g : PiLp 0 β),
edist f g = ↑⋯.toFinset.card | null | true |
Projectivization.mulHeight | Mathlib.NumberTheory.Height.Projectivization | {K : Type u_1} →
[inst : Field K] → [Height.AdmissibleAbsValues K] → {ι : Type u_2} → [Finite ι] → Projectivization K (ι → K) → ℝ | The multiplicative height of a point on a finite-dimensional projective space over `K`
with a given basis. | true |
add_tsub_le_tsub_add | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α] {a b c : α}
[AddLeftMono α], a + b - c ≤ a - c + b | See `tsub_add_eq_add_tsub` for the equality. | true |
CategoryTheory.Center.isoMk | Mathlib.CategoryTheory.Monoidal.Center | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X Y : CategoryTheory.Center C} → (f : X ⟶ Y) → [CategoryTheory.IsIso f.f] → X ≅ Y | Construct an isomorphism in the Drinfeld center from
a morphism whose underlying morphism is an isomorphism.
| true |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.mem_rootsOfUnity._simp_1_4 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Diffeomorph.boundarylessManifold | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.collectVersoTokens.tok | Lean.Server.FileWorker.SemanticHighlighting | Lean.Syntax → Lean.Lsp.SemanticTokenType → StateM (Array Lean.Server.FileWorker.LeanSemanticToken) Unit | null | true |
Nat.getElem_toArray_roo | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ} (_h : i < (m<...n).toArray.size), (m<...n).toArray[i] = m + 1 + i | null | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.map'_inv_eq_inv_map'._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n m : ℕ}, n + 1 ≤ m → ¬n ≤ m → False | null | false |
Setoid.comap | Mathlib.Order.Setoid.Basic | {α : Type u_1} → {β : Type u_2} → (α → β) → Setoid β → Setoid α | Given a function `f : α → β`, an equivalence relation `r` on `β` induces an equivalence
relation on `α` defined by '`x ≈ y` iff `f(x)` is related to `f(y)` by `r`'.
See note [reducible non-instances]. | true |
UniformConcaveOn.concaveOn | Mathlib.Analysis.Convex.Strong | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {φ : ℝ → ℝ} {s : Set E} {f : E → ℝ},
UniformConcaveOn s φ f → 0 ≤ φ → ConcaveOn ℝ s f | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.glueDataT._proof_7 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (U V : ↑X.affineOpens),
CategoryTheory.CategoryStruct.comp
(AlgebraicGeometry.Scheme.Hom.liftQuotient
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd (I.glueDataObjι U) (X.homOfLE ⋯))
(CategoryTheory.CategoryStruct... | null | false |
Lean.Meta.Sym.getMatch | Lean.Meta.Sym.Simp.DiscrTree | {α : Type} → Lean.MetavarContext → Lean.Meta.DiscrTree α → Lean.Expr → Array α | Retrieves all values whose patterns match the expression `e`.
`mctx` is used to resolve assigned metavariables during retrieval; see `resolveAssignedMVars`.
| true |
UInt64.not_eq_neg_sub | Init.Data.UInt.Bitwise | ∀ (a : UInt64), ~~~a = -a - 1 | null | true |
ImportGraph.Shake.Needs.map₂ | ImportGraph.Shake.Basic | ImportGraph.Shake.Needs →
ImportGraph.Shake.Needs →
(ImportGraph.Shake.Bitset → ImportGraph.Shake.Bitset → ImportGraph.Shake.Bitset) → ImportGraph.Shake.Needs | Applies `f` "pointwise" to the pairs of bitsets at each given `NeedsKind`.
`f (n₁.get k) (n₂.get k) = (n₁.map₂ n₂ f).get k` for all `k : NeedsKind`. | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.ExistsContDiffBumpBase.y_smooth._simp_1_7 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b | null | false |
PrincipalSeg.isMin_apply_iff | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder β] {a : α} [inst_1 : PartialOrder α] (f : α <i β),
IsMin (f.toRelEmbedding a) ↔ IsMin a | null | true |
CategoryTheory.NatTrans.mapHomologicalComplex_id | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (c : ComplexShape ι) (F : CategoryTheory.Functor W₁ W₂)
[inst_4... | null | true |
PiTensorProduct.congr_symm_tprod | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {t : ι → Type u_11} [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i ≃ₗ[R] t i) (p : (i : ι) → t i),
(PiTensorProdu... | null | true |
le_of_forall_lt_imp_ne | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ c < a, c ≠ b) → a ≤ b | null | true |
MeasureTheory.IsFundamentalDomain.setIntegral_eq_tsum | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} {E : Type u_5} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α]
[inst_3 : NormedAddCommGroup E] {s : Set α} {μ : MeasureTheory.Measure α} [MeasurableConstSMul G α]
[MeasureTheory.SMulInvariantMeasure G α μ] [Countable G] [inst_7 : NormedSpace ℝ E],
MeasureTheo... | null | true |
mul_eq_zero_of_ne_zero_imp_eq_zero | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] {a b : M₀}, (a ≠ 0 → b = 0) → a * b = 0 | null | true |
Nat.Partition.oddDistincts | Mathlib.Combinatorics.Enumerative.Partition.Basic | (n : ℕ) → Finset n.Partition | The finset of those partitions in which every part is odd and used at most once. | true |
Real.exp_one_gt_d9 | Mathlib.Analysis.Complex.ExponentialBounds | 2.7182818283 < Real.exp 1 | null | true |
Std.Http.Method.mkworkspace | Std.Http.Data.Method | Std.Http.Method | Create a workspace resource.
Source: https://www.rfc-editor.org/rfc/rfc3253#section-6.3
| true |
instNonUnitalCommCStarAlgebraSubtypeMemNonUnitalStarSubalgebraComplexElementalOfIsStarNormal._proof_8 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] (x : A) (a b c : ↥(NonUnitalStarAlgebra.elemental ℂ x)),
(a + b) * c = a * c + b * c | null | false |
_private.Lean.Compiler.LCNF.FixedParams.0.Lean.Compiler.LCNF.FixedParams.isEquivalentFunDecl?._sparseCasesOn_7 | Lean.Compiler.LCNF.FixedParams | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((fvarId : Lean.FVarId) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) → motive (Lean.Compiler.LCNF.LetValue.fvar fvarId args)) →
(Nat.hasNotBit 16 t.ctorIdx → motiv... | null | false |
ContMDiffConstSMul.rec | Mathlib.Geometry.Manifold.Algebra.SMul | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{n : WithTop ℕ∞} →
... | null | false |
CategoryTheory.Abelian.Ext.comp_add | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y Z : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) {m : ℕ}
(β₁ β₂ : CategoryTheory.Abelian.Ext Y Z m) {p : ℕ} (h : n + m = p), α.comp (β₁ + β₂) h = α.comp β₁ h + α.comp β₂ h | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.