name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
NonUnitalStarSubalgebra.ofClass._proof_2 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {S : Type u_2} {A : Type u_1} [inst : NonUnitalNonAssocSemiring A] [inst_1 : SetLike S A]
[NonUnitalSubsemiringClass S A] (s : S), 0 ∈ s | null | false |
_private.Mathlib.Order.KrullDimension.0.Order.height_eq_krullDim_Iic._simp_1_3 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | null | false |
Subgroup.commutator_le_focalSubgroupOf | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), commutator ↥H ≤ H.focalSubgroupOf | null | true |
instDecidableEqNzsNum | Mathlib.Data.Num.Bitwise | DecidableEq NzsNum | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Mathlib.Meta.NormNum.evalRPow.match_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | (motive :
(u : Lean.Level) →
{αR : Q(Type u)} →
(e : Q(«$αR»)) →
Lean.MetaM (Mathlib.Meta.NormNum.Result e) → Lean.MetaM (Mathlib.Meta.NormNum.Result e) → Sort u_1) →
(u : Lean.Level) →
{αR : Q(Type u)} →
(e : Q(«$αR»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.NormNum.... | null | false |
BoundedVariationOn.variation_vectorMeasure_Ioc | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : DenselyOrdered α] [inst_2 : TopologicalSpace α]
[inst_3 : OrderTopology α] [inst_4 : SecondCountableTopology α] [inst_5 : CompactIccSpace α] [hα : MeasurableSpace α]
[inst_6 : BorelSpace α] {E : Type u_2} [inst_7 : NormedAddCommGroup E] [inst_8 : CompleteSpace E] {f... | null | true |
tendsto_mul | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M] {a b : M},
Filter.Tendsto (fun p => p.1 * p.2) (nhds (a, b)) (nhds (a * b)) | null | true |
Lean.Compiler.LCNF.LambdaLifting.State.recOn | Lean.Compiler.LCNF.LambdaLifting | {motive : Lean.Compiler.LCNF.LambdaLifting.State → Sort u} →
(t : Lean.Compiler.LCNF.LambdaLifting.State) →
((decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
(nextIdx : ℕ) → motive { decls := decls, nextIdx := nextIdx }) →
motive t | null | false |
CategoryTheory.Abelian.mono_inr_of_isColimit | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C]
[CategoryTheory.Limits.HasPushouts C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Mono f]
{s : CategoryTheory.Limits.PushoutCocone f g} (hs : CategoryTheory.Limits.IsColimit s), CategoryTheory.Mono s.inr | null | true |
CategoryTheory.Limits.IsColimit.mapCoconeEquiv.eq_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {K : CategoryTheory.Functor J C}
{F G : CategoryTheory.Functor C D} (h : F ≅ G) {c : CategoryTheory.Limits.Cocone K}
(t : CategoryTheo... | null | true |
HomotopicalAlgebra.FibrantObject.HoCat.localizerMorphismResolution | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.LocalizerMorphism (HomotopicalAlgebra.weakEquivalences C)
(HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.FibrantObject.HoCat C)) | The fibrant resolution functor `HoCat.resolution`, as a localizer morphism. | true |
Aesop.popGoal? | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM Q (Option Aesop.GoalRef) | null | true |
_private.Mathlib.Analysis.Complex.JensenFormula.0.norm_herglotzLogIntegrand_circleMap_le | Mathlib.Analysis.Complex.JensenFormula | ∀ {w ρ : ℂ} {R r₀ r : ℝ},
0 < R →
‖ρ‖ = R →
0 < r₀ →
‖w‖ < r₀ →
r₀ ≤ r →
r ≤ R →
∀ (θ : ℝ),
0 < ‖circleMap 0 R θ - ρ‖ →
‖herglotzLogIntegrand✝ w ρ (circleMap 0 r θ)‖ ≤
(R + ‖w‖) / (r₀ - ‖w‖) *
... | null | true |
Algebra.SubmersivePresentation.ofHasCoeffs | Mathlib.RingTheory.Extension.Presentation.Core | {R : Type u_1} →
{S : Type u_2} →
{ι : Type u_3} →
{σ : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : Finite σ] →
(P : Algebra.SubmersivePresentation R S ι σ) →
(R₀ : Type u_5) →
... | The submersive presentation on `P.ModelOfHasCoeffs R₀` provided `P.HasCoeffs R₀`. | true |
Valuation.ltSubmodule_monotone | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u} {Γ₀ : Type v} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀),
Monotone v.ltSubmodule | null | true |
OrthonormalBasis.coe_equiv_euclideanSpace | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (b : OrthonormalBasis ι 𝕜 E),
⇑((EuclideanSpace.basisFun ι 𝕜).equiv b (Equiv.refl ι)) = fun x => ∑ i, x.ofLp i • b i | null | true |
SModEq.symm | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M}
{x y : M}, x ≡ y [SMOD U] → y ≡ x [SMOD U] | null | true |
Units.add._proof_1 | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : HasSummableGeomSeries R] (x : Rˣ) (t : R) (h : ‖t‖ < ‖↑x⁻¹‖⁻¹),
↑(x * Units.oneSub (-(↑x⁻¹ * t)) ⋯)⁻¹ = ↑(x * Units.oneSub (-(↑x⁻¹ * t)) ⋯)⁻¹ | null | false |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.mk.injEq | Mathlib.CategoryTheory.Localization.Predicate | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {L : CategoryTheory.Functor C D}
{W : CategoryTheory.MorphismProperty C} {E : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(inverts : W.IsInvertedBy L) (lift : (F : CategoryTh... | null | true |
Bifunctor.snd | Mathlib.Control.Bifunctor | {F : Type u₀ → Type u₁ → Type u₂} → [Bifunctor F] → {α : Type u₀} → {β β' : Type u₁} → (β → β') → F α β → F α β' | Right map of a bifunctor. | true |
Lean.mkAppRange | Lean.Expr | Lean.Expr → ℕ → ℕ → Array Lean.Expr → Lean.Expr | `mkAppRange f i j #[a_1, ..., a_i, ..., a_j, ... ]` ==> the expression `f a_i ... a_{j-1}` | true |
LinearMap.normDet_comp | Mathlib.Analysis.InnerProductSpace.NormDet | ∀ {𝕜 : Type u_1} {U : Type u_2} {V : Type u_3} {W : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup U]
[inst_2 : InnerProductSpace 𝕜 U] [inst_3 : FiniteDimensional 𝕜 U] [inst_4 : NormedAddCommGroup V]
[inst_5 : InnerProductSpace 𝕜 V] [inst_6 : NormedAddCommGroup W] [inst_7 : InnerProductSpace 𝕜 W] (f... | null | true |
MeasureTheory.UniformIntegrable.memLp_of_ae_tendsto | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{p : ENNReal} {κ : Type u_4} {u : Filter κ} [u.NeBot] [u.IsCountablyGenerated] {f : κ → α → β} {g : α → β},
MeasureTheory.UniformIntegrable f p μ →
(∀ᵐ (x : α) ∂μ, Filter.Tendsto (fun n => f n x) ... | Suppose `f` is a sequence of functions that converges a.e. to `g`. If `f` is
`UniformIntegrable`, then `g` is in `Lp`. | true |
CategoryTheory.Limits.IsWeakLimit.postcompose_inv_iff_of_iso | Mathlib.CategoryTheory.Limits.WeakLimits.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{v_3, u_3} C] {F G : CategoryTheory.Functor J C} (α : F ≅ G)
(c : CategoryTheory.Limits.Cone G),
Nonempty (CategoryTheory.Limits.IsWeakLimit ((CategoryTheory.Limits.Cone.postcompose α.inv).obj c)) ↔
... | A cone postcomposed with the inverse of a natural isomorphism is a weak limit cone
if and only if the original cone is.
| true |
_private.Aesop.Builder.Forward.0.Aesop.RuleBuilder.getImmediatePremises._sparseCasesOn_1 | Aesop.Builder.Forward | {motive : Lean.BinderInfo → Sort u} →
(t : Lean.BinderInfo) → motive Lean.BinderInfo.instImplicit → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
Set.infinite_of_injective_forall_mem | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {β : Type v} [Infinite α] {s : Set β} {f : α → β},
Function.Injective f → (∀ (x : α), f x ∈ s) → s.Infinite | null | true |
IntCast.rec | Init.Data.Int.Basic | {R : Type u} →
{motive : IntCast R → Sort u_1} → ((intCast : ℤ → R) → motive { intCast := intCast }) → (t : IntCast R) → motive t | null | false |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_isClosed_diagonal._simp_1_4 | Mathlib.Topology.Separation.Hausdorff | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doNested._regBuiltin.Lean.Parser.Term.doNested.declRange_3 | Lean.Parser.Do | IO Unit | null | false |
QuadraticForm.radical_weightedSumSquares | Mathlib.LinearAlgebra.QuadraticForm.Radical | ∀ {𝕜 : Type u_1} {ι : Type u_2} [inst : Field 𝕜] [NeZero 2] [inst_2 : Fintype ι] {w : ι → 𝕜},
(QuadraticMap.weightedSumSquares 𝕜 w).radical = Pi.spanSubset 𝕜 {i | w i = 0} | Over a field of characteristic different from `2`,
the radical of a weighted-sum-of-squares quadratic form is the number of zero weights. | true |
Std.Rxi.HasSize.rec | Init.Data.Range.Polymorphic.Basic | {α : Type u} →
{motive : Std.Rxi.HasSize α → Sort u_1} →
((size : α → ℕ) → motive { size := size }) → (t : Std.Rxi.HasSize α) → motive t | null | false |
CategoryTheory.ShortComplex.RightHomologyMapData.mk | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.RightHomologyData} →
{h₂ : S₂.RightHomologyData} →
(φQ : h₁.Q ⟶ h₂.Q) →
... | null | true |
AlgebraicGeometry.Scheme.affineOpenCoverOfSpanRangeEqTop._proof_3 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {R : CommRingCat} {ι : Type u_1} (s : ι → ↑R),
Ideal.span (Set.range s) = ⊤ → ∀ (x : ↥(AlgebraicGeometry.Spec R)), ∃ i, s i ∉ x.asIdeal | null | false |
Submodule.starProjection_inj | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{U V : Submodule 𝕜 E} [inst_3 : U.HasOrthogonalProjection] [inst_4 : V.HasOrthogonalProjection],
U.starProjection = V.starProjection ↔ U = V | `U.starProjection = V.starProjection` iff `U = V`. | true |
BiheytingHom.id_comp | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_2} {β : Type u_3} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β] (f : BiheytingHom α β),
(BiheytingHom.id β).comp f = f | null | true |
_private.Batteries.Data.String.Lemmas.0.String.foldlAux_of_valid.match_1_1 | Batteries.Data.String.Lemmas | ∀ {α : Type u_1} (motive : List Char → List Char → List Char → α → Prop) (x x_1 x_2 : List Char) (x_3 : α),
(∀ (l r : List Char) (a : α), motive l [] r a) →
(∀ (l : List Char) (c : Char) (m r : List Char) (a : α), motive l (c :: m) r a) → motive x x_1 x_2 x_3 | null | false |
BoundedLatticeHom.toInfTopHom | Mathlib.Order.Hom.BoundedLattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Lattice α] →
[inst_1 : Lattice β] →
[inst_2 : BoundedOrder α] → [inst_3 : BoundedOrder β] → BoundedLatticeHom α β → InfTopHom α β | null | true |
SSet.Edge.map_id | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X Y : SSet} (x₀ : X.obj (Opposite.op { len := 0 })) (f : X ⟶ Y),
(SSet.Edge.id x₀).map f = SSet.Edge.id ((CategoryTheory.ConcreteCategory.hom (f.app (Opposite.op { len := 0 }))) x₀) | null | true |
_private.Std.Data.String.ToNat.0.noRepetition_iff | Std.Data.String.ToNat | ∀ {α : Type u} {a : α} {l : List α}, NoRepetition✝ a l ↔ ¬[a, a] <:+: l | null | true |
Convexity.convexCombPair_one | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {R : Type u_1} {X : Type u_2} [inst : PartialOrder R] [inst_1 : Semiring R] [inst_2 : IsStrictOrderedRing R]
[inst_3 : Convexity.ConvexSpace R X] {x y : X}, Convexity.convexCombPair 1 0 ⋯ ⋯ ⋯ x y = x | A binary convex combination with weight 1 on the first point returns the first point. | true |
Float.Model.UnpackedFloat.Sign.instDiv | Init.Data.Float.Model.Unpacked.Sign | Div Float.Model.UnpackedFloat.Sign | null | true |
GroupExtension.Equiv.ofMonoidHom._proof_6 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_4} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_1} [inst_2 : Group E]
{S : GroupExtension N E G} {E' : Type u_3} [inst_3 : Group E'] {S' : GroupExtension N E' G} (f : E →* E'),
S'.rightHom.comp f = S.rightHom → ⇑(S'.rightHom.comp f) = ⇑S.rightHom | null | false |
EisensteinSeries.r1.eq_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ (z : UpperHalfPlane), EisensteinSeries.r1 z = z.im ^ 2 / (z.re ^ 2 + z.im ^ 2) | null | true |
CategoryTheory.Limits.Cofork.IsColimit.homIso_natural | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : Y ⟶ X} {t : CategoryTheory.Limits.Cofork f g}
(ht : CategoryTheory.Limits.IsColimit t) {Z Z' : C} (q : Z ⟶ Z') (k : t.pt ⟶ Z),
↑((CategoryTheory.Limits.Cofork.IsColimit.homIso ht Z') (CategoryTheory.CategoryStruct.comp k q)) =
CategoryThe... | The bijection of `Cofork.IsColimit.homIso` is natural in `Z`. | true |
continuousWithinAt_iff_continuous_left'_right'._to_dual_1 | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace β]
{s : Set α} {a : α} {f : α → β},
ContinuousWithinAt f s a ↔ ContinuousWithinAt f (s ∩ Set.Ioi a) a ∧ ContinuousWithinAt f (s ∩ Set.Iio a) a | null | false |
_private.Mathlib.Tactic.Lift.0.Mathlib.Tactic.Lift.main.match_3 | Mathlib.Tactic.Lift | (motive : Option (Lean.TSyntax `ident) → Sort u_1) →
(newVarName : Option (Lean.TSyntax `ident)) →
((v : Lean.TSyntax `ident) → motive (some v)) → (Unit → motive none) → motive newVarName | null | false |
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.Kernel.HasSubgaussianMGF.measure_pos_eq_zero_of_hasSubGaussianMGF_zero._simp_1_2 | Mathlib.Probability.Moments.SubGaussian | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
Std.Roc.Sliceable.rec | Init.Data.Slice.Notation | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : Std.Roc.Sliceable α β γ → Sort u_1} →
((mkSlice : α → Std.Roc β → γ) → motive { mkSlice := mkSlice }) → (t : Std.Roc.Sliceable α β γ) → motive t | null | false |
HomotopicalAlgebra.AttachCells.ofArrowIso._proof_1 | Mathlib.AlgebraicTopology.RelativeCellComplex.AttachCells | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {α : Type u_4} {A B : α → C} {g : (a : α) → A a ⟶ B a}
{X₁ X₂ : C} {f : X₁ ⟶ X₂} (c : HomotopicalAlgebra.AttachCells g f) {Y₁ Y₂ : C} {f' : Y₁ ⟶ Y₂}
(e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f'),
CategoryTheory.IsPushout (CategoryTheory... | null | false |
WithTop.add_right_inj | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] {x y z : WithTop α} [IsRightCancelAdd α], z ≠ ⊤ → (x + z = y + z ↔ x = y) | null | true |
CategoryTheory.Comonad.comparison._proof_3 | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {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] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C}
(h : L ⊣ R) (X : C),
CategoryTheory.CategoryStruct.comp (L.map (h.unit.app X)) (h.toComonad.δ.app (L.obj X)) =
Categor... | null | false |
RatFunc.intDegree_add_le | Mathlib.FieldTheory.RatFunc.Degree | ∀ {K : Type u} [inst : Field K] {x y : RatFunc K}, y ≠ 0 → x + y ≠ 0 → (x + y).intDegree ≤ max x.intDegree y.intDegree | null | true |
SimpleGraph.TripartiteFromTriangles.toTriangle.match_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (motive : α × β × γ → Prop) (x : α × β × γ),
(∀ (a' : α) (b' : β) (c' : γ), motive (a', b', c')) → motive x | null | false |
LiouvilleWith.mul_rat_iff | Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | ∀ {p x : ℝ} {r : ℚ}, r ≠ 0 → (LiouvilleWith p (x * ↑r) ↔ LiouvilleWith p x) | The product `x * r`, `r : ℚ`, `r ≠ 0`, is a Liouville number with exponent `p` if and only if
`x` satisfies the same condition. | true |
Module.IsTorsionFree.of_faithfulSMul | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[FaithfulSMul R A] [inst_4 : Semiring S] [inst_5 : Module S R] [inst_6 : Module S A] [IsScalarTower S R A]
[Module.IsTorsionFree S A], Module.IsTorsionFree S R | null | true |
AddOpposite.opUniformEquivRight._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
UniformContinuous AddOpposite.opEquiv.toFun | null | false |
CategoryTheory.Triangulated.TStructure.triangleLEGEIsoTriangleLTGE._proof_2 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | false |
Int.tdiv_left_inj | Init.Data.Int.DivMod.Lemmas | ∀ {a b d : ℤ}, d ∣ a → d ∣ b → (a.tdiv d = b.tdiv d ↔ a = b) | null | true |
Module.eqIdeal._proof_3 | Mathlib.RingTheory.Ideal.Defs | ∀ (R : Type u_1) {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m m' : M),
0 ∈ {r | r • m = r • m'} | null | false |
measurableSet_generateFrom_of_mem_supClosure | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {s : Set (Set α)} {t : Set α}, t ∈ supClosure s → MeasurableSet t | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastExtractAndExtendBit._simp_1_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop | ∀ {n : ℕ}, (n < 1) = (n = 0) | null | false |
List.getElem!_inj | Init.Data.List.Pairwise | ∀ {α : Type u_1} {i j : ℕ} [inst : Inhabited α] {xs : List α},
i < xs.length → j < xs.length → xs.Nodup → (xs[i]! = xs[j]! ↔ i = j) | null | true |
Std.TreeSet.Raw.isEmpty_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, (t.insert k).isEmpty = false | null | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_finset_disjoint_balls_large_measure._simp_1_20 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
Std.DTreeMap.Internal.Unit.RooSliceData | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) → [Ord α] → Type u | null | true |
MeasureTheory.projectiveFamilyContent_eq | Mathlib.MeasureTheory.Constructions.ProjectiveFamilyContent | ∀ {ι : Type u_1} {α : ι → Type u_2} {mα : (i : ι) → MeasurableSpace (α i)}
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} {s : Set ((i : ι) → α i)}
(hP : MeasureTheory.IsProjectiveMeasureFamily P),
(MeasureTheory.projectiveFamilyContent hP) s = MeasureTheory.projectiveFamilyFun P s | null | true |
norm_add₄_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] {a b c d : E}, ‖a + b + c + d‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ + ‖d‖ | **Triangle inequality** for the norm. | true |
_private.Mathlib.AlgebraicGeometry.Scheme.0.AlgebraicGeometry.basicOpen_eq_of_affine._simp_1_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
CategoryTheory.Functor.whiskerRight_id | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor C D}
(F : CategoryTheory.Functor D E),
CategoryTheory.Functor.whiskerRight (CategoryTheory.NatTrans.id G) ... | null | true |
DirectSum.SetLike.IsHomogeneous | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid M] →
[inst_2 : SetLike σ M] →
[inst_3 : AddSubmonoidClass σ M] →
(ℳ : ι → σ) → [DirectSum.Decomposition ℳ] → {P : Type u_5} → [SetLike P M] → P → Prop | A substructure `p ⊆ M` is homogeneous if for every `m ∈ p`, all homogeneous components
of `m` are in `p`. | true |
MulOpposite.instNonUnitalNormedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [inst : NonUnitalNormedRing α] (a b : αᵐᵒᵖ), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
Graded.subtypeMap | Mathlib.Algebra.GradedFunLike | {F : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_4} →
{τ : Type u_5} →
{ι : Type u_6} →
[inst : SetLike σ A] →
[inst_1 : SetLike τ B] →
{𝒜 : ι → σ} →
{ℬ : ι → τ} → [inst_2 : FunLike F A B] → [GradedFunLike F 𝒜 ℬ] →... | A graded map descends to a map on each component. | true |
smoothSheafCommGroup.compLeft | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_2} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_3} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_4} →
... | For a manifold `M` and a smooth homomorphism `φ` between abelian Lie groups `A`, `A'`, the
'left-composition-by-`φ`' morphism of sheaves from `smoothSheafCommGroup IM I M A` to
`smoothSheafCommGroup IM I' M A'`. | true |
Batteries.BinomialHeap.Imp.Heap.foldTreeM._f | Batteries.Data.BinomialHeap.Basic | {m : Type u_1 → Type u_2} →
{β : Type u_1} →
{α : Type u_3} →
[Monad m] →
β → (α → β → β → m β) → (x : Batteries.BinomialHeap.Imp.Heap α) → Batteries.BinomialHeap.Imp.Heap.below x → m β | null | false |
Representation.mapSubmodule._proof_15 | Mathlib.RepresentationTheory.Submodule | ∀ {k : Type u_3} {G : Type u_2} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (q : Submodule (MonoidAlgebra k G) ρ.asModule),
(fun p =>
let __AddSubmonoid := AddSubmonoid.map ρ.asModuleEquiv.symm (↑p).toAddSubmonoid;
... | null | false |
LieDerivation.coe_sub_linearMap | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(D1 D2 : LieDerivation R L M), ↑(D1 - D2) = ↑D1 - ↑D2 | null | true |
Std.ExtHashMap.getKey?_inter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (m₁ ∩ m₂).getKey? k = if k ∈ m₂ then m₁.getKey? k else none | null | true |
Lean.Lsp.SemanticTokenType.decorator.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SemanticTokenType.decorator = 1 | null | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.prod_Icc_div._proof_1_9 | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_1} [inst : CommGroup M] {n : ℕ} {a b : Fin n} (f : Fin (n + 1) → M) (x : ℕ),
↑a ≤ x ∧ x ≤ ↑b →
(if h : x < n then f ⟨x + 1, ⋯⟩ / f ⟨x, ⋯⟩ else 1) =
(if h : x < n then f ⟨x + 1, ⋯⟩ else 1) / if h : x ≤ n then f ⟨x, ⋯⟩ else 1 | null | false |
_private.Lean.Elab.AssertExists.0.Lean.Elab.Command.elabImportPath._regBuiltin.Lean.Elab.Command.elabImportPath_1 | Lean.Elab.AssertExists | IO Unit | null | false |
List.takeWhile_cons_of_pos | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, p a = true → List.takeWhile p (a :: l) = a :: List.takeWhile p l | null | true |
Lean.Expr.const.injEq | Lean.Expr | ∀ (declName : Lean.Name) (us : List Lean.Level) (declName_1 : Lean.Name) (us_1 : List Lean.Level),
(Lean.Expr.const declName us = Lean.Expr.const declName_1 us_1) = (declName = declName_1 ∧ us = us_1) | null | true |
Array.getElem_setIfInBounds | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α} {j : ℕ} (hj : j < xs.size),
(xs.setIfInBounds i a)[j] = if i = j then a else xs[j] | null | true |
Prod.instExistsAddOfLE | Mathlib.Algebra.Order.Monoid.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] [inst_2 : Add α] [inst_3 : Add β] [ExistsAddOfLE α]
[ExistsAddOfLE β], ExistsAddOfLE (α × β) | null | true |
Lean.Order.MonadTail.monotone_bind_right | Init.Internal.Order.MonadTail | ∀ (m : Type u → Type v) [inst : Monad m] [inst_1 : Lean.Order.MonadTail m] {α β : Type u} [inst_2 : Nonempty β]
{γ : Sort w} [inst_3 : Lean.Order.PartialOrder γ] (f : m α) (g : γ → α → m β),
Lean.Order.monotone g → Lean.Order.monotone fun x => f >>= g x | null | true |
Std.Internal.Small.mk._flat_ctor | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {α : Type v}, Nonempty (Std.Internal.ComputableSmall α) → Std.Internal.Small α | null | false |
Finset.nonempty_product | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}, (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty | null | true |
MonoidAlgebra.mapDomainNonUnitalRingHom_comp | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} {O : Type u_8} [inst : Semiring R] [inst_1 : Mul M] [inst_2 : Mul N]
[inst_3 : Mul O] (f : N →ₙ* O) (g : M →ₙ* N),
MonoidAlgebra.mapDomainNonUnitalRingHom R (f.comp g) =
(MonoidAlgebra.mapDomainNonUnitalRingHom R f).comp (MonoidAlgebra.mapDomainNonUnitalRingHom R g... | null | true |
OrderMonoidHom.copy._proof_2 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulOneClass α]
[inst_3 : MulOneClass β] (f : α →*o β) (f' : α → β) (h : f' = ⇑f) (x y : α),
(↑(f.copy f' h)).toFun (x * y) = (↑(f.copy f' h)).toFun x * (↑(f.copy f' h)).toFun y | null | false |
Lean.Elab.Term.MatchAltView.mk.inj | Lean.Elab.MatchAltView | ∀ {k : Lean.SyntaxNodeKinds} {ref : Lean.Syntax} {patterns : Array Lean.Syntax} {lhs : Lean.Syntax}
{rhs : Lean.TSyntax k} {ref_1 : Lean.Syntax} {patterns_1 : Array Lean.Syntax} {lhs_1 : Lean.Syntax}
{rhs_1 : Lean.TSyntax k},
{ ref := ref, patterns := patterns, lhs := lhs, rhs := rhs } =
{ ref := ref_1, pat... | null | true |
WithZeroTopology.tendsto_of_ne_zero | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {α : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {l : Filter α} {f : α → Γ₀} {γ : Γ₀},
γ ≠ 0 → (Filter.Tendsto f l (nhds γ) ↔ ∀ᶠ (x : α) in l, f x = γ) | null | true |
NumberField.mixedEmbedding.norm_le_convexBodySumFun | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.mixedSpace K),
‖x‖ ≤ NumberField.mixedEmbedding.convexBodySumFun x | null | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.X | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} → {S : C} → (self : F.PreOneHypercoverDenseData S) → self.I₀ → C₀ | the objects in the covering of `S` | true |
Std.HashSet.any_eq_true_iff_exists_mem_get | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [LawfulHashable α] [EquivBEq α] {p : α → Bool},
m.any p = true ↔ ∃ a, ∃ (h : a ∈ m), p (m.get a h) = true | null | true |
Pointed.coe_of | Mathlib.CategoryTheory.Category.Pointed | ∀ {X : Type u_1} (point : X), (Pointed.of point).X = X | null | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.sup'._simp_1_2 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {p : α ×' β → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩ | null | false |
CategoryTheory.Limits.instDecidableEqWalkingReflexivePair | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | DecidableEq CategoryTheory.Limits.WalkingReflexivePair | null | true |
NNReal.instLinearOrderedCommGroupWithZero._proof_4 | Mathlib.Basic.NNReal.Defs | ∀ (a : NNReal), a ^ 0 = 1 | null | false |
SubMulAction.mem_carrier | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] {p : SubMulAction R M} {x : M}, x ∈ p.carrier ↔ x ∈ ↑p | null | true |
Lean.Parser.ParserAliasInfo.recOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserAliasInfo → Sort u} →
(t : Lean.Parser.ParserAliasInfo) →
((declName : Lean.Name) →
(stackSz? : Option ℕ) →
(autoGroupArgs : Bool) →
motive { declName := declName, stackSz? := stackSz?, autoGroupArgs := autoGroupArgs }) →
motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.