name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_disjoint_covering_families._simp_1_10 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
Std.DHashMap.Const.foldM_eq_foldlM_toList | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {δ : Type w} {m' : Type w → Type w'} {β : Type v}
{m : Std.DHashMap α fun x => β} [inst : Monad m'] [LawfulMonad m'] {f : δ → α → β → m' δ} {init : δ},
Std.DHashMap.foldM f init m = List.foldlM (fun a b => f a b.1 b.2) init (Std.DHashMap.Const.toList m) | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.toFunctorToCategoricalPullback._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_3} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_2, u_4} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u_8)
[inst_3 : CategoryTheory.Category.{u_7, u_8}... | null | false |
Finset.notMem_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {a b : α}, a ∉ {b} ↔ a ≠ b | null | true |
Plausible.SampleableExt.sample | Plausible.Sampleable | {α : Sort u} → [self : Plausible.SampleableExt α] → Plausible.Arbitrary (Plausible.SampleableExt.proxy α) | null | true |
Bundle.Trivial.vectorBundle | Mathlib.Topology.VectorBundle.Constructions | ∀ (𝕜 : Type u_1) (B : Type u_2) (F : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace B], VectorBundle 𝕜 F (Bundle.Trivial B F) | null | true |
ModularGroup.exists_bound_of_subgroup_invariant | Mathlib.NumberTheory.ModularForms.Bounds | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {f : UpperHalfPlane → E},
Continuous f →
(∀ (g : Matrix.SpecialLinearGroup (Fin 2) ℤ), UpperHalfPlane.IsBoundedAtImInfty fun τ => f (g • τ)) →
∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.IsArithmetic],
(∀ g ∈ Γ, ∀ (τ : UpperHalfPlane), f (g • τ) = f τ) → ∃ C... | A function on `ℍ` which is invariant under an arithmetic subgroup and bounded at all cusps,
is uniformly bounded. | true |
CategoryTheory.Functor.IsOneHypercoverDense.of_hasPullbacks | 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} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} [CategoryTheory.Functor.IsDenseSubsite J₀ J F]
[CategoryTheory.Limits.H... | Constructor for `IsOneHypercoverDense.{w} F J₀ J` for a dense subsite
when the functor `F : C₀ ⥤ C` is fully faithful, `C` has pullbacks, and
any object in `C` admits a `w`-small covering family consisting of objects in `C₀`. | true |
NonUnitalSubalgebra.coe_zero | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
{S : NonUnitalSubalgebra R A}, ↑0 = 0 | null | true |
Fin.insertNthOrderIso_symm_apply | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_2) [inst : (i : Fin (n + 1)) → LE (α i)] (p : Fin (n + 1))
(f : (i : Fin (n + 1)) → α i), (RelIso.symm (Fin.insertNthOrderIso α p)) f = (f p, p.removeNth f) | null | true |
NNReal.coe_sInf | Mathlib.Data.NNReal.Defs | ∀ (s : Set NNReal), ↑(sInf s) = sInf (NNReal.toReal '' s) | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Reify.0.Lean.Meta.Grind.Arith.CommRing.reifyCore?.go | Lean.Meta.Tactic.Grind.Arith.CommRing.Reify | {m : Type → Type} →
[MonadLiftT Lean.MetaM m] →
[Lean.MonadError m] →
[Monad m] →
[Lean.Meta.Sym.Arith.MonadCanon m] →
[Lean.Meta.Grind.Arith.CommRing.MonadRing m] →
(Lean.Expr → m Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(Lean.Expr → m Lean.Meta.Grind.Arith.Com... | null | true |
Measurable.of_discrete | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [DiscreteMeasurableSpace α]
{f : α → β}, Measurable f | null | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.instRxcLawfulHasSize.match_5 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (motive : (n : ℕ) → BitVec n → BitVec n → BitVec n → Prop) (n : ℕ) (lo hi lo_1 : BitVec n),
(∀ (lo hi lo_2 : BitVec 0), motive 0 lo hi lo_2) →
(∀ (n : ℕ) (lo hi lo_2 : BitVec (n + 1)), motive n.succ lo hi lo_2) → motive n lo hi lo_1 | null | false |
inv_apply | Mathlib.Data.FunLike.IsApply | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : Inv β}
{inst_2 : Inv F} [self : IsInvApply F α β] (f : F) (x : α), f⁻¹ x = (f x)⁻¹ | **Alias** of `IsInvApply.inv_apply`. | true |
LinearEquiv.toContinuousLinearEquivOfBounds | Mathlib.Analysis.Normed.Operator.ContinuousLinearMap | {𝕜 : Type u_1} →
{𝕜₂ : Type u_2} →
{E : Type u_3} →
{F : Type u_4} →
[inst : Ring 𝕜] →
[inst_1 : Ring 𝕜₂] →
[inst_2 : SeminormedAddCommGroup E] →
[inst_3 : SeminormedAddCommGroup F] →
[inst_4 : Module 𝕜 E] →
[inst_5 : Module ... | Construct a continuous linear equivalence from a linear equivalence together with
bounds in both directions. | true |
IntermediateField.relfinrank_eq_one_iff | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E},
A.relfinrank B = 1 ↔ B ≤ A | null | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.integral_le_sum_mul_Ico_of_antitone_monotone._proof_1_3 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), a ≤ i ∧ i < b → i + 1 ≤ b | null | false |
Std.Http.Body.Empty.ctorIdx | Std.Http.Data.Body.Empty | Std.Http.Body.Empty → ℕ | null | false |
groupCohomology.isoCocycles₂._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G),
(HomologicalComplex.sc (groupCohomology.inhomogeneousCochains A) 2).HasLeftHomology | null | false |
UniformEquiv.piCongrRight | Mathlib.Topology.UniformSpace.Equiv | {ι : Type u_4} →
{β₁ : ι → Type u_5} →
{β₂ : ι → Type u_6} →
[inst : (i : ι) → UniformSpace (β₁ i)] →
[inst_1 : (i : ι) → UniformSpace (β₂ i)] → ((i : ι) → β₁ i ≃ᵤ β₂ i) → ((i : ι) → β₁ i) ≃ᵤ ((i : ι) → β₂ i) | `Equiv.piCongrRight` as a uniform isomorphism: this is the natural isomorphism
`Π i, β₁ i ≃ᵤ Π j, β₂ i` obtained from uniform isomorphisms `β₁ i ≃ᵤ β₂ i` for each `i`. | true |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Vector.0.Vector.iterM_equiv_iterM_toList._simp_1_1 | Std.Data.Iterators.Lemmas.Producers.Monadic.Vector | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} {n : ℕ} {xs : Vector β n}, xs.iterM m = xs.toArray.iterM m | null | false |
_private.Mathlib.CategoryTheory.Subfunctor.Equalizer.0.CategoryTheory.Subfunctor.equalizer.condition._simp_1_1 | Mathlib.CategoryTheory.Subfunctor.Equalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor C (Type w)}
{A : CategoryTheory.Subfunctor F₁} (f g : A.toFunctor ⟶ F₂) {G : CategoryTheory.Functor C (Type w)}
(φ : G ⟶ A.toFunctor),
(CategoryTheory.CategoryStruct.comp φ f = CategoryTheory.CategoryStruct.comp φ g) =
(C... | null | false |
AlgebraicGeometry.Scheme.isAffine_affineBasisCover | Mathlib.AlgebraicGeometry.AffineScheme | ∀ (X : AlgebraicGeometry.Scheme) (i : X.affineBasisCover.I₀), AlgebraicGeometry.IsAffine (X.affineBasisCover.X i) | null | true |
Array.append_inj_left' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs₁ xs₂ ys₁ ys₂ : Array α}, xs₁ ++ ys₁ = xs₂ ++ ys₂ → ys₁.size = ys₂.size → xs₁ = xs₂ | Variant of `append_inj_left` instead requiring equality of the sizes of the second arrays. | true |
not_covBy_bot._simp_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α] {a : α}, (a ⋖ ⊥) = False | null | false |
_private.Mathlib.RingTheory.Unramified.LocalRing.0.Localization.exists_awayMap_bijective_of_localRingHom_bijective._simp_1_2 | Mathlib.RingTheory.Unramified.LocalRing | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_26 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (hp₀ : ¬p₀ = s.endPos) (q : s.Pos) (v : ℕ),
Lean.parseLowerHex?✝ 4 s (p₀.next hp₀) 0 = some (q, v) → p₀ < q | null | false |
RingHom.codRestrict._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_3} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {σS : Type u_2}
[inst_2 : SetLike σS S] [inst_3 : SubsemiringClass σS S] (f : R →+* S) (s : σS) (h : ∀ (x : R), f x ∈ s) (x y : R),
(↑((↑f).codRestrict s h)).toFun (x * y) = (↑((↑f).codRestrict s h)).toFun x * (↑((↑f).codRestr... | null | false |
RingHomInvPair.mk._flat_ctor | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ : R₁ →+* R₂}
{σ' : outParam (R₂ →+* R₁)}, σ'.comp σ = RingHom.id R₁ → σ.comp σ' = RingHom.id R₂ → RingHomInvPair σ σ' | null | false |
Lean.Meta.DiscrTree.recOn | Lean.Meta.DiscrTree.Types | {α : Type} →
{motive : Lean.Meta.DiscrTree α → Sort u} →
(t : Lean.Meta.DiscrTree α) →
((root : Lean.PersistentHashMap Lean.Meta.DiscrTree.Key (Lean.Meta.DiscrTree.Trie α)) → motive { root := root }) →
motive t | null | false |
_private.Mathlib.GroupTheory.Sylow.0.Sylow.exists_subgroup_card_pow_prime.match_1_1 | Mathlib.GroupTheory.Sylow | ∀ {G : Type u_1} [inst : Group G] (p : ℕ) {n : ℕ} (motive : (∃ K, Nat.card ↥K = p ^ n ∧ ⊥ ≤ K) → Prop)
(x : ∃ K, Nat.card ↥K = p ^ n ∧ ⊥ ≤ K), (∀ (K : Subgroup G) (hK : Nat.card ↥K = p ^ n ∧ ⊥ ≤ K), motive ⋯) → motive x | null | false |
MeasureTheory.AddQuotientMeasureEqMeasurePreimage.addHaarMeasure_quotient | Mathlib.MeasureTheory.Measure.Haar.Quotient | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] [inst_2 : TopologicalSpace G]
[IsTopologicalAddGroup G] [BorelSpace G] [PolishSpace G] {Γ : AddSubgroup G} [inst_6 : Γ.Normal] [T2Space (G ⧸ Γ)]
[SecondCountableTopology (G ⧸ Γ)] {μ : MeasureTheory.Measure (G ⧸ Γ)} [Countable ↥Γ] (ν : MeasureTheory.M... | If a measure `μ` on the quotient `G ⧸ Γ` of an additive group `G` by a discrete
normal subgroup `Γ` having fundamental domain, satisfies `AddQuotientMeasureEqMeasurePreimage`
relative to a standardized choice of Haar measure on `G`, and assuming `μ` is finite, then `μ` is
itself Haar. | true |
MeasureTheory.condExp_of_not_integrable | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | ∀ {α : Type u_1} {E : Type u_3} {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → E}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E], ¬MeasureTheory.Integrable f μ → μ[f | m] = 0 | null | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isDefEqArgs._sparseCasesOn_1 | Lean.Meta.ExprDefEq | {motive : Lean.Meta.DefEqArgsFirstPassResult → Sort u} →
(t : Lean.Meta.DefEqArgsFirstPassResult) →
((postponedImplicit postponedHO : Array ℕ) →
motive (Lean.Meta.DefEqArgsFirstPassResult.ok postponedImplicit postponedHO)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
LightDiagram.diagram | Mathlib.Topology.Category.LightProfinite.Basic | LightDiagram → CategoryTheory.Functor ℕᵒᵖ FintypeCat | The indexing diagram. | true |
Matrix.toLin_finTwoProd_toContinuousLinearMap | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] [inst : CompleteSpace 𝕜] (a b c d : 𝕜),
LinearMap.toContinuousLinearMap
((Matrix.toLin (Module.Basis.finTwoProd 𝕜) (Module.Basis.finTwoProd 𝕜)) !![a, b; c, d]) =
(a • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + b • ContinuousLinearMap.snd 𝕜 𝕜 𝕜).prod
... | null | true |
_private.Mathlib.LinearAlgebra.TensorAlgebra.Basic.0.instSMulCommClassTensorAlgebra._proof_1 | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_4} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : AddCommMonoid M] [inst_3 : CommSemiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A]
[inst_6 : Module R M] [inst_7 : Module S M] [inst_8 : Module A M] [inst_9 : IsScalarTower R A M]
[inst_... | null | false |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.doubling_lt_golden_ratio._simp_1_21 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
Int16.toBitVec_add | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a + b).toBitVec = a.toBitVec + b.toBitVec | null | true |
DifferentiableAt.smul_const | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
{𝕜' : Type u_5} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module 𝕜' F] [IsBo... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtractAndExtend.go._unary._proof_5 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | ∀ {w : ℕ} (idx : ℕ), w * (idx + 1) = w * idx + w → w * idx + w = w * (idx + 1) | null | false |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.tilted_tilted._simp_1_3 | Mathlib.MeasureTheory.Measure.Tilted | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
MatrixEquivTensor.toFunAlgHom._proof_3 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_1) (R : Type u_3) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : DecidableEq n] [inst_4 : Fintype n], (MatrixEquivTensor.toFunLinear n R A) (1 ⊗ₜ[R] 1) = 1 | null | false |
InitialSeg.mem_range_of_rel' | Mathlib.Order.InitialSeg | ∀ {α : Type u_4} {β : Type u_5} {r : α → α → Prop} {s : β → β → Prop} (self : InitialSeg r s) (a : α) (b : β),
s b (self.toRelEmbedding a) → b ∈ Set.range ⇑self.toRelEmbedding | The order embedding is an initial segment | true |
Std.DHashMap.Internal.List.HashesTo.mk | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {l : List ((a : α) × β a)} {i size : ℕ},
(∀ (h : 0 < size), ∀ p ∈ l, (↑(Std.DHashMap.Internal.mkIdx size h (hash p.fst))).toNat = i) →
Std.DHashMap.Internal.List.HashesTo l i size | null | true |
Std.DHashMap.Raw.Const.getD_of_isEmpty | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {a : α} {fallback : β}, m.isEmpty = true → Std.DHashMap.Raw.Const.getD m a fallback = fallback | null | true |
MonCat.instConcreteCategoryMonoidHomCarrier._proof_1 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : MonCat} (f : ↑X →* ↑Y), { hom' := f }.hom' = f | null | false |
_private.Mathlib.RingTheory.Polynomial.SmallDegreeVieta.0.Polynomial.eq_quadratic_of_degree_le_two._abel_1_1 | Mathlib.RingTheory.Polynomial.SmallDegreeVieta | ∀ {R : Type u_1} [inst : Semiring R] {p : Polynomial R},
Polynomial.C (p.coeff 0) + Polynomial.C (p.coeff 1) * Polynomial.X + Polynomial.C (p.coeff 2) * Polynomial.X ^ 2 =
Polynomial.C (p.coeff 2) * Polynomial.X ^ 2 + Polynomial.C (p.coeff 1) * Polynomial.X + Polynomial.C (p.coeff 0) | null | false |
CategoryTheory.PullbackShift.adjunction_counit | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] [inst_3 : CategoryTheory.HasShift C B] (φ : A →+ B) {D : Type u_4}
[inst_4 : CategoryTheory.Category.{v_2, u_4} D] [inst_5 : CategoryTheory.HasShift D B]
{F : CategoryTheory.F... | null | true |
CategoryTheory.SmallObject.FunctorObjIndex.comm_assoc | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X : C}
(πX : X ⟶ S)
[inst_1 :
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX))
C]
[inst_2 :
CategoryTheory.Limits.HasPu... | null | true |
ContinuousLinearMap.IsIdempotentElem.ext | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Idempotent | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p q : M →L[R] M},
IsIdempotentElem p → IsIdempotentElem q → (↑p).range = (↑q).range ∧ (↑p).ker = (↑q).ker → p = q | **Alias** of the reverse direction of `ContinuousLinearMap.IsIdempotentElem.ext_iff`.
---
Idempotent operators are equal iff their range and kernels are. | true |
SemilinearMapClass.mk._flat_ctor | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {F : Type u_14} {R : outParam (Type u_15)} {S : outParam (Type u_16)} [inst : Semiring R] [inst_1 : Semiring S]
{σ : outParam (R →+* S)} {M : outParam (Type u_17)} {M₂ : outParam (Type u_18)} [inst_2 : AddCommMonoid M]
[inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module S M₂] [inst_6 : FunLike F M ... | null | false |
RootPairing.IsRootSystem.ext | Mathlib.LinearAlgebra.RootSystem.Basic | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] [Finite ι] [CharZero R] [IsDomain R]
[Module.IsTorsionFree R M] {P₁ P₂ : RootPairing ι R M N} [P₁.IsRootSystem] [P₂.IsRootSystem],
P₁.to... | In characteristic zero if there is no torsion, a finite root system is determined entirely by
its roots. | true |
_private.Mathlib.RingTheory.MvPowerSeries.Order.0.MvPowerSeries.le_weightedOrder._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ}, (↑m < ↑n) = (m < n) | null | false |
Pi.cancelMonoid._proof_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → CancelMonoid (f i)], IsRightCancelMul ((i : I) → f i) | null | false |
ULift.forall | Mathlib.Data.ULift | ∀ {α : Type u} {p : ULift.{u_1, u} α → Prop}, (∀ (x : ULift.{u_1, u} α), p x) ↔ ∀ (x : α), p { down := x } | null | true |
MonoidHom.smulOneHom | Mathlib.Algebra.Group.Action.Hom | {M : Type u_4} →
{N : Type u_5} →
[inst : Monoid M] → [inst_1 : MulOneClass N] → [inst_2 : MulAction M N] → [IsScalarTower M N N] → M →* N | If the multiplicative action of `M` on `N` is compatible with multiplication on `N`, then
`fun x ↦ x • 1` is a monoid homomorphism from `M` to `N`. | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.Action.hugeNumber | Lean.Meta.Tactic.Grind.Intro | ℕ | null | true |
Lean.Macro.State | Init.Prelude | Type | The mutable state for the `MacroM` monad. | true |
TopPair.HomologyPretheory.hFunctor._proof_4 | Mathlib.AlgebraicTopology.EilenbergSteenrod | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_4} {c : ComplexShape ι} (i : ι) {X Y Z : TopPair.HomologyPretheory C c} (f : X ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).hom i = CategoryTheory.CategoryStruct.comp (f.hom i... | null | false |
List.perm_reverse | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Perm l₂.reverse ↔ l₁.Perm l₂ | null | true |
CategoryTheory.Limits.PreservesPullback.iso_hom_fst | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullb... | null | true |
Lean.Meta.withLetDecl | Lean.Meta.Basic | {n : Type → Type u_1} →
[MonadControlT Lean.MetaM n] →
[Monad n] →
{α : Type} →
Lean.Name →
Lean.Expr →
Lean.Expr →
(Lean.Expr → n α) → optParam Bool false → optParam Lean.LocalDeclKind Lean.LocalDeclKind.default → n α | Add the local declaration `<name> : <type> := <val>` to the local context and execute `k x`, where `x` is a new
free variable corresponding to the `let`-declaration. After executing `k x`, the local context is restored.
| true |
InnerProductGeometry.cos_angle | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
Real.cos (InnerProductGeometry.angle x y) = inner ℝ x y / (‖x‖ * ‖y‖) | The cosine of the angle between two vectors. | true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.ofDigits_lt_base_pow_length'._simp_1_4 | Mathlib.Data.Nat.Digits.Defs | ∀ (n : ℕ), (0 ≤ n) = True | null | false |
Lean.Meta.KExprMap.rec | Lean.Meta.KExprMap | {α : Type} →
{motive : Lean.Meta.KExprMap α → Sort u} →
((map : Lean.PHashMap Lean.HeadIndex (Lean.AssocList Lean.Expr α)) → motive { map := map }) →
(t : Lean.Meta.KExprMap α) → motive t | null | false |
WithBot.giUnbotDBot | Mathlib.Order.GaloisConnection.Basic | {α : Type u} → [inst : Preorder α] → [inst_1 : OrderBot α] → GaloisInsertion (WithBot.unbotD ⊥) WithBot.some | If `α` is a partial order with bottom element (e.g., `ℕ`, `ℝ≥0`), then `WithBot.unbot' ⊥` and
coercion form a Galois insertion. | true |
Submodule.orderIsoMapComap_apply' | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{τ₂₁ : R₂ →+* R} [inst_6 : RingHomInvPair τ₁₂ τ₂₁] [inst_7 : RingHomInvPair τ₂₁ τ₁₂] (e : M... | null | true |
AddSubmonoid.isAddCommutative_closure | Mathlib.GroupTheory.Submonoid.Centralizer | ∀ (M : Type u_1) [inst : AddMonoid M] {s : Set M},
(∀ a ∈ s, ∀ b ∈ s, a + b = b + a) → IsAddCommutative ↥(AddSubmonoid.closure s) | If all the elements of a set `s` commute, then `closure s` forms an additive
commutative monoid. | true |
Lean.ImportM.Context.noConfusionType | Lean.Environment | Sort u → Lean.ImportM.Context → Lean.ImportM.Context → Sort u | null | false |
CategoryTheory.EnrichedCat.bicategory._proof_3 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c : CategoryTheory.EnrichedCat V} {f g : CategoryTheory.EnrichedFunctor V ↑a ↑b}
{h i : CategoryTheory.EnrichedFunctor V ↑b ↑c} (α : f ⟶ g) (β : h ⟶ i),
CategoryTheory.CategoryStruct.comp (CategoryTheo... | null | false |
DFinsupp.linearEquivFunOnFintype | Mathlib.LinearAlgebra.DFinsupp | {ι : Type u_1} →
{R : Type u_3} →
{M : ι → Type u_5} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M i)] →
[inst_2 : (i : ι) → Module R (M i)] → [Fintype ι] → (Π₀ (i : ι), M i) ≃ₗ[R] (i : ι) → M i | `DFinsupp.equivFunOnFintype` as a linear equivalence.
This is the `DFinsupp` version of `Finsupp.linearEquivFunOnFintype`. | true |
UInt16.toUInt32_and | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a &&& b).toUInt32 = a.toUInt32 &&& b.toUInt32 | null | true |
Lean.Grind.instToIntIntIi._proof_2 | Init.GrindInstances.ToInt | ∀ (x : ℤ), id x ∈ Lean.Grind.IntInterval.ii | null | false |
IsStronglyCoatomic.of_wellFounded_gt | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α], (WellFounded fun x1 x2 => x1 > x2) → IsStronglyCoatomic α | null | true |
SimpleGraph.Walk.isHamiltonianCycle_iff_isCycle_and_support_count_tail_eq_one | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a},
p.IsHamiltonianCycle ↔ p.IsCycle ∧ ∀ (a_1 : α), List.count a_1 p.support.tail = 1 | null | true |
aestronglyMeasurable_iff_aemeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : MeasurableSpace β] [TopologicalSpace.PseudoMetrizableSpace β] [BorelSpace β]
[SecondCountableTopology β], MeasureTheory.AEStronglyMeasurable f μ ↔ AEMeasurable f μ | In a space with second countable topology, strongly measurable and measurable are equivalent. | true |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.brecOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive : Lean.Meta.Grind.Arith.CommRing.PolyDerivation → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
((t : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.below t → motive t) →
motive t | null | false |
IsUnit.finset | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] {a : α}, IsUnit a → IsUnit {a} | null | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage._proof_1_10 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] {a b c : ι} (hbc : b ≤ c) (w : ι) (w_1 : a < w)
(w_2 : w ≤ b), w ≤ b → ↑⟨w, ⋯⟩ ∈ Finset.Ioc a b | null | false |
_private.Mathlib.Analysis.Convex.Segment.0.insert_endpoints_openSegment._simp_1_1 | Mathlib.Analysis.Convex.Segment | ∀ {α : Type u} [inst : HasSubset α] {a b : α} [Std.Refl fun x1 x2 => x1 ⊆ x2] [Std.Antisymm fun x1 x2 => x1 ⊆ x2],
(a = b) = (a ⊆ b ∧ b ⊆ a) | null | false |
MeasureTheory.AEStronglyMeasurable.add_const | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : Add β] [ContinuousAdd β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (c : β), MeasureTheory.AEStronglyMeasurable (fun x => f x + c) μ | null | true |
contDiffWithinAt_const | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {x : E}
{n : WithTop ℕ∞} {c : F}, ContDiffWithinAt 𝕜 n (fun x => c) s x | null | true |
_private.Init.Data.String.Lemmas.Basic.0.String.Slice.slice_eq_self_iff._simp_1_3 | Init.Data.String.Lemmas.Basic | ∀ {s : String} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
MeasureTheory.measure_inter_add_sdiff | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {t : Set α} (s : Set α),
MeasurableSet t → μ (s ∩ t) + μ (s \ t) = μ s | null | true |
Nat.cast_succ | Mathlib.Data.Nat.Cast.Defs | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (n : ℕ), ↑n.succ = ↑n + 1 | null | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.mkCoe.match_1 | Lean.Elab.Term.TermElabM | (motive : Lean.LOption (Lean.Expr × List Lean.Name) → Sort u_1) →
(__do_lift : Lean.LOption (Lean.Expr × List Lean.Name)) →
((eNew : Lean.Expr) → (expandedCoeDecls : List Lean.Name) → motive (Lean.LOption.some (eNew, expandedCoeDecls))) →
(Unit → motive Lean.LOption.none) → (Unit → motive Lean.LOption.undef... | null | false |
Monoid.PushoutI.hom_ext_iff | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} {K : Type u_4} [inst : Monoid K] [inst_1 : (i : ι) → Monoid (G i)]
[inst_2 : Monoid H] {φ : (i : ι) → H →* G i} {f g : Monoid.PushoutI φ →* K},
f = g ↔
(∀ (i : ι), f.comp (Monoid.PushoutI.of i) = g.comp (Monoid.PushoutI.of i)) ∧
f.comp (Monoid.PushoutI.ba... | null | true |
List.decidableSortedGE | Mathlib.Data.List.Sort | {α : Type u_1} → [inst : Preorder α] → [DecidableLE α] → DecidablePred List.SortedGE | null | true |
_private.Aesop.Nanos.0.Aesop.instBEqNanos.beq.match_1 | Aesop.Nanos | (motive : Aesop.Nanos → Aesop.Nanos → Sort u_1) →
(x x_1 : Aesop.Nanos) →
((a b : ℕ) → motive { nanos := a } { nanos := b }) → ((x x_2 : Aesop.Nanos) → motive x x_2) → motive x x_1 | null | false |
SimpleGraph._aux_Mathlib_Combinatorics_SimpleGraph_Copy___unexpand_SimpleGraph_IsIndContained_1 | Mathlib.Combinatorics.SimpleGraph.Copy | Lean.PrettyPrinter.Unexpander | null | false |
HXor.mk.noConfusion | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : outParam (Type w)} →
{P : Sort u_1} → {hXor hXor' : α → β → γ} → { hXor := hXor } = { hXor := hXor' } → (hXor ≍ hXor' → P) → P | null | false |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_of_two_pow_le_and_two_pow_add_one_gt._proof_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ {n : ℕ} {i : ℕ}, ∀ i' ≥ i, ¬i = i' → ¬i + 1 ≤ i' → False | null | false |
CategoryTheory.MonObj.pow_comp | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N X : C} [inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] (f : X ⟶ M) (n : ℕ) (g : M ⟶ N)
[CategoryTheory.IsMonHom g], CategoryTheory.CategoryStruct.comp (f ^ n) g = CategoryThe... | null | true |
_private.Init.Data.List.Sort.Basic.0.List.merge.match_1 | Init.Data.List.Sort.Basic | {α : Type u_1} →
(motive : List α → List α → Sort u_2) →
(xs ys : List α) →
((ys : List α) → motive [] ys) →
((xs : List α) → motive xs []) →
((x : α) → (xs : List α) → (y : α) → (ys : List α) → motive (x :: xs) (y :: ys)) → motive xs ys | null | false |
Subgroup.descending_central_series_ge_lower | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] (H : ℕ → Subgroup G),
Subgroup.IsDescendingCentralSeries H → ∀ (n : ℕ), ⊤.lowerCentralSeries n ≤ H n | Any descending central series for a group is bounded below by the lower central series. | true |
Polynomial.contentIdeal_le_span_content | Mathlib.RingTheory.Polynomial.ContentIdeal | ∀ {R : Type u_3} [inst : CommRing R] [inst_1 : NormalizedGCDMonoid R] {p : Polynomial R},
p.contentIdeal ≤ Ideal.span {p.content} | null | true |
Mathlib.Tactic.LibraryRewrite.Kind.hypothesis.sizeOf_spec | Mathlib.Tactic.Widget.LibraryRewrite | sizeOf Mathlib.Tactic.LibraryRewrite.Kind.hypothesis = 1 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.mem_of_mem_insertMany_list._simp_1_1 | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.