name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
classifyingSpaceUniversalCover.compForgetAugmented | Mathlib.RepresentationTheory.Homological.Resolution | (G : Type u) → [Monoid G] → CategoryTheory.SimplicialObject.Augmented (Type u) |
Fin.Value.noConfusionType | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | Sort u → Fin.Value → Fin.Value → Sort u |
ISize.xor_eq_zero_iff._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : ISize}, (a ^^^ b = 0) = (a = b) |
Lean.Meta.matchFalse | Lean.Meta.MatchUtil | Lean.Expr → Lean.MetaM Bool |
_private.Mathlib.Algebra.Category.ModuleCat.ChangeOfRings.0.ModuleCat.extendScalars_assoc'._simp_1_1 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {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] (F : CategoryTheory.Functor C D)
{G H K : CategoryTheory.Functor D E} (α : G ⟶ H) (β : H ⟶ K) {Z : CategoryTheory.Functor C E} (h : F.comp K ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.whiskerLeft α) (CategoryTheory.CategoryStruct.comp (F.whiskerLeft β) h) =
CategoryTheory.CategoryStruct.comp (F.whiskerLeft (CategoryTheory.CategoryStruct.comp α β)) h |
_private.Init.Data.List.MinMaxOn.0.List.minOn.eq_1 | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] (f : α → β) (x : α) (xs : List α)
(h_2 : x :: xs ≠ []), List.minOn f (x :: xs) h_2 = List.foldl (minOn f) x xs |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization.0.Polynomial.natDegree_of_dvd_cyclotomic_of_irreducible_of_monic._simp_1_1 | Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [IsDomain R] [NeZero ↑n] {μ : R},
IsPrimitiveRoot μ n = (Polynomial.cyclotomic n R).IsRoot μ |
LinearMap.toLinearIsometry | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{E : Type u_5} →
{E₂ : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
[inst_2 : SeminormedAddCommGroup E] →
[inst_3 : SeminormedAddCommGroup E₂] →
[inst_4 : Module R E] → [inst_5 : Module R₂ E₂] → (f : E →ₛₗ[σ₁₂] E₂) → Isometry ⇑f → E →ₛₗᵢ[σ₁₂] E₂ |
Submonoid.distribMulAction | Mathlib.Algebra.Group.Submonoid.DistribMulAction | {M : Type u_1} →
{α : Type u_2} →
[inst : Monoid M] → [inst_1 : AddMonoid α] → [DistribMulAction M α] → (S : Submonoid M) → DistribMulAction (↥S) α |
Int.divisorsAntidiagonal_one | Mathlib.NumberTheory.Divisors | Int.divisorsAntidiag 1 = {(1, 1), (-1, -1)} |
CoeDep.noConfusion | Init.Coe | {P : Sort u_1} →
{α : Sort u} →
{x : α} →
{β : Sort v} →
{t : CoeDep α x β} →
{α' : Sort u} →
{x' : α'} →
{β' : Sort v} → {t' : CoeDep α' x' β'} → α = α' → x ≍ x' → β = β' → t ≍ t' → CoeDep.noConfusionType P t t' |
Algebra.PreSubmersivePresentation.ofAlgEquiv | Mathlib.RingTheory.Extension.Presentation.Submersive | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
Algebra.PreSubmersivePresentation R S ι σ →
{T : Type u_1} →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] → (S ≃ₐ[R] T) → Algebra.PreSubmersivePresentation R T ι σ |
AffineSubspace.coe_vsub._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : AffineSubspace k P) [inst_4 : Nonempty ↥s] (a b : ↥s), ↑a -ᵥ ↑b = ↑(a -ᵥ b) |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt8.reduceBin.match_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | (motive : Option UInt8 → Sort u_1) →
(__discr : Option UInt8) → ((m : UInt8) → motive (some m)) → ((x : Option UInt8) → motive x) → motive __discr |
AkraBazziRecurrence.eventually_one_add_smoothingFn_pos | Mathlib.Computability.AkraBazzi.SumTransform | ∀ᶠ (n : ℕ) in Filter.atTop, 0 < 1 + AkraBazziRecurrence.smoothingFn ↑n |
wrapSimpDischarger | Mathlib.Util.DischargerAsTactic | Lean.Meta.Simp.Discharge → Lean.Elab.Tactic.TacticM Unit |
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.tryTheoremWithHint?.match_1 | Mathlib.Tactic.FunProp.Core | (motive : ℕ × Lean.Expr → Sort u_1) → (x : ℕ × Lean.Expr) → ((id : ℕ) → (v : Lean.Expr) → motive (id, v)) → motive x |
Lean.Meta.ExtractLets.State._sizeOf_inst | Lean.Meta.Tactic.Lets | SizeOf Lean.Meta.ExtractLets.State |
instLieGroupOfNatWithTopENatOfIsTopologicalGroup | Mathlib.Geometry.Manifold.Algebra.LieGroup | ∀ {𝕜 : 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} {G : Type u_4}
[inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Group G] [IsTopologicalGroup G], LieGroup I 0 G |
Lean.Grind.Order.eq_of_le_of_le_0 | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [Std.IsPartialOrder α] [inst_2 : Lean.Grind.Ring α] {a b : α},
a ≤ b + ↑0 → b ≤ a + ↑0 → a = b |
UpperHalfPlane.IsZeroAtImInfty.eq_1 | Mathlib.NumberTheory.ModularForms.BoundedAtCusp | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : TopologicalSpace α] (f : UpperHalfPlane → α),
UpperHalfPlane.IsZeroAtImInfty f = UpperHalfPlane.atImInfty.ZeroAtFilter f |
Irreducible.maximalIdeal_pow_eq_setOf_le_v_coe_pow | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {K : Type u_1} {Γ₀ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation K Γ₀)
[inst_2 : IsDiscreteValuationRing ↥v.integer] {ϖ : ↥v.integer},
Irreducible ϖ → ∀ (n : ℕ), ↑(IsLocalRing.maximalIdeal ↥v.integer ^ n) = {y | v ↑y ≤ v ↑ϖ ^ n} |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.eq_zero_or_one._simp_1_1 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{x : P}, (x ∈ 1) = ∃ x', (algebraMap R P) x' = x |
Lean.Meta.ExtractLetsConfig.merge | Init.MetaTypes | Lean.Meta.ExtractLetsConfig → Bool |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isNone_minEntry?_eq_isEmpty._simp_1_3 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = true) = (l = []) |
SeparationQuotient.continuousOn_lift₂._simp_1 | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : X → Y → Z}
{hf : ∀ (a : X) (b : Y) (c : X) (d : Y), Inseparable a c → Inseparable b d → f a b = f c d}
{s : Set (SeparationQuotient X × SeparationQuotient Y)},
ContinuousOn (Function.uncurry (SeparationQuotient.lift₂ f hf)) s =
ContinuousOn (Function.uncurry f) (Prod.map SeparationQuotient.mk SeparationQuotient.mk ⁻¹' s) |
_private.Mathlib.LinearAlgebra.Matrix.Notation.0.Matrix.diagonal_fin_three._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∀ (i : Fin (n + 1)), P i) = (P 0 ∧ ∀ (i : Fin n), P i.succ) |
ContinuousMultilinearMap.smulRightL._proof_8 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) (G : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G], ContinuousSMul 𝕜 G |
Topology.RelCWComplex.finiteType_mkFiniteType | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] (C : Set X) (D : outParam (Set X)) (cell : ℕ → Type u)
(map : (n : ℕ) → cell n → PartialEquiv (Fin n → ℝ) X) (finite_cell : ∀ (n : ℕ), Finite (cell n))
(source_eq : ∀ (n : ℕ) (i : cell n), (map n i).source = Metric.ball 0 1)
(continuousOn : ∀ (n : ℕ) (i : cell n), ContinuousOn (↑(map n i)) (Metric.closedBall 0 1))
(continuousOn_symm : ∀ (n : ℕ) (i : cell n), ContinuousOn (↑(map n i).symm) (map n i).target)
(pairwiseDisjoint' : Set.univ.PairwiseDisjoint fun ni => ↑(map ni.fst ni.snd) '' Metric.ball 0 1)
(disjointBase' : ∀ (n : ℕ) (i : cell n), Disjoint (↑(map n i) '' Metric.ball 0 1) D)
(mapsTo :
∀ (n : ℕ) (i : cell n),
Set.MapsTo (↑(map n i)) (Metric.sphere 0 1) (D ∪ ⋃ m, ⋃ (_ : m < n), ⋃ j, ↑(map m j) '' Metric.closedBall 0 1))
(closed' :
∀ A ⊆ C,
(∀ (n : ℕ) (j : cell n), IsClosed (A ∩ ↑(map n j) '' Metric.closedBall 0 1)) ∧ IsClosed (A ∩ D) → IsClosed A)
(isClosedBase : IsClosed D) (union' : D ∪ ⋃ n, ⋃ j, ↑(map n j) '' Metric.closedBall 0 1 = C),
Topology.RelCWComplex.FiniteType C |
TopHomClass.rec | Mathlib.Order.Hom.Bounded | {F : Type u_6} →
{α : Type u_7} →
{β : Type u_8} →
[inst : Top α] →
[inst_1 : Top β] →
[inst_2 : FunLike F α β] →
{motive : TopHomClass F α β → Sort u} →
((map_top : ∀ (f : F), f ⊤ = ⊤) → motive ⋯) → (t : TopHomClass F α β) → motive t |
List.getLast_range' | Init.Data.List.Nat.Range | ∀ {s n : ℕ} (h : List.range' s n ≠ []), (List.range' s n).getLast h = s + n - 1 |
AddLocalization.r'._proof_4 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] (S : AddSubmonoid M) {a b c : M × ↥S} (t₁ : ↥S),
↑t₁ + (↑b.2 + a.1) = ↑t₁ + (↑a.2 + b.1) →
∀ (t₂ : ↥S), ↑t₂ + ↑c.2 + (↑t₁ + (↑b.2 + a.1)) = ↑t₁ + ↑a.2 + (↑t₂ + (↑c.2 + b.1)) |
_private.Lean.Server.FileWorker.0.Lean.Server.FileWorker.reportSnapshots.match_1 | Lean.Server.FileWorker | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) → ((last : Lean.Syntax.Range) → motive (some last)) → (Unit → motive none) → motive x |
CochainComplex.mkHomAux | Mathlib.Algebra.Homology.HomologicalComplex | {V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
(P Q : CochainComplex V ℕ) →
(zero : P.X 0 ⟶ Q.X 0) →
(one : P.X 1 ⟶ Q.X 1) →
CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one →
((n : ℕ) →
(p :
(f : P.X n ⟶ Q.X n) ×'
(f' : P.X (n + 1) ⟶ Q.X (n + 1)) ×'
CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) =
CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f') →
(f'' : P.X (n + 2) ⟶ Q.X (n + 2)) ×'
CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) =
CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f'') →
(n : ℕ) →
(f : P.X n ⟶ Q.X n) ×'
(f' : P.X (n + 1) ⟶ Q.X (n + 1)) ×'
CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) =
CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f' |
IsDedekindDomain.HeightOneSpectrum.valuedAdicCompletion_eq_valuation' | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (k : K),
Valued.v ↑((WithVal.equiv (IsDedekindDomain.HeightOneSpectrum.valuation K v)).symm k) =
(IsDedekindDomain.HeightOneSpectrum.valuation K v) k |
Equiv.toHomeomorphOfContinuousClosed_symm_apply | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y)
(h₁ : Continuous ⇑e) (h₂ : IsClosedMap ⇑e), ⇑(e.toHomeomorphOfContinuousClosed h₁ h₂).symm = ⇑e.symm |
Matroid.eRk_le_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X : Set α), M.eRk X ≤ X.encard |
FintypeCat.botTopology | Mathlib.Topology.Category.Profinite.Basic | (A : FintypeCat) → TopologicalSpace A.obj |
Std.DTreeMap.Internal.Impl.toListModel_inner | Std.Data.DTreeMap.Internal.Def | ∀ {α : Type u} {β : α → Type v} {sz : ℕ} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
(Std.DTreeMap.Internal.Impl.inner sz k v l r).toListModel = l.toListModel ++ ⟨k, v⟩ :: r.toListModel |
Real.toNNReal_le_ofNat._simp_1 | Mathlib.Data.NNReal.Defs | ∀ {r : ℝ} {n : ℕ} [inst : n.AtLeastTwo], (r.toNNReal ≤ OfNat.ofNat n) = (r ≤ ↑n) |
NonUnitalStarAlgebra.range_eq_top | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {F : Type v'} {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : StarRing R]
[inst_2 : NonUnitalSemiring A] [inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : NonUnitalSemiring B]
[inst_6 : StarRing B] [inst_7 : Module R B] [inst_8 : FunLike F A B] [inst_9 : NonUnitalAlgHomClass F R A B]
[inst_10 : StarHomClass F A B] [inst_11 : IsScalarTower R B B] [inst_12 : SMulCommClass R B B]
[inst_13 : StarModule R B] (f : F), NonUnitalStarAlgHom.range f = ⊤ ↔ Function.Surjective ⇑f |
_private.Mathlib.Analysis.Analytic.Within.0.analyticWithinAt_of_singleton_mem._simp_1_7 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True |
IsSepClosed.of_exists_root | Mathlib.FieldTheory.IsSepClosed | ∀ (k : Type u) [inst : Field k],
(∀ (p : Polynomial k), p.Monic → Irreducible p → p.Separable → ∃ x, Polynomial.eval x p = 0) → IsSepClosed k |
Subtype.isEmpty_of_false | Mathlib.Logic.IsEmpty.Defs | ∀ {α : Sort u} {p : α → Prop}, (∀ (a : α), ¬p a) → IsEmpty (Subtype p) |
ContinuousLinearMap.range_coeFn_eq | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂],
Set.range DFunLike.coe = {f | Continuous f} ∩ Set.range DFunLike.coe |
Turing.PartrecToTM2.instDecidableEqCont'.decEq._proof_5 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (a : Turing.ToPartrec.Code) (a_1 : Turing.PartrecToTM2.Cont'),
¬Turing.PartrecToTM2.Cont'.halt = Turing.PartrecToTM2.Cont'.comp a a_1 |
Lean.CollectMVars.State.rec | Lean.Util.CollectMVars | {motive : Lean.CollectMVars.State → Sort u} →
((visitedExpr : Lean.ExprSet) →
(result : Array Lean.MVarId) → motive { visitedExpr := visitedExpr, result := result }) →
(t : Lean.CollectMVars.State) → motive t |
SemidirectProduct.rightHom_eq_right | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N},
⇑SemidirectProduct.rightHom = SemidirectProduct.right |
AlgebraicGeometry.StructureSheaf.sectionsSubmodule._proof_5 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R |
_private.Lean.Meta.Basic.0.Lean.Meta.lambdaMetaTelescope.process.match_1 | Lean.Meta.Basic | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((binderName : Lean.Name) → (d b : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.lam binderName d b bi)) →
((x : Lean.Expr) → motive x) → motive type |
MvPolynomial.degrees_one | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], MvPolynomial.degrees 1 = 0 |
Real.not_summable_indicator_one_div_natCast | Mathlib.Analysis.PSeries | ∀ {m : ℕ}, m ≠ 0 → ∀ (k : ZMod m), ¬Summable ({n | ↑n = k}.indicator fun n => 1 / ↑n) |
CategoryTheory.Limits.biproduct.isLimit | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(F : J → C) →
[inst_2 : CategoryTheory.Limits.HasBiproduct F] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.biproduct.bicone F).toCone |
List.mergeSort_of_sorted | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool} {l : List α}, List.Pairwise (fun a b => le a b = true) l → l.mergeSort le = l |
QuasispectrumRestricts.nonUnitalStarAlgHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | {R : Type u} →
{S : Type v} →
{A : Type w} →
[inst : Semifield R] →
[inst_1 : StarRing R] →
[inst_2 : TopologicalSpace R] →
[inst_3 : IsTopologicalSemiring R] →
[inst_4 : ContinuousStar R] →
[inst_5 : Field S] →
[inst_6 : StarRing S] →
[inst_7 : TopologicalSpace S] →
[inst_8 : IsTopologicalRing S] →
[inst_9 : ContinuousStar S] →
[inst_10 : NonUnitalRing A] →
[inst_11 : StarRing A] →
[inst_12 : Algebra R S] →
[inst_13 : Module R A] →
[inst_14 : Module S A] →
[IsScalarTower S A A] →
[SMulCommClass S A A] →
[IsScalarTower R S A] →
[StarModule R S] →
[ContinuousSMul R S] →
{a : A} →
(ContinuousMapZero (↑(quasispectrum S a)) S →⋆ₙₐ[S] A) →
{f : C(S, R)} →
QuasispectrumRestricts a ⇑f →
ContinuousMapZero (↑(quasispectrum R a)) R →⋆ₙₐ[R] A |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.disjoint_filter_pairs_lt_filter_pairs_eq | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (σ : Type u_1) [inst : DecidableEq σ] [inst_1 : Fintype σ] (k : ℕ),
Disjoint ({t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k | t.1.card < k})
({t ∈ MvPolynomial.NewtonIdentities.pairs✝¹ σ k | t.1.card = k}) |
EStateM.Result.map_error | Batteries.Lean.EStateM | ∀ {ε σ α β : Type u_1} (f : α → β) (e : ε) (s : σ),
EStateM.Result.map f (EStateM.Result.error e s) = EStateM.Result.error e s |
DFinsupp.mkAddGroupHom | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{β : ι → Type v} →
[DecidableEq ι] → [inst : (i : ι) → AddGroup (β i)] → (s : Finset ι) → ((i : ↑↑s) → β ↑i) →+ Π₀ (i : ι), β i |
MonoidHom.noncommPiCoprod.eq_1 | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {M : Type u_1} [inst : Monoid M] {ι : Type u_2} [inst_1 : Fintype ι] {N : ι → Type u_3}
[inst_2 : (i : ι) → Monoid (N i)] (ϕ : (i : ι) → N i →* M)
(hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)),
MonoidHom.noncommPiCoprod ϕ hcomm =
{ toFun := fun f => Finset.univ.noncommProd (fun i => (ϕ i) (f i)) ⋯, map_one' := ⋯, map_mul' := ⋯ } |
MulEquiv.monoidHomCongrLeftEquiv._proof_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M₁ : Type u_1} {M₂ : Type u_3} {N : Type u_2} [inst : MulOneClass M₁] [inst_1 : MulOneClass M₂] [inst_2 : Monoid N]
(e : M₁ ≃* M₂) (f : M₁ →* N), (fun f => f.comp e.toMonoidHom) ((fun f => f.comp e.symm.toMonoidHom) f) = f |
Pi.involutiveNeg._proof_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → InvolutiveNeg (f i)] (x : (i : I) → f i), - -x = x |
String.Slice.SplitIterator.instIteratorIdSubslice._proof_7 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] {pat : ρ}
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat σ] {s : String.Slice} (currPos : s.Pos)
(searcher searcher' : Std.Iter (String.Slice.Pattern.SearchStep s)) (startPos endPos : s.Pos),
searcher.IsPlausibleStep (Std.IterStep.yield searcher' (String.Slice.Pattern.SearchStep.matched startPos endPos)) →
match { internalState := String.Slice.SplitIterator.operating currPos searcher },
Std.IterStep.yield { internalState := String.Slice.SplitIterator.operating endPos searcher' }
(s.subslice! currPos startPos) with
| { internalState := String.Slice.SplitIterator.operating currPos s_1 },
Std.IterStep.yield { internalState := String.Slice.SplitIterator.operating currPos_1 s' } out =>
s'.IsPlausibleSuccessorOf s_1
| { internalState := String.Slice.SplitIterator.operating currPos s_1 },
Std.IterStep.yield { internalState := String.Slice.SplitIterator.atEnd } out => True
| { internalState := String.Slice.SplitIterator.operating currPos s_1 },
Std.IterStep.skip { internalState := String.Slice.SplitIterator.operating currPos_1 s' } =>
s'.IsPlausibleSuccessorOf s_1
| { internalState := String.Slice.SplitIterator.operating currPos s },
Std.IterStep.skip { internalState := String.Slice.SplitIterator.atEnd } => False
| { internalState := String.Slice.SplitIterator.operating currPos s }, Std.IterStep.done => True
| { internalState := String.Slice.SplitIterator.atEnd }, Std.IterStep.yield it out => False
| { internalState := String.Slice.SplitIterator.atEnd }, Std.IterStep.skip it => False
| { internalState := String.Slice.SplitIterator.atEnd }, Std.IterStep.done => True |
Lean.Elab.Term.elabRunElab._regBuiltin.Lean.Elab.Term.elabRunElab.declRange_5 | Lean.Elab.BuiltinNotation | IO Unit |
abs_eq_abs | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] {a b : α}, |a| = |b| ↔ a = b ∨ a = -b |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.continuous_dom_pi._simp_1_4 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_minKey!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
UInt32.and_not_self | Init.Data.UInt.Bitwise | ∀ {a : UInt32}, a &&& ~~~a = 0 |
OrderRingHom | Mathlib.Algebra.Order.Hom.Ring | (α : Type u_6) →
(β : Type u_7) → [NonAssocSemiring α] → [Preorder α] → [NonAssocSemiring β] → [Preorder β] → Type (max u_6 u_7) |
Std.DTreeMap.Internal.Impl.minView.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hl_2 : Std.DTreeMap.Internal.Impl.leaf.Balanced)
(hlr_2 : Std.DTreeMap.Internal.Impl.BalancedAtRoot Std.DTreeMap.Internal.Impl.leaf.size r.size),
Std.DTreeMap.Internal.Impl.minView k v Std.DTreeMap.Internal.Impl.leaf r hl_2 hr hlr_2 =
{ k := k, v := v, tree := { impl := r, balanced_impl := hr, size_impl := ⋯ } } |
TopCat.effectiveEpiStructOfQuotientMap._proof_2 | Mathlib.Topology.Category.TopCat.EffectiveEpi | ∀ {X : TopCat} (a : ↑X), Continuous fun x => a |
IsUltrametricDist.closedBall_openSubgroup._proof_3 | Mathlib.Analysis.Normed.Group.Ultra | ∀ (S : Type u_1) [inst : SeminormedGroup S] {r : ℝ} {x : S}, x ∈ Metric.closedBall 1 r → x⁻¹ ∈ Metric.closedBall 1 r |
OpenSubgroup.mem_inf._simp_2 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] {U V : OpenSubgroup G} {x : G},
(x ∈ U ⊓ V) = (x ∈ U ∧ x ∈ V) |
Std.DHashMap.Raw.contains_inter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {k : α}, m₁.WF → m₂.WF → (m₁ ∩ m₂).contains k = (m₁.contains k && m₂.contains k) |
_private.Mathlib.Algebra.DirectSum.Basic.0.DirectSum.id._proof_3 | Mathlib.Algebra.DirectSum.Basic | ∀ (M : Type u_2) (ι : Type u_1) [inst : AddCommMonoid M] [inst_1 : Unique ι] (x y : DirectSum ι fun i => M),
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) x) = x →
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) y) = y →
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) (x + y)) = x + y |
Lean.Firefox.ProfileMeta.sampleUnits._default | Lean.Util.Profiler | Lean.Firefox.SampleUnits |
Lean.EffectiveImport.mk.noConfusion | Lean.Environment | {P : Sort u} →
{toImport : Lean.Import} →
{irPhases : Lean.IRPhases} →
{toImport' : Lean.Import} →
{irPhases' : Lean.IRPhases} →
{ toImport := toImport, irPhases := irPhases } = { toImport := toImport', irPhases := irPhases' } →
(toImport = toImport' → irPhases = irPhases' → P) → P |
Set.Ioi_insert | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, insert a (Set.Ioi a) = Set.Ici a |
Lean.Compiler.LCNF.MonadCodeBind.recOn | Lean.Compiler.LCNF.Bind | {m : Type → Type} →
{motive : Lean.Compiler.LCNF.MonadCodeBind m → Sort u} →
(t : Lean.Compiler.LCNF.MonadCodeBind m) →
((codeBind :
{pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu →
(Lean.FVarId → m (Lean.Compiler.LCNF.Code pu)) → m (Lean.Compiler.LCNF.Code pu)) →
motive { codeBind := codeBind }) →
motive t |
_private.Mathlib.MeasureTheory.Measure.Restrict.0.MeasureTheory.ae_restrict_iff₀._simp_1_3 | Mathlib.MeasureTheory.Measure.Restrict | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) |
CategoryTheory.SmallObject.SuccStruct.Iteration.mkOfLimit._proof_1 | Mathlib.CategoryTheory.SmallObject.Iteration.Nonempty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {Φ : CategoryTheory.SmallObject.SuccStruct C}
{J : Type u_3} [inst_1 : LinearOrder J] [inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] {j : J} (hj : Order.IsSuccLimit j)
(iter : (i : J) → i < j → Φ.Iteration i) (i : J) (hi : i < j),
CategoryTheory.SmallObject.SuccStruct.arrowSucc
(CategoryTheory.SmallObject.SuccStruct.Iteration.mkOfLimit.functor hj iter) i hi =
Φ.toSuccArrow ((CategoryTheory.SmallObject.SuccStruct.Iteration.mkOfLimit.functor hj iter).obj ⟨i, ⋯⟩) |
CategoryTheory.DifferentialObject.Hom.mk.congr_simp | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_1} [inst : AddMonoidWithOne S] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S]
{X Y : CategoryTheory.DifferentialObject S C} (f f_1 : X.obj ⟶ Y.obj) (e_f : f = f_1)
(comm :
CategoryTheory.CategoryStruct.comp X.d ((CategoryTheory.shiftFunctor C 1).map f) =
CategoryTheory.CategoryStruct.comp f Y.d),
{ f := f, comm := comm } = { f := f_1, comm := ⋯ } |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.alterKey_cons_perm.match_1.splitter | Std.Data.Internal.List.Associative | {α : Type u_3} →
{β : α → Type u_1} →
{k : α} →
(motive : Option (β k) → Sort u_2) →
(x : Option (β k)) → (Unit → motive none) → ((v : β k) → motive (some v)) → motive x |
Nonneg.semiring._proof_14 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : ZeroLEOneClass α] [inst_3 : AddLeftMono α]
[inst_4 : PosMulMono α] (a : { x // 0 ≤ x }), a * 1 = a |
ComplexShape.Embedding.extendFunctor_obj | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') (C : Type u_3)
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c),
(e.extendFunctor C).obj K = K.extend e |
GradedAlgebra.algebraMap_apply | Mathlib.RingTheory.GradedAlgebra.TensorProduct | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : DecidableEq ι] [inst_4 : AddCommMonoid ι] [inst_5 : CommSemiring A]
[inst_6 : Algebra R A] (𝒜 : ι → Submodule R A) [inst_7 : GradedAlgebra 𝒜] (x : ↥(Submodule.baseChange S (𝒜 0))),
(algebraMap (↥(Submodule.baseChange S (𝒜 0))) (TensorProduct R S A)) x = ↑x |
WittVector.truncateFun_add | Mathlib.RingTheory.WittVector.Truncated | ∀ {p : ℕ} (n : ℕ) {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (x y : WittVector p R),
WittVector.truncateFun n (x + y) = WittVector.truncateFun n x + WittVector.truncateFun n y |
MessageActionItem.title | Lean.Data.Lsp.Window | MessageActionItem → String |
Pi.vaddAssocClass | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} {α : ι → Type u_4} [inst : VAdd M N] [inst_1 : (i : ι) → VAdd N (α i)]
[inst_2 : (i : ι) → VAdd M (α i)] [∀ (i : ι), VAddAssocClass M N (α i)], VAddAssocClass M N ((i : ι) → α i) |
instPseudoEMetricSpaceULift | Mathlib.Topology.EMetricSpace.Defs | {α : Type u} → [PseudoEMetricSpace α] → PseudoEMetricSpace (ULift.{u_2, u} α) |
Action.forget._proof_2 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (G : Type u_3) [inst_1 : Monoid G] {X Y Z : Action V G}
(f : X ⟶ Y) (g : Y ⟶ Z), (CategoryTheory.CategoryStruct.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.dvd_C_mul.match_1_1 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u_1} {a : R} [inst : Field R] {p q : Polynomial R} (motive : p ∣ Polynomial.C a * q → Prop)
(x : p ∣ Polynomial.C a * q), (∀ (r : Polynomial R) (hr : Polynomial.C a * q = p * r), motive ⋯) → motive x |
Std.Sat.AIG.denote._proof_4 | Std.Sat.AIG.Basic | ∀ {α : Type} (x : ℕ) (decls : Array (Std.Sat.AIG.Decl α)),
x < decls.size → ∀ (lhs rhs : Std.Sat.AIG.Fanin), lhs.gate < x ∧ rhs.gate < x → rhs.gate < decls.size |
Antitone.lowerBounds_range_comp_tendsto_atTop | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : Preorder γ] {l : Filter α} [l.NeBot]
{f : β → γ},
Antitone f →
∀ {g : α → β}, Filter.Tendsto g l Filter.atTop → lowerBounds (Set.range (f ∘ g)) = lowerBounds (Set.range f) |
CategoryTheory.ProjectiveResolution.isoExt._proof_4 | Mathlib.CategoryTheory.Abelian.Ext | ∀ {R : Type u_2} [inst : Ring R] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.Linear R C] {X : C}
(P : CategoryTheory.ProjectiveResolution X) (n : ℕ) (Y : C),
(HomologicalComplex.sc (P.complex.linearYonedaObj R Y) n).HasHomology |
Lean.Meta.Rewrites.RwDirection._sizeOf_inst | Lean.Meta.Tactic.Rewrites | SizeOf Lean.Meta.Rewrites.RwDirection |
Int.natAbs_inj_of_nonpos_of_nonneg | Mathlib.Data.Int.Lemmas | ∀ {a b : ℤ}, a ≤ 0 → 0 ≤ b → (a.natAbs = b.natAbs ↔ -a = b) |
Nat.coprime_of_dvd' | Mathlib.Data.Nat.Prime.Basic | ∀ {m n : ℕ}, (∀ (k : ℕ), Nat.Prime k → k ∣ m → k ∣ n → k ∣ 1) → m.Coprime n |
Set.univ_inter | Mathlib.Data.Set.Basic | ∀ {α : Type u} (a : Set α), Set.univ ∩ a = a |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_650 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α)
(h :
List.idxOfNth w [g (g a)] (List.idxOfNth w [g (g a)] 1) + 1 ≤
(List.filter (fun x => decide (x = w)) [a, g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w)) [a, g a, g (g a)])[List.idxOfNth w [g (g a)] (List.idxOfNth w [g (g a)] 1)] <
[a, g a, g (g a)].length |
PreTilt.mk_comp_untilt_eq_coeff_zero | Mathlib.RingTheory.Perfectoid.Untilt | ∀ {O : Type u_1} [inst : CommRing O] {p : ℕ} [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p]
[inst_3 : IsAdicComplete (Ideal.span {↑p}) O],
⇑(Ideal.Quotient.mk (Ideal.span {↑p})) ∘ ⇑PreTilt.untilt = ⇑(PreTilt.coeff 0) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.