name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
toIcoDiv_add_left' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), toIcoDiv hp (p + a) b = toIcoDiv hp a b - 1 |
Int8.toNatClampNeg_lt | Init.Data.SInt.Lemmas | ∀ (x : Int8), x.toNatClampNeg < 2 ^ 7 |
_private.Lean.Meta.ForEachExpr.0.Lean.Meta.forEachExpr'.visit | Lean.Meta.ForEachExpr | {m : Type → Type} →
[Monad m] →
[MonadControlT Lean.MetaM m] →
(Lean.Expr → m Bool) →
(x : STWorld IO.RealWorld m) →
MonadLiftT (ST IO.RealWorld) m → Lean.Expr → Lean.MonadCacheT Lean.Expr Unit m Unit |
_private.Init.Data.Nat.Lemmas.0.Nat.one_mod_eq_one.match_1_1 | Init.Data.Nat.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive x |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.mu'_apply_self | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : AddCommGroup 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : LocallyFiniteOrder α] [inst_4 : DecidableEq α] (a : α), (IncidenceAlgebra.mu'✝ 𝕜) a a = 1 |
MeasureTheory.Egorov.notConvergentSeqLTIndex | Mathlib.MeasureTheory.Function.Egorov | {α : Type u_1} →
{β : Type u_2} →
{ι : Type u_3} →
{m : MeasurableSpace α} →
[inst : PseudoEMetricSpace β] →
{μ : MeasureTheory.Measure α} →
{s : Set α} →
{ε : ℝ} →
{f : ι → α → β} →
{g : α → β} →
[inst_1 : SemilatticeSup ι] →
[Nonempty ι] →
[Countable ι] →
0 < ε →
(∀ (n : ι), Measurable fun a => edist (f n a) (g a)) →
MeasurableSet s →
μ s ≠ ⊤ →
(∀ᵐ (x : α) ∂μ, x ∈ s → Filter.Tendsto (fun n => f n x) Filter.atTop (nhds (g x))) →
ℕ → ι |
Lean.Meta.MVarRenaming.map | Lean.Meta.Match.MVarRenaming | Lean.Meta.MVarRenaming → Lean.MVarIdMap Lean.MVarId |
SemidirectProduct.inr | Mathlib.GroupTheory.SemidirectProduct | {N : Type u_1} → {G : Type u_2} → [inst : Group N] → [inst_1 : Group G] → {φ : G →* MulAut N} → G →* N ⋊[φ] G |
GroupSeminorm.coe_sSup_apply' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : Group E] {s : Set (GroupSeminorm E)},
BddAbove s → ∀ {x : E}, (sSup s) x = sSup ((fun x_1 => x_1 x) '' s) |
Algebra.IsPushout.cancelBaseChangeAux.congr_simp | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_1) (S : Type v₃) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (A : Type u_8)
(B : Type u_9) [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTower R S B]
[inst_11 : Algebra.IsPushout R S A B] (M : Type u_10) [inst_12 : AddCommGroup M] [inst_13 : Module R M]
[inst_14 : Module A M] [inst_15 : IsScalarTower R A M],
Algebra.IsPushout.cancelBaseChangeAux R S A B M = Algebra.IsPushout.cancelBaseChangeAux R S A B M |
_private.Lean.Server.GoTo.0.Lean.Server.getInstanceProjectionArg?.reduceToProjection?._sparseCasesOn_6 | Lean.Server.GoTo | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t |
Array.merge.go._unary | Batteries.Data.Array.Merge | {α : Type u_1} → (α → α → Bool) → Array α → Array α → (_ : Array α) ×' (_ : ℕ) ×' ℕ → Array α |
RingSeminormClass.mk._flat_ctor | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} [inst : NonUnitalNonAssocRing α]
[inst_1 : Semiring β] [inst_2 : PartialOrder β] [inst_3 : FunLike F α β],
(∀ (f : F) (a b : α), f (a + b) ≤ f a + f b) →
(∀ (f : F), f 0 = 0) →
(∀ (f : F) (a : α), f (-a) = f a) → (∀ (f : F) (a b : α), f (a * b) ≤ f a * f b) → RingSeminormClass F α β |
_private.Init.Data.Fin.Basic.0.Fin.exists_iff.match_1_1 | Init.Data.Fin.Basic | ∀ {n : ℕ} {p : Fin n → Prop} (motive : (∃ i, p i) → Prop) (x : ∃ i, p i),
(∀ (i : ℕ) (hi : i < n) (hpi : p ⟨i, hi⟩), motive ⋯) → motive x |
LieModule.Cohomology.twoCocycle.eq_1 | Mathlib.Algebra.Lie.Cochain | ∀ (R : Type u_1) [inst : CommRing R] (L : Type u_2) [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M],
LieModule.Cohomology.twoCocycle R L M = (LieModule.Cohomology.d₂₃ R L M).ker |
Convex.norm_image_sub_le_of_norm_fderiv_le | Mathlib.Analysis.Calculus.MeanValue | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {𝕜 : Type u_3} {G : Type u_4}
[inst_2 : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → G} {C : ℝ} {s : Set E} {x y : E},
(∀ x ∈ s, DifferentiableAt 𝕜 f x) →
(∀ x ∈ s, ‖fderiv 𝕜 f x‖ ≤ C) → Convex ℝ s → x ∈ s → y ∈ s → ‖f y - f x‖ ≤ C * ‖y - x‖ |
Std.DTreeMap.Internal.Impl.applyPartition_eq_apply_toListModel | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : BEq α]
[inst_3 : Std.LawfulBEqOrd α] {k : α} {l : Std.DTreeMap.Internal.Impl α β},
l.Ordered →
∀
{f :
List ((a : α) × β a) →
(c : Std.DTreeMap.Internal.Cell α β (compare k)) →
(Std.DTreeMap.Internal.Impl.contains' (compare k) l = true → c.contains = true) → List ((a : α) × β a) → δ}
(g :
(ll : List ((a : α) × β a)) →
(Std.DTreeMap.Internal.Impl.contains' (compare k) l = true → Std.Internal.List.containsKey k ll = true) → δ),
(∀ {ll rr : List ((a : α) × β a)} {c : Std.DTreeMap.Internal.Cell α β (compare k)}
{h₁ : Std.DTreeMap.Internal.Impl.contains' (compare k) l = true → c.contains = true},
List.Pairwise (fun a b => compare a.fst b.fst = Ordering.lt) (ll ++ c.inner.toList ++ rr) →
(∀ p ∈ ll, compare k p.fst = Ordering.gt) →
(∀ p ∈ rr, compare k p.fst = Ordering.lt) → f ll c h₁ rr = g (ll ++ c.inner.toList ++ rr) ⋯) →
Std.DTreeMap.Internal.Impl.applyPartition (compare k) l f = g l.toListModel ⋯ |
Lean.Elab.Do.InferControlInfo.ofSeq | Lean.Elab.Do.InferControlInfo | Lean.TSyntax `Lean.Parser.Term.doSeq → Lean.Elab.TermElabM Lean.Elab.Do.ControlInfo |
Mathlib.Tactic.Order.OrderType.lin.sizeOf_spec | Mathlib.Tactic.Order.Preprocessing | sizeOf Mathlib.Tactic.Order.OrderType.lin = 1 |
_private.Init.Data.Nat.Control.0.Nat.forM.loop._unsafe_rec | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → (i : ℕ) → i ≤ n → m Unit |
SymAlg.instCommMagmaOfInvertibleOfNat | Mathlib.Algebra.Symmetrized | {α : Type u_1} → [inst : Ring α] → [Invertible 2] → CommMagma αˢʸᵐ |
LeanSearchClient.instReprSearchResult | LeanSearchClient.Syntax | Repr LeanSearchClient.SearchResult |
Nat.mul_left_comm | Init.Data.Nat.Basic | ∀ (n m k : ℕ), n * (m * k) = m * (n * k) |
UInt16.toFin_mod | Init.Data.UInt.Lemmas | ∀ (a b : UInt16), (a % b).toFin = a.toFin % b.toFin |
PadicSeq.valuation | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [Fact (Nat.Prime p)] → PadicSeq p → ℤ |
SimpleGraph.sum_incMatrix_apply_of_notMem_edgeSet | Mathlib.Combinatorics.SimpleGraph.IncMatrix | ∀ {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [inst : NonAssocSemiring R] [inst_1 : DecidableEq α]
[inst_2 : DecidableRel G.Adj] {e : Sym2 α} [inst_3 : Fintype α],
e ∉ G.edgeSet → ∑ a, SimpleGraph.incMatrix R G a e = 0 |
ValueDistribution.logCounting_const | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : ProperSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {c : E} {e : WithTop E},
ValueDistribution.logCounting (fun x => c) e = 0 |
PairReduction.finset_logSizeBallSeq_subset_logSizeBallSeq_init | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : PseudoEMetricSpace T] {a c : ENNReal} {J : Finset T} [inst_1 : DecidableEq T] (hJ : J.Nonempty)
(i : ℕ), (PairReduction.logSizeBallSeq J hJ a c i).finset ⊆ J |
RootPairing.coroot_eq_neg_iff | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : 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] (P : RootPairing ι R M N) {i j : ι},
P.coroot i = -P.coroot j ↔ i = (P.reflectionPerm j) j |
UInt8.ext | Batteries.Data.UInt | ∀ {x y : UInt8}, x.toNat = y.toNat → x = y |
Std.Roo.size_eq_match_roc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.HasSize α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[Std.Rxo.IsAlwaysFinite α] [Std.Rxo.LawfulHasSize α],
r.size =
match Std.PRange.succ? r.lower with
| none => 0
| some next => if next < r.upper then (next<...r.upper).size + 1 else 0 |
_private.Mathlib.Data.Nat.Dist.0.Nat.dist_zero_right._proof_1_1 | Mathlib.Data.Nat.Dist | ∀ (n : ℕ), n - 0 + (0 - n) = n |
NNRat.divNat_zero | Mathlib.Data.NNRat.Defs | ∀ (n : ℕ), NNRat.divNat n 0 = 0 |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.activateNextGuard.go.match_1 | Lean.Meta.Tactic.Grind.Types | (motive : Lean.Meta.Simp.Result → Sort u_1) →
(__discr : Lean.Meta.Simp.Result) →
((e : Lean.Expr) →
(proof? : Option Lean.Expr) → (cache : Bool) → motive { expr := e, proof? := proof?, cache := cache }) →
motive __discr |
Lean.Grind.CommRing.Poly.noConfusion | Init.Grind.Ring.CommSolver | {P : Sort u} → {t t' : Lean.Grind.CommRing.Poly} → t = t' → Lean.Grind.CommRing.Poly.noConfusionType P t t' |
RingHom.CodescendsAlong.algebraMap_tensorProduct | Mathlib.RingTheory.RingHomProperties | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
(Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) (R S T : Type u)
[inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T],
(RingHom.CodescendsAlong (fun {R S} [CommRing R] [CommRing S] => P) fun {R S} [CommRing R] [CommRing S] => Q) →
Q (algebraMap R S) → P (algebraMap S (TensorProduct R S T)) → P (algebraMap R T) |
star_pow | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (x : R) (n : ℕ), star (x ^ n) = star x ^ n |
Std.Sat.CNF.eval_empty | Std.Sat.CNF.Basic | ∀ {α : Type u_1} (a : α → Bool), Std.Sat.CNF.eval a Std.Sat.CNF.empty = true |
DiscreteMeasurableSpace.mk | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_7} [inst : MeasurableSpace α], (∀ (s : Set α), MeasurableSet s) → DiscreteMeasurableSpace α |
LocallyConstant.instCommGroup._proof_6 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : CommGroup Y] (x : LocallyConstant X Y) (x_1 : ℤ),
⇑(x ^ x_1) = ⇑(x ^ x_1) |
Set.OrdConnected.isSuccArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] (s : Set α)
[inst_3 : s.OrdConnected], IsSuccArchimedean ↑s |
Lean.Parser.Term.falseVal.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_derivedLits._proof_1_8 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (derivedLits_arr : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(j : Fin derivedLits_arr.size), ↑j + 1 ≤ derivedLits_arr.size → ↑j < derivedLits_arr.size |
_private.Mathlib.Order.Sublattice.0.Sublattice.map_symm_eq_iff_eq_map._simp_1_3 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L M : Sublattice α}, (L = M) = (↑L = ↑M) |
Set.image_affine_Ico | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {K : Type u_2} [inst : DivisionSemiring K] [inst_1 : PartialOrder K] [PosMulReflectLT K] [IsOrderedCancelAddMonoid K]
[ExistsAddOfLE K] {a : K},
0 < a → ∀ (b c d : K), (fun x => a * x + b) '' Set.Ico c d = Set.Ico (a * c + b) (a * d + b) |
AlgebraicGeometry.Scheme.Modules.pullback._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
(SheafOfModules.pushforward (AlgebraicGeometry.Scheme.Hom.toRingCatSheafHom f)).IsRightAdjoint |
Std.HashMap.contains_modify | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α} {f : β → β}, (m.modify k f).contains k' = m.contains k' |
CategoryTheory.MonoidalCategory.instMonoidalFunctorTensoringRight._proof_6 | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso C)
(((CategoryTheory.evaluation C (CategoryTheory.Functor C C)).obj X).comp
((CategoryTheory.evaluation C C).obj Y))).hom
((CategoryTheory.MonoidalCategory.tensoringRight C).obj Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso C)
(((CategoryTheory.evaluation C (CategoryTheory.Functor C C)).obj
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).comp
((CategoryTheory.evaluation C C).obj Z))).hom
((CategoryTheory.MonoidalCategory.tensoringRight C).map
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator ((CategoryTheory.MonoidalCategory.tensoringRight C).obj X)
((CategoryTheory.MonoidalCategory.tensoringRight C).obj Y)
((CategoryTheory.MonoidalCategory.tensoringRight C).obj Z)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.MonoidalCategory.tensoringRight C).obj X)
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso C)
(((CategoryTheory.evaluation C (CategoryTheory.Functor C C)).obj Y).comp
((CategoryTheory.evaluation C C).obj Z))).hom)
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso C)
(((CategoryTheory.evaluation C (CategoryTheory.Functor C C)).obj X).comp
((CategoryTheory.evaluation C C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)))).hom) |
Lean.PrettyPrinter.Formatter.State.noConfusionType | Lean.PrettyPrinter.Formatter | Sort u → Lean.PrettyPrinter.Formatter.State → Lean.PrettyPrinter.Formatter.State → Sort u |
Lean.Meta.MatcherApp.remaining | Lean.Meta.Match.MatcherApp.Basic | Lean.Meta.MatcherApp → Array Lean.Expr |
instSubNegAddMonoidLex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : SubNegMonoid α] → SubNegMonoid (Lex α) |
inv_eq_one_divp | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), ↑u⁻¹ = 1 /ₚ u |
_private.Mathlib.NumberTheory.SmoothNumbers.0.Nat.mem_factoredNumbers_iff_forall_le.match_1_3 | Mathlib.NumberTheory.SmoothNumbers | ∀ {s : Finset ℕ} {m : ℕ} (motive : (m ≠ 0 ∧ ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s) → Prop)
(x : m ≠ 0 ∧ ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s),
(∀ (H₀ : m ≠ 0) (H₁ : ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s), motive ⋯) → motive x |
PNat.XgcdType.y | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ |
ContinuousLinearMap.coe_projKerOfRightInverse_apply | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R : Type u_1} [inst : Ring R] {R₂ : Type u_2} [inst_1 : Ring R₂] {M : Type u_4} [inst_2 : TopologicalSpace M]
[inst_3 : AddCommGroup M] {M₂ : Type u_5} [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommGroup M₂]
[inst_6 : Module R M] [inst_7 : Module R₂ M₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_8 : RingHomInvPair σ₁₂ σ₂₁]
[inst_9 : IsTopologicalAddGroup M] (f₁ : M →SL[σ₁₂] M₂) (f₂ : M₂ →SL[σ₂₁] M) (h : Function.RightInverse ⇑f₂ ⇑f₁)
(x : M), ↑((f₁.projKerOfRightInverse f₂ h) x) = x - f₂ (f₁ x) |
PseudoMetricSpace.toUniformSpace | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u} → [self : PseudoMetricSpace α] → UniformSpace α |
CategoryTheory.MorphismProperty.llp_rlp_of_hasSmallObjectArgument' | Mathlib.CategoryTheory.SmallObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C)
[inst_1 : I.HasSmallObjectArgument],
I.rlp.llp =
((CategoryTheory.MorphismProperty.coproducts.{w, v, u} I).pushouts.transfiniteCompositionsOfShape
I.smallObjectκ.ord.ToType).retracts |
Submonoid.LocalizationMap.mulEquivOfLocalizations_right_inv | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) (k : S.LocalizationMap P),
f.ofMulEquivOfLocalizations (f.mulEquivOfLocalizations k) = k |
Besicovitch.TauPackage.color.eq_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(x : Ordinal.{u}),
p.color x =
sInf
(Set.univ \
⋃ j,
⋃ (_ :
(Metric.closedBall (p.c (p.index ↑j)) (p.r (p.index ↑j)) ∩
Metric.closedBall (p.c (p.index x)) (p.r (p.index x))).Nonempty),
{p.color ↑j}) |
PiTensorProduct.dualDistribEquivOfBasis_symm_apply | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_1} {R : Type u_2} {κ : ι → Type u_3} {M : ι → Type u_4} [inst : CommRing R]
[inst_1 : (i : ι) → AddCommGroup (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι]
[inst_4 : ∀ (i : ι), Finite (κ i)] (b : (i : ι) → Module.Basis (κ i) R (M i))
(a : Module.Dual R (PiTensorProduct R fun i => M i)),
(PiTensorProduct.dualDistribEquivOfBasis b).symm a = (PiTensorProduct.dualDistribInvOfBasis b) a |
FractionalIdeal.ne_zero_of_mul_eq_one | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
(I J : FractionalIdeal (nonZeroDivisors R₁) K), I * J = 1 → I ≠ 0 |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.x_mul_y_mul_z_eq_u_mul_w_cube._simp_1_8 | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution hζ)
[inst_1 : NumberField K] [inst_2 : IsCyclotomicExtension {3} ℚ K],
(hζ.toInteger - 1) ^ (3 * S.multiplicity - 2) * FermatLastTheoremForThreeGen.Solution.x✝ S = S.a + S.b |
Matrix.isUnit_charpolyRev_of_isNilpotent | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n] {M : Matrix n n R},
IsNilpotent M → IsUnit M.charpolyRev |
Polynomial.natDegree_mul_C_eq_of_mul_ne_zero | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R},
p.leadingCoeff * a ≠ 0 → (p * Polynomial.C a).natDegree = p.natDegree |
PartialEquiv.transEquiv._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (e : PartialEquiv α β) (f' : β ≃ γ),
↑(e.trans f'.toPartialEquiv).symm = ↑(e.trans f'.toPartialEquiv).symm |
Lean.Meta.Simp.Stats.diag | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Stats → Lean.Meta.Simp.Diagnostics |
Homeomorph.toEquiv_piCongrLeft | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι : Type u_7} {ι' : Type u_8} {Y : ι' → Type u_9} [inst : (j : ι') → TopologicalSpace (Y j)] (e : ι ≃ ι'),
(Homeomorph.piCongrLeft e).toEquiv = Equiv.piCongrLeft Y e |
Stream'.cons_injective2 | Mathlib.Data.Stream.Init | ∀ {α : Type u}, Function.Injective2 Stream'.cons |
DirectSum.decomposeLinearEquiv_apply | Mathlib.Algebra.DirectSum.Decomposition | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (ℳ : ι → Submodule R M) [inst_4 : DirectSum.Decomposition ℳ] (m : M),
(DirectSum.decomposeLinearEquiv ℳ) m = (DirectSum.decompose ℳ) m |
Lean.Grind.CommRing.Poly.combine.go.match_1.congr_eq_4 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) (p₁ p₂ : Lean.Grind.CommRing.Poly)
(h_1 : (k₁ k₂ : ℤ) → motive (Lean.Grind.CommRing.Poly.num k₁) (Lean.Grind.CommRing.Poly.num k₂))
(h_2 :
(k₁ k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(p₂ : Lean.Grind.CommRing.Poly) →
motive (Lean.Grind.CommRing.Poly.num k₁) (Lean.Grind.CommRing.Poly.add k₂ m₂ p₂))
(h_3 :
(k₁ : ℤ) →
(m₁ : Lean.Grind.CommRing.Mon) →
(p₁ : Lean.Grind.CommRing.Poly) →
(k₂ : ℤ) → motive (Lean.Grind.CommRing.Poly.add k₁ m₁ p₁) (Lean.Grind.CommRing.Poly.num k₂))
(h_4 :
(k₁ : ℤ) →
(m₁ : Lean.Grind.CommRing.Mon) →
(p₁ : Lean.Grind.CommRing.Poly) →
(k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(p₂ : Lean.Grind.CommRing.Poly) →
motive (Lean.Grind.CommRing.Poly.add k₁ m₁ p₁) (Lean.Grind.CommRing.Poly.add k₂ m₂ p₂))
(k₁ : ℤ) (m₁ : Lean.Grind.CommRing.Mon) (p₁_1 : Lean.Grind.CommRing.Poly) (k₂ : ℤ) (m₂ : Lean.Grind.CommRing.Mon)
(p₂_1 : Lean.Grind.CommRing.Poly),
p₁ = Lean.Grind.CommRing.Poly.add k₁ m₁ p₁_1 →
p₂ = Lean.Grind.CommRing.Poly.add k₂ m₂ p₂_1 →
(match p₁, p₂ with
| Lean.Grind.CommRing.Poly.num k₁, Lean.Grind.CommRing.Poly.num k₂ => h_1 k₁ k₂
| Lean.Grind.CommRing.Poly.num k₁, Lean.Grind.CommRing.Poly.add k₂ m₂ p₂ => h_2 k₁ k₂ m₂ p₂
| Lean.Grind.CommRing.Poly.add k₁ m₁ p₁, Lean.Grind.CommRing.Poly.num k₂ => h_3 k₁ m₁ p₁ k₂
| Lean.Grind.CommRing.Poly.add k₁ m₁ p₁, Lean.Grind.CommRing.Poly.add k₂ m₂ p₂ => h_4 k₁ m₁ p₁ k₂ m₂ p₂) ≍
h_4 k₁ m₁ p₁_1 k₂ m₂ p₂_1 |
ContinuousLinearMap.compContinuousMultilinearMapL._proof_1 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ (𝕜 : Type u_4) {ι : Type u_1} (E : ι → Type u_2) (F : Type u_5) (G : Type u_3) [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopologicalAddGroup F] [inst_8 : AddCommGroup G] [inst_9 : Module 𝕜 G] [inst_10 : TopologicalSpace G]
[inst_11 : IsTopologicalAddGroup G] (g : F →L[𝕜] G) (x x_1 : ContinuousMultilinearMap 𝕜 E F),
g.compContinuousMultilinearMap (x + x_1) = g.compContinuousMultilinearMap x + g.compContinuousMultilinearMap x_1 |
_private.Mathlib.Order.GaloisConnection.Defs.0.GaloisConnection._proof_2 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (l : α → β) (u : β → α),
(∀ (a : β) (b : α), u a ≤ b ↔ a ≤ l b) = ∀ (a : α) (b : β), b ≤ l a ↔ u b ≤ a |
SeparationQuotient.instAddSemigroup.eq_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddSemigroup M] [inst_2 : ContinuousAdd M],
SeparationQuotient.instAddSemigroup = Function.Surjective.addSemigroup SeparationQuotient.mk ⋯ ⋯ |
Flow.mk | Mathlib.Dynamics.Flow | {τ : Type u_1} →
[inst : TopologicalSpace τ] →
[inst_1 : AddMonoid τ] →
[inst_2 : ContinuousAdd τ] →
{α : Type u_2} →
[inst_3 : TopologicalSpace α] →
(toFun : τ → α → α) →
Continuous (Function.uncurry toFun) →
(∀ (t₁ t₂ : τ) (x : α), toFun (t₁ + t₂) x = toFun t₁ (toFun t₂ x)) →
(∀ (x : α), toFun 0 x = x) → Flow τ α |
BitVec.getMsbD_or | Init.Data.BitVec.Lemmas | ∀ {w i : ℕ} {x y : BitVec w}, (x ||| y).getMsbD i = (x.getMsbD i || y.getMsbD i) |
CategoryTheory.Limits.colimit.isoColimitCocone.eq_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
(t : CategoryTheory.Limits.ColimitCocone F),
CategoryTheory.Limits.colimit.isoColimitCocone t =
(CategoryTheory.Limits.colimit.isColimit F).coconePointUniqueUpToIso t.isColimit |
Submodule.toLocalizedQuotient' | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_5} →
(S : Type u_6) →
{M : Type u_7} →
{N : Type u_8} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
[inst_6 : Algebra R S] →
[inst_7 : Module S N] →
[inst_8 : IsScalarTower R S N] →
(p : Submonoid R) →
[inst_9 : IsLocalization p S] →
(f : M →ₗ[R] N) →
[inst_10 : IsLocalizedModule p f] →
(M' : Submodule R M) → M ⧸ M' →ₗ[R] N ⧸ Submodule.localized' S p f M' |
String.reduceNe._regBuiltin.String.reduceNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.731978007._hygCtx._hyg.24 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit |
Quantale.noConfusion | Mathlib.Algebra.Order.Quantale | {P : Sort u} →
{α : Type u_1} →
{inst : Semigroup α} →
{inst_1 : CompleteLattice α} →
{inst_2 : IsQuantale α} →
{t : Quantale α} →
{α' : Type u_1} →
{inst' : Semigroup α'} →
{inst'_1 : CompleteLattice α'} →
{inst'_2 : IsQuantale α'} →
{t' : Quantale α'} →
α = α' →
inst ≍ inst' → inst_1 ≍ inst'_1 → inst_2 ≍ inst'_2 → t ≍ t' → Quantale.noConfusionType P t t' |
NNReal.natCast_iSup | Mathlib.Data.NNReal.Basic | ∀ {ι : Sort u_3} (f : ι → ℕ), ↑(⨆ i, f i) = ⨆ i, ↑(f i) |
MoritaEquivalence.mk.inj | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u₀} {inst : CommSemiring R} {A : Type u₁} {inst_1 : Ring A} {inst_2 : Algebra R A} {B : Type u₂}
{inst_3 : Ring B} {inst_4 : Algebra R B} {eqv : ModuleCat A ≌ ModuleCat B}
{linear : autoParam (CategoryTheory.Functor.Linear R eqv.functor) MoritaEquivalence.linear._autoParam}
{eqv_1 : ModuleCat A ≌ ModuleCat B}
{linear_1 : autoParam (CategoryTheory.Functor.Linear R eqv_1.functor) MoritaEquivalence.linear._autoParam},
{ eqv := eqv, linear := linear } = { eqv := eqv_1, linear := linear_1 } → eqv = eqv_1 |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.instBEqKey.beq._sparseCasesOn_3 | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.Key → Sort u} →
(t : Lean.Meta.LazyDiscrTree.Key) →
((a : Lean.Literal) → motive (Lean.Meta.LazyDiscrTree.Key.lit a)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
Subgroup.mulSingle_mem_pi | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → Subgroup (f i)} (i : η) (x : f i), Pi.mulSingle i x ∈ Subgroup.pi I H ↔ i ∈ I → x ∈ H i |
_private.Mathlib.CategoryTheory.EssentialImage.0.CategoryTheory.Functor.essImage_comp_apply_of_essSurj.match_1_3 | Mathlib.CategoryTheory.EssentialImage | ∀ {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} (Y : D)
(motive : F.essImage Y → Prop) (x : F.essImage Y), (∀ (Z : C) (e' : F.obj Z ≅ Y), motive ⋯) → motive x |
List.transpose.go.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : Id (Array (List α) × List α) → Sort u_2) →
(x : Id (Array (List α) × List α)) → ((acc : Array (List α)) → (l : List α) → motive (acc, l)) → motive x |
Lean.Meta.Instances._sizeOf_1 | Lean.Meta.Instances | Lean.Meta.Instances → ℕ |
Rep.FiniteCyclicGroup.chainComplexFunctor_map_f | Mathlib.RepresentationTheory.Homological.FiniteCyclic | ∀ (k : Type u) {G : Type u} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (g : G) {X Y : Rep k G}
(f : X ⟶ Y) (i : ℕ), ((Rep.FiniteCyclicGroup.chainComplexFunctor k g).map f).f i = f |
CategoryTheory.Monoidal.leftRigidFunctorCategory | Mathlib.CategoryTheory.Monoidal.Rigid.FunctorCategory | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Groupoid C] →
[inst_1 : CategoryTheory.Category.{v_1, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
[CategoryTheory.LeftRigidCategory D] → CategoryTheory.LeftRigidCategory (CategoryTheory.Functor C D) |
Submodule.orthogonal_orthogonal | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [K.HasOrthogonalProjection], Kᗮᗮ = K |
instReprAtomBool | Init.Data.Repr | ReprAtom Bool |
AddMonoidAlgebra.exists_supDegree_mem_support | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : Semiring R] [inst_1 : LinearOrder B] [inst_2 : OrderBot B]
{p : AddMonoidAlgebra R A} (D : A → B), p ≠ 0 → ∃ a ∈ p.support, AddMonoidAlgebra.supDegree D p = D a |
_private.Lean.Elab.DocString.0.Lean.Doc.elabBlocks'.match_5 | Lean.Elab.DocString | (motive :
Option
(Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) ×
Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)) →
Sort u_1) →
(x :
Option
(Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) ×
Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty))) →
(Unit → motive none) →
((a :
Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) ×
Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)) →
motive (some a)) →
motive x |
Ideal.quotEquivPowQuotPowSucc._proof_2 | Mathlib.RingTheory.Ideal.IsPrincipalPowQuotient | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R |
smooth_functions_tower | Mathlib.Geometry.Manifold.DerivationBundle | ∀ (𝕜 : 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],
IsScalarTower 𝕜 (ContMDiffMap I (modelWithCornersSelf 𝕜 𝕜) M 𝕜 ↑⊤) (ContMDiffMap I (modelWithCornersSelf 𝕜 𝕜) M 𝕜 ↑⊤) |
uniformContinuousOn_iff_restrict | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} {s : Set α},
UniformContinuousOn f s ↔ UniformContinuous (s.restrict f) |
Int.ediv_dvd_iff_dvd_mul._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, b ∣ a → b ≠ 0 → (a / b ∣ c) = (a ∣ b * c) |
ContinuousMap.compStarAlgHom._proof_6 | Mathlib.Topology.ContinuousMap.Star | ∀ (X : Type u_1) {𝕜 : Type u_4} {A : Type u_2} {B : Type u_3} [inst : TopologicalSpace X] [inst_1 : CommSemiring 𝕜]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring A] [inst_4 : Star A] [inst_5 : ContinuousStar A]
[inst_6 : Algebra 𝕜 A] [inst_7 : TopologicalSpace B] [inst_8 : Semiring B] [inst_9 : Star B]
[inst_10 : ContinuousStar B] [inst_11 : Algebra 𝕜 B] (φ : A →⋆ₐ[𝕜] B) (hφ : Continuous ⇑φ) (f : C(X, A)),
{ toFun := ⇑φ, continuous_toFun := hφ }.comp (star f) = star ({ toFun := ⇑φ, continuous_toFun := hφ }.comp f) |
AugmentedSimplexCategory.inr_comp_associator_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (x y z : AugmentedSimplexCategory) {Z : AugmentedSimplexCategory}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj x (CategoryTheory.MonoidalCategoryStruct.tensorObj y z) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategoryStruct.tensorObj x y).inr z)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator x y z).hom h) =
CategoryTheory.CategoryStruct.comp (y.inr z)
(CategoryTheory.CategoryStruct.comp (x.inr (CategoryTheory.MonoidalCategoryStruct.tensorObj y z)) h) |
Lean.IndirectModUse.recOn | Lean.ExtraModUses | {motive : Lean.IndirectModUse → Sort u} →
(t : Lean.IndirectModUse) →
((kind : String) → (declName : Lean.Name) → motive { kind := kind, declName := declName }) → motive t |
CategoryTheory.effectiveEpiFamilyStructOfIsColimit._proof_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} {α : Type u_3} (X : α → C)
(π : (a : α) → X a ⟶ B) (obj : CategoryTheory.Over B) (hT : (CategoryTheory.Sieve.generateFamily X π).arrows obj.hom),
∃ g, CategoryTheory.CategoryStruct.comp g (π (Exists.choose hT)) = obj.hom |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.