name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Data.List.Basic.0.List.mem_getLast?_eq_getLast._proof_1_14 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (a b : α) (l : List α), ¬(a :: b :: l).length - 1 = 0 → (a :: b :: l).length - 2 < (b :: l).length |
Ring.KrullDimLE.subsingleton_primeSpectrum | Mathlib.RingTheory.KrullDimension.Zero | ∀ (R : Type u_1) [inst : CommSemiring R] [Ring.KrullDimLE 0 R] [IsLocalRing R], Subsingleton (PrimeSpectrum R) |
id_tensor_π_preserves_coequalizer_inv_colimMap_desc | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
{X Y Z X' Y' Z' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : CategoryTheory.MonoidalCategoryStruct.tensorObj Z X ⟶ X')
(q : CategoryTheory.MonoidalCategoryStruct.tensorObj Z Y ⟶ Y')
(wf :
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z f) q =
CategoryTheory.CategoryStruct.comp p f')
(wg :
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z g) q =
CategoryTheory.CategoryStruct.comp p g')
(h : Y' ⟶ Z') (wh : CategoryTheory.CategoryStruct.comp f' h = CategoryTheory.CategoryStruct.comp g' h),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z (CategoryTheory.Limits.coequalizer.π f g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorLeft Z) f g).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimMap
(CategoryTheory.Limits.parallelPairHom (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z f)
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z g) f' g' p q wf wg))
(CategoryTheory.Limits.coequalizer.desc h wh))) =
CategoryTheory.CategoryStruct.comp q h |
EReal.top_ne_coe._simp_1 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), (⊤ = ↑x) = False |
_private.Lean.Compiler.LCNF.Internalize.0.Lean.Compiler.LCNF.Internalize.internalizeCodeDecl.match_4 | Lean.Compiler.LCNF.Internalize | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u_1) →
(decl : Lean.Compiler.LCNF.CodeDecl pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.let decl)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.CodeDecl.fun decl h)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.jp decl)) →
((fvarId : Lean.FVarId) →
(i : ℕ) →
(y : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.uset fvarId i y h)) →
((fvarId : Lean.FVarId) →
(i offset : ℕ) →
(y : Lean.FVarId) →
(ty : Lean.Expr) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.sset fvarId i offset y ty h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check offset : Bool) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.inc fvarId n check offset h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check offset : Bool) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.dec fvarId n check offset h)) →
motive decl |
Subsemiring.coe_prod._simp_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (s : Subsemiring R)
(t : Subsemiring S), ↑s ×ˢ ↑t = ↑(s.prod t) |
QuadraticMap.zeroHomClass | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], ZeroHomClass (QuadraticMap R M N) M N |
Std.DTreeMap.Internal.Impl.balanceL!_pair_congr | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {k' : α} {v' : β k'},
⟨k, v⟩ = ⟨k', v'⟩ →
∀ {l l' r r' : Std.DTreeMap.Internal.Impl α β},
l = l' → r = r' → Std.DTreeMap.Internal.Impl.balanceL! k v l r = Std.DTreeMap.Internal.Impl.balanceL! k' v' l' r' |
Module.mapEvalEquiv | Mathlib.LinearAlgebra.Dual.Defs | (R : Type u_3) →
(M : Type u_4) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[Module.IsReflexive R M] → Submodule R M ≃o Submodule R (Module.Dual R (Module.Dual R M)) |
SimplexCategory.δ_comp_σ_of_le | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)},
i ≤ j.castSucc →
CategoryTheory.CategoryStruct.comp (SimplexCategory.δ i.castSucc) (SimplexCategory.σ j.succ) =
CategoryTheory.CategoryStruct.comp (SimplexCategory.σ j) (SimplexCategory.δ i) |
_private.Mathlib.Algebra.Polynomial.UnitTrinomial.0.Polynomial.isUnitTrinomial_iff'._simp_1_1 | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (n : ℕ), ↑a ^ n = ↑(a ^ n) |
Polynomial.SplittingField.instCharZero | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type v} [inst : Field K] (f : Polynomial K) [CharZero K], CharZero f.SplittingField |
_private.Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean.0.NNReal.bddAbove_range_agmSequences_fst._simp_1_3 | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), f a = b → p b) = ∀ (a : α), p (f a) |
FreeGroup.isReduced_iff_reduce_eq | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} {L : List (α × Bool)} [inst : DecidableEq α], FreeGroup.IsReduced L ↔ FreeGroup.reduce L = L |
instLTBitVec | Init.Prelude | {w : ℕ} → LT (BitVec w) |
PMF.uniformOfFintype_apply | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Nonempty α] (a : α), (PMF.uniformOfFintype α) a = (↑(Fintype.card α))⁻¹ |
ciSup_eq_ite | Mathlib.Order.ConditionallyCompletePartialOrder.Indexed | ∀ {α : Type u_1} [inst : ConditionallyCompletePartialOrderSup α] {p : Prop} [inst_1 : Decidable p] {f : p → α},
⨆ (h : p), f h = if h : p then f h else sSup ∅ |
_private.Mathlib.GroupTheory.Perm.Finite.0.Equiv.Perm.disjoint_support_closure_of_disjoint_support._simp_1_2 | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u_1} {t : Set α} {ι : Sort u_12} {s : ι → Set α}, Disjoint t (⋃ i, s i) = ∀ (i : ι), Disjoint t (s i) |
Pi.mulSingle_le_mulSingle._gcongr_3 | Mathlib.Algebra.Order.Pi | ∀ {ι : Type u_6} {α : ι → Type u_7} [inst : DecidableEq ι] [inst_1 : (i : ι) → One (α i)]
[inst_2 : (i : ι) → Preorder (α i)] {i : ι} {a b : α i}, a ≤ b → Pi.mulSingle i a ≤ Pi.mulSingle i b |
ISize.toInt_maxValue | Init.Data.SInt.Lemmas | ISize.maxValue.toInt = 2 ^ (System.Platform.numBits - 1) - 1 |
_private.Mathlib.Tactic.Find.0.Mathlib.Tactic.Find.matchHyps | Mathlib.Tactic.Find | List Lean.Expr → List Lean.Expr → List Lean.Expr → Lean.MetaM Bool |
LaurentSeries.val_le_one_iff_eq_coe | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (f : LaurentSeries K), Valued.v f ≤ 1 ↔ ∃ F, (HahnSeries.ofPowerSeries ℤ K) F = f |
Lean.Lsp.DiagnosticCode | Lean.Data.Lsp.Diagnostics | Type |
Ordnode.eraseMin._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Ordnode α |
UpperSet.coe_nonempty | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s : UpperSet α}, (↑s).Nonempty ↔ s ≠ ⊤ |
_private.Mathlib.RingTheory.Lasker.0.Submodule.IsMinimalPrimaryDecomposition.comap_localized₀_eq_ite._simp_1_9 | Mathlib.RingTheory.Lasker | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] {f : M →ₗ[R] M'}
[inst_5 : IsLocalizedModule S f] {m : M} {s : ↥S} {m' : M'}, (IsLocalizedModule.mk' f m s = m') = (f m = s • m') |
_private.Lean.Meta.Tactic.Cbv.Util.0.Lean.Meta.Tactic.Cbv.isBitVecValue | Lean.Meta.Tactic.Cbv.Util | Lean.Expr → Bool |
ContinuousMap.instRegularSpace | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [RegularSpace Y],
RegularSpace C(X, Y) |
Std.IterM.Partial.it | Init.Data.Iterators.Consumers.Monadic.Partial | {α : Type w} → {m : Type w → Type w'} → {β : Type w} → Std.IterM.Partial m β → Std.IterM m β |
AlgebraicTopology.DoldKan.Γ₀.Obj.map._proof_1 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {Δ' Δ : SimplexCategoryᵒᵖ} (θ : Δ ⟶ Δ') (A : SimplicialObject.Splitting.IndexSet Δ),
CategoryTheory.Limits.HasImage (CategoryTheory.CategoryStruct.comp θ.unop A.e) |
Algebra.TensorProduct.tensorQuotientEquiv_symm_apply_tmul | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {R : Type u_1} (S : Type u_2) (T : Type u_3) (A : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : CommRing A] [inst_6 : Algebra R A]
[inst_7 : Algebra S A] [inst_8 : IsScalarTower R S A] (I : Ideal T) (a : A) (t : T),
(Algebra.TensorProduct.tensorQuotientEquiv S T A I).symm
((Ideal.Quotient.mk (Ideal.map Algebra.TensorProduct.includeRight I)) (a ⊗ₜ[R] t)) =
a ⊗ₜ[R] (Ideal.Quotient.mk I) t |
Std.ExtTreeMap.union_insert_right_eq_insert_union | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{p : (_ : α) × β}, t₁ ∪ t₂.insert p.fst p.snd = (t₁ ∪ t₂).insert p.fst p.snd |
String.Slice.Pattern.Model.IsValidSearchFrom.mismatched_of_eq | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.ForwardPatternModel pat] {s : String.Slice}
{startPos startPos' endPos : s.Pos} {l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidSearchFrom pat endPos l →
startPos' < endPos →
(∀ (pos : s.Pos), startPos' ≤ pos → pos < endPos → ¬String.Slice.Pattern.Model.MatchesAt pat pos) →
startPos = startPos' →
String.Slice.Pattern.Model.IsValidSearchFrom pat startPos'
(String.Slice.Pattern.SearchStep.rejected startPos endPos :: l) |
Std.ExtDHashMap.mem_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, k' ∈ m.modify k f ↔ k' ∈ m |
CategoryTheory.MonoidalCategory.whiskerLeftIso_trans | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (W : C)
{X Y Z : C} (f : X ≅ Y) (g : Y ≅ Z),
CategoryTheory.MonoidalCategory.whiskerLeftIso W (f ≪≫ g) =
CategoryTheory.MonoidalCategory.whiskerLeftIso W f ≪≫ CategoryTheory.MonoidalCategory.whiskerLeftIso W g |
List.isEmpty_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, xs.reverse.isEmpty = xs.isEmpty |
Std.TreeSet.Raw.insertMany_list_equiv_foldl | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ : Std.TreeSet.Raw α cmp} {l : List α},
(t₁.insertMany l).Equiv (List.foldl (fun acc a => acc.insert a) t₁ l) |
CategoryTheory.ComposableArrows.homMkSucc | Mathlib.CategoryTheory.ComposableArrows.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{n : ℕ} →
{F G : CategoryTheory.ComposableArrows C (n + 1)} →
(α : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) →
(β : F.δ₀ ⟶ G.δ₀) →
CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheory.ComposableArrows.app' β 0 ⋯) =
CategoryTheory.CategoryStruct.comp α (G.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯) →
(F ⟶ G) |
_private.Mathlib.LinearAlgebra.Projection.0.LinearMap.IsIdempotentElem.commute_iff_of_isUnit._simp_1_4 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {f : M ≃ₗ[R] M}
{p : Submodule R M}, (p ≤ Submodule.map (↑f) p) = (p ∈ Module.End.invtSubmodule ↑f.symm) |
Ideal.quotientEquivDirectSum | Mathlib.LinearAlgebra.FreeModule.IdealQuotient | {ι : Type u_1} →
{R : Type u_2} →
{S : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : IsDomain R] →
[inst_4 : IsPrincipalIdealRing R] →
[inst_5 : IsDomain S] →
[inst_6 : Finite ι] →
(F : Type u_4) →
[inst_7 : CommRing F] →
[inst_8 : Algebra F R] →
[inst_9 : Algebra F S] →
[IsScalarTower F R S] →
(b : Module.Basis ι R S) →
{I : Ideal S} →
(hI : I ≠ ⊥) →
(S ⧸ I) ≃ₗ[F] DirectSum ι fun i => R ⧸ Ideal.span {Ideal.smithCoeffs b I hI i} |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.logUnassignedUsingErrorInfos.match_1 | Lean.Elab.Term.TermElabM | (motive : MProd Lean.MVarIdSet (MProd (Array Lean.Elab.Term.MVarErrorInfo) Bool) → Sort u_1) →
(r : MProd Lean.MVarIdSet (MProd (Array Lean.Elab.Term.MVarErrorInfo) Bool)) →
((alreadyVisited : Lean.MVarIdSet) →
(errors : Array Lean.Elab.Term.MVarErrorInfo) →
(hasNewErrors : Bool) → motive ⟨alreadyVisited, errors, hasNewErrors⟩) →
motive r |
CategoryTheory.Functor.DenseAt.ofIso | Mathlib.CategoryTheory.Functor.KanExtension.DenseAt | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} → {Y : D} → F.DenseAt Y → {Y' : D} → (Y ≅ Y') → F.DenseAt Y' |
Option.merge.eq_4 | Init.Omega.Constraint | ∀ {α : Type u_1} (fn : α → α → α) (x_2 y : α), Option.merge fn (some x_2) (some y) = some (fn x_2 y) |
Lean.Server.RequestCancellation._sizeOf_1 | Lean.Server.RequestCancellation | Lean.Server.RequestCancellation → ℕ |
SemiRingCat.FilteredColimits.colimitCoconeIsColimit._proof_2 | Mathlib.Algebra.Category.Ring.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : CategoryTheory.IsFiltered J] (t : CategoryTheory.Limits.Cocone F),
(SemiRingCat.FilteredColimits.colimitCoconeIsColimit.descAddMonoidHom t) 1 = 1 |
ContinuousLinearEquiv.equivLike._proof_1 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_3} {R₂ : Type u_4} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_1} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_2} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
[inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (f g : M₁ ≃SL[σ₁₂] M₂),
(↑f.toLinearEquiv).toFun = (↑g.toLinearEquiv).toFun → f.invFun = g.invFun → f = g |
Lean.FindLevelMVar.main._unsafe_rec | Lean.Util.FindLevelMVar | (Lean.LMVarId → Bool) → Lean.Expr → Lean.FindLevelMVar.Visitor |
CategoryTheory.Enriched.FunctorCategory.homEquiv_apply_π_assoc | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} C] {J : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] {F₁ F₂ : CategoryTheory.Functor J C}
[inst_5 : CategoryTheory.Enriched.FunctorCategory.HasEnrichedHom V F₁ F₂] (τ : F₁ ⟶ F₂) (j : J) {Z : V}
(h : (F₁.obj j ⟶[V] F₂.obj j) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Enriched.FunctorCategory.homEquiv V) τ)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Enriched.FunctorCategory.enrichedHomπ V F₁ F₂ j) h) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.eHomEquiv V) (τ.app j)) h |
FirstCountableTopology.frechetUrysohnSpace | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] [FirstCountableTopology X], FrechetUrysohnSpace X |
Int.cast_le_neg_one_of_neg | Mathlib.Algebra.Order.Ring.Cast | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : ℤ}, a < 0 → ↑a ≤ -1 |
WithZero.instAddMonoidWithOne | Mathlib.Algebra.GroupWithZero.WithZero | {α : Type u_1} → [AddMonoidWithOne α] → AddMonoidWithOne (WithZero α) |
lt_of_mul_self_lt_mul_self₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a b : M₀} [MulPosMono M₀],
0 ≤ b → a * a < b * b → a < b |
Module.piEquiv | Mathlib.LinearAlgebra.StdBasis | (ι : Type u_1) →
(R : Type u_2) →
(M : Type u_3) →
[Finite ι] →
[inst : CommSemiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (ι → M) ≃ₗ[R] (ι → R) →ₗ[R] M |
Orientation.rotationAux._proof_1 | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (θ : Real.Angle) (x y : V),
inner ℝ ((θ.cos • LinearMap.id + θ.sin • ↑o.rightAngleRotation.toLinearEquiv) x)
((θ.cos • LinearMap.id + θ.sin • ↑o.rightAngleRotation.toLinearEquiv) y) =
inner ℝ x y |
Valuation.RankLeOne.mk._flat_ctor | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Ring R] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation R Γ₀} → (hom' : MonoidWithZeroHom.ValueGroup₀ v →*₀ NNReal) → StrictMono ⇑hom' → v.RankLeOne |
ContinuousLinearMap.bilinear_hasTemperateGrowth | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {𝕜 : Type u_2} {D : Type u_4} {E : Type u_5} {F : Type u_6} {G : Type u_7} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F]
[inst_4 : NontriviallyNormedField 𝕜] [NormedAlgebra ℝ 𝕜] [inst_6 : NormedAddCommGroup D] [inst_7 : NormedSpace ℝ D]
[inst_8 : NormedAddCommGroup G] [inst_9 : NormedSpace ℝ G] [inst_10 : NormedSpace 𝕜 F] [inst_11 : NormedSpace 𝕜 G]
[inst_12 : NormedSpace 𝕜 E] (B : E →L[𝕜] F →L[𝕜] G) {f : D → E} {g : D → F},
Function.HasTemperateGrowth f → Function.HasTemperateGrowth g → Function.HasTemperateGrowth fun x => (B (f x)) (g x) |
_private.Mathlib.Data.List.NodupEquivFin.0.List.sublist_iff_exists_orderEmbedding_getElem?_eq._simp_1_1 | Mathlib.Data.List.NodupEquivFin | ∀ {a b : ℕ}, (a.succ ≤ b.succ) = (a ≤ b) |
Lean.Grind.ToInt.toInt.eq_1 | Init.GrindInstances.ToInt | ∀ (α : Type u) {range : Lean.Grind.IntInterval} [self : Lean.Grind.ToInt α range], Lean.Grind.ToInt.toInt = self.1 |
Lean.Meta.Try.Collector.OrdSet.set | Lean.Meta.Tactic.Try.Collect | {α : Type} → [inst : Hashable α] → [inst_1 : BEq α] → Lean.Meta.Try.Collector.OrdSet α → Std.HashSet α |
_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.hasProd_fintype_support._simp_1_1 | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i |
hasStrictDerivAt_abs | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ {x : ℝ}, x ≠ 0 → HasStrictDerivAt (fun x => |x|) (↑(SignType.sign x)) x |
DistribSMul.toAddMonoidHom_eq_zsmulAddGroupHom | Mathlib.Algebra.Module.NatInt | ∀ (M : Type u_3) [inst : AddCommGroup M], DistribSMul.toAddMonoidHom M = zsmulAddGroupHom |
Fin.dfoldrM.loop._sunfold | Batteries.Data.Fin.Basic | {m : Type u_1 → Type u_2} →
[Monad m] →
(n : ℕ) →
(α : Fin (n + 1) → Type u_1) →
((i : Fin n) → α i.succ → m (α i.castSucc)) → (i : ℕ) → (h : i < n + 1) → α ⟨i, h⟩ → m (α 0) |
CategoryTheory.Functor.sheafInducedTopologyEquivOfIsCoverDense._proof_2 | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_6, u_3} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] (G : CategoryTheory.Functor C D)
(K : CategoryTheory.GrothendieckTopology D) (A : Type u_5) [inst_2 : CategoryTheory.Category.{u_2, u_5} A]
[inst_3 : G.LocallyCoverDense K] [inst_4 : G.IsLocallyFull K] [inst_5 : G.IsLocallyFaithful K]
[inst_6 : G.IsCoverDense K]
[∀ (X : Dᵒᵖ), CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.StructuredArrow X G.op) A],
(G.sheafPushforwardContinuous A (G.inducedTopology K) K).IsEquivalence |
matPolyEquiv_symm_map_eval | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type w} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
(M : Polynomial (Matrix n n R)) (r : R),
(matPolyEquiv.symm M).map (Polynomial.eval r) = Polynomial.eval ((Matrix.scalar n) r) M |
StdSimplex.join._proof_2 | Mathlib.LinearAlgebra.ConvexSpace | ∀ {R : Type u_1} [inst : PartialOrder R] [inst_1 : Semiring R] {M : Type u_2} [IsStrictOrderedRing R]
(f : StdSimplex R (StdSimplex R M)), 0 ≤ f.sum fun d r => r • d.weights |
MonoidWithZero.toOppositeMulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | (M₀ : Type u_2) → [inst : MonoidWithZero M₀] → MulActionWithZero M₀ᵐᵒᵖ M₀ |
Module.Basis.dualBasis_coord_toDualEquiv_apply | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) [inst_4 : Finite ι] (i : ι) (f : M),
(b.dualBasis.coord i) (b.toDualEquiv f) = (b.coord i) f |
Lean.Parser.Module.module.formatter | Lean.Parser.Module | Lean.PrettyPrinter.Formatter |
Module.Basis.noConfusionType | Mathlib.LinearAlgebra.Basis.Defs | Sort u →
{ι : Type u_1} →
{R : Type u_3} →
{M : Type u_6} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
Module.Basis ι R M →
{ι' : Type u_1} →
{R' : Type u_3} →
{M' : Type u_6} →
[inst' : Semiring R'] →
[inst'_1 : AddCommMonoid M'] → [inst'_2 : Module R' M'] → Module.Basis ι' R' M' → Sort u |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.minKey!_eq._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) |
Std.Internal.List.getValueCast_alterKey._proof_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (k k' : α) (f : Option (β k) → Option (β k))
(l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k' (Std.Internal.List.alterKey k f l) = true →
(k == k') = true → (f (Std.Internal.List.getValueCast? k l)).isSome = true |
_private.Mathlib.LinearAlgebra.Matrix.Transvection.0.Matrix.Pivot.reindex_exists_list_transvec_mul_mul_list_transvec_eq_diagonal._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_11) (A : Type u_12) [inst : CommSemiring R] [inst_1 : Fintype n]
[inst_2 : Fintype m] [inst_3 : DecidableEq m] [inst_4 : DecidableEq n] [inst_5 : Semiring A] [inst_6 : Algebra R A]
(e : m ≃ n) (M N : Matrix m m A),
(Matrix.reindexAlgEquiv R A e) M * (Matrix.reindexAlgEquiv R A e) N = (Matrix.reindexAlgEquiv R A e) (M * N) |
RingQuot.instSemiring._proof_14 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop) (a : RingQuot r), a * 1 = a |
Colex.instSMul'.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {x : Type u_2} {x_1 : Type u_1} [h : SMul x x_1], Colex.instSMul' = h |
Batteries.RBNode.Balanced.nil | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1}, Batteries.RBNode.nil.Balanced Batteries.RBColor.black 0 |
_private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.asiegel.eq_1 | Mathlib.NumberTheory.NumberField.House | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {α : Type u_2} {β : Type u_3}
(a : Matrix α β (NumberField.RingOfIntegers K)) (k : α × (K →+* ℂ)) (l : β × (K →+* ℂ)),
NumberField.house.asiegel✝ K a k l = NumberField.house.a'✝ K a k.1 l.1 l.2 k.2 |
Con.congr.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} [inst : Mul M] {c d : Con M} (h : c = d),
Con.congr h = { toEquiv := Quotient.congr (Equiv.refl M) ⋯, map_mul' := ⋯ } |
Nat.le_sqrt | Mathlib.Data.Nat.Sqrt | ∀ {m n : ℕ}, m ≤ n.sqrt ↔ m * m ≤ n |
_private.Init.Data.Int.LemmasAux.0.Int.sub_max_sub_left._proof_1_1 | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), ¬max (a - b) (a - c) = a - min b c → False |
Int.lt_of_lt_of_le | Init.Data.Int.Order | ∀ {a b c : ℤ}, a < b → b ≤ c → a < c |
Qq.SortLocalDecls.State.ctorIdx | Qq.SortLocalDecls | Qq.SortLocalDecls.State → ℕ |
«_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₙₐ__1» | Mathlib.Algebra.Star.StarAlgHom | Lean.Macro |
Std.Tactic.BVDecide.LRAT.Internal.Formula.ReadyForRatAdd | Std.Tactic.BVDecide.LRAT.Internal.Formula.Class | {α : outParam (Type u)} →
{β : outParam (Type v)} →
{inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β} →
{σ : Type w} →
{inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ} →
[self : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ] → σ → Prop |
AlgHom.card_le | Mathlib.FieldTheory.Fixed | ∀ {F : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K]
[inst_3 : FiniteDimensional F K], Fintype.card (K →ₐ[F] K) ≤ Module.finrank F K |
CategoryTheory.finrank_hom_simple_simple_le_one | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] (𝕜 : Type u_2)
[inst_2 : Field 𝕜] [IsAlgClosed 𝕜] [inst_4 : CategoryTheory.Linear 𝕜 C] [CategoryTheory.Limits.HasKernels C] (X Y : C)
[FiniteDimensional 𝕜 (X ⟶ X)] [CategoryTheory.Simple X] [CategoryTheory.Simple Y], Module.finrank 𝕜 (X ⟶ Y) ≤ 1 |
Lean.Meta.Grind.instHasAnchorSplitCandidateWithAnchor | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.HasAnchor Lean.Meta.Grind.SplitCandidateWithAnchor |
DyckWord.firstReturn.eq_1 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord),
p.firstReturn =
List.findIdx
(fun i => decide (List.count DyckStep.U (List.take (i + 1) ↑p) = List.count DyckStep.D (List.take (i + 1) ↑p)))
(List.range (↑p).length) |
Asymptotics.isBigOTVS_fun_neg_right._simp_1 | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} {g : α → F} [ContinuousNeg F],
(f =O[𝕜; l] fun x => -g x) = f =O[𝕜; l] g |
AddOpposite.forall | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} {p : αᵃᵒᵖ → Prop}, (∀ (a : αᵃᵒᵖ), p a) ↔ ∀ (a : α), p (AddOpposite.op a) |
ProbabilityTheory.iIndepSets.piiUnionInter_of_notMem | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {π : ι → Set (Set Ω)} {a : ι}
{S : Finset ι}, ProbabilityTheory.iIndepSets π μ → a ∉ S → ProbabilityTheory.IndepSets (piiUnionInter π ↑S) (π a) μ |
_private.Mathlib.NumberTheory.LegendreSymbol.AddCharacter.0.AddChar.val_mem_rootsOfUnity._simp_1_1 | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {M : Type u_1} [inst : CommMonoid M] (k : ℕ) (ζ : Mˣ), (ζ ∈ rootsOfUnity k M) = (↑ζ ^ k = 1) |
Lean.Language.Lean.CommandParsedSnapshot.brecOn_3.eq | Lean.Language.Lean.Types | ∀ {motive_1 : Lean.Language.Lean.CommandParsedSnapshot → Sort u}
{motive_2 : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) → Sort u}
{motive_3 : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot → Sort u}
{motive_4 : Task Lean.Language.Lean.CommandParsedSnapshot → Sort u}
(t : Task Lean.Language.Lean.CommandParsedSnapshot)
(F_1 : (t : Lean.Language.Lean.CommandParsedSnapshot) → t.below → motive_1 t)
(F_2 :
(t : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot)) →
Lean.Language.Lean.CommandParsedSnapshot.below_1 t → motive_2 t)
(F_3 :
(t : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) →
Lean.Language.Lean.CommandParsedSnapshot.below_2 t → motive_3 t)
(F_4 :
(t : Task Lean.Language.Lean.CommandParsedSnapshot) →
Lean.Language.Lean.CommandParsedSnapshot.below_3 t → motive_4 t),
Lean.Language.Lean.CommandParsedSnapshot.brecOn_3 t F_1 F_2 F_3 F_4 =
F_4 t (Lean.Language.Lean.CommandParsedSnapshot.brecOn_3.go t F_1 F_2 F_3 F_4).2 |
Real.logb_zero | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b : ℝ}, Real.logb b 0 = 0 |
Lean.Compiler.LCNF.NormFVarResult.erased.elim | Lean.Compiler.LCNF.CompilerM | {motive : Lean.Compiler.LCNF.NormFVarResult → Sort u} →
(t : Lean.Compiler.LCNF.NormFVarResult) → t.ctorIdx = 1 → motive Lean.Compiler.LCNF.NormFVarResult.erased → motive t |
String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.noConfusion | Init.Data.String.Pattern.Basic | {P : Sort u} →
{ρ : Type} →
{pat : ρ} →
{s : String.Slice} →
{t : String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s} →
{ρ' : Type} →
{pat' : ρ'} →
{s' : String.Slice} →
{t' : String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat' s'} →
ρ = ρ' →
pat ≍ pat' →
s = s' →
t ≍ t' → String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.noConfusionType P t t' |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.NamespaceEntry.finish.match_1 | Lean.Server.FileWorker.RequestHandling | (motive : Option Lean.Syntax → Sort u_1) →
(endStx : Option Lean.Syntax) → ((endStx : Lean.Syntax) → motive (some endStx)) → (Unit → motive none) → motive endStx |
ContMDiffAt.eq_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : 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 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H')
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] (n : WithTop ℕ∞) (f : M → M') (x : M),
ContMDiffAt I I' n f x = ContMDiffWithinAt I I' n f Set.univ x |
MeasureTheory.measureReal_eq_measureReal_smaller_of_between_null_diff | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ s₃ : Set α},
s₁ ⊆ s₂ →
s₂ ⊆ s₃ →
μ.real (s₃ \ s₁) = 0 →
autoParam (μ (s₃ \ s₁) ≠ ⊤) MeasureTheory.measureReal_eq_measureReal_smaller_of_between_null_diff._auto_1 →
μ.real s₁ = μ.real s₂ |
CategoryTheory.Functor.Accessible.Limits.isColimitMapCocone.injective | Mathlib.CategoryTheory.Presentable.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {K : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} K]
{F : CategoryTheory.Functor K (CategoryTheory.Functor C (Type w'))} (c : CategoryTheory.Limits.Cone F)
(hc : (Y : C) → CategoryTheory.Limits.IsLimit (((CategoryTheory.evaluation C (Type w')).obj Y).mapCone c))
(κ : Cardinal.{w}) [inst_2 : Fact κ.IsRegular],
HasCardinalLT (CategoryTheory.Arrow K) κ →
∀ {J : Type w} [inst_3 : CategoryTheory.SmallCategory J] [CategoryTheory.IsCardinalFiltered J κ]
{X : CategoryTheory.Functor J C} (cX : CategoryTheory.Limits.Cocone X)
(hF : (k : K) → CategoryTheory.Limits.IsColimit ((F.obj k).mapCocone cX)) (j : J) (x₁ x₂ : c.pt.obj (X.obj j)),
c.pt.map (cX.ι.app j) x₁ = c.pt.map (cX.ι.app j) x₂ → ∃ j' α, c.pt.map (X.map α) x₁ = c.pt.map (X.map α) x₂ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.