name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
OreLocalization.«_aux_Mathlib_GroupTheory_OreLocalization_Basic___macroRules_OreLocalization_term_-ₒ__1» | Mathlib.GroupTheory.OreLocalization.Basic | Lean.Macro |
_private.Lean.Elab.Task.0.Lean.Elab.Tactic.TacticM.asTask.match_1 | Lean.Elab.Task | {α : Type} →
(motive : α × Lean.Elab.Tactic.State → Sort u_1) →
(__discr : α × Lean.Elab.Tactic.State) → ((a : α) → (s : Lean.Elab.Tactic.State) → motive (a, s)) → motive __discr |
_private.Std.Tactic.BVDecide.LRAT.Internal.Convert.0.Std.Tactic.BVDecide.LRAT.Internal.CNF.unsat_of_convertLRAT_unsat._simp_1_5 | Std.Tactic.BVDecide.LRAT.Internal.Convert | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' |
AlgHom.coe_prod | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : A →ₐ[R] C), ⇑(f.prod g) = Pi.prod ⇑f ⇑g |
PiLp.norm_toLp_const | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {p : ENNReal} {ι : Type u_2} [hp : Fact (1 ≤ p)] [inst : Fintype ι] {β : Type u_5}
[inst_1 : SeminormedAddCommGroup β],
p ≠ ⊤ → ∀ (b : β), ‖WithLp.toLp p (Function.const ι b)‖ = ↑↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖ |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Type |
_private.Mathlib.Algebra.Lie.Abelian.0.LieSubalgebra.isLieAbelian_lieSpan_iff._simp_1_3 | Mathlib.Algebra.Lie.Abelian | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) |
RingHom.IsStableUnderBaseChange | Mathlib.RingTheory.RingHomProperties | ({R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) → Prop |
Filter.coprod_inf_prod_le | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f₁ f₂ : Filter α) (g₁ g₂ : Filter β), f₁.coprod g₁ ⊓ f₂ ×ˢ g₂ ≤ f₁ ×ˢ g₂ ⊔ f₂ ×ˢ g₁ |
Lean.Lsp.SignatureHelpTriggerKind.invoked.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SignatureHelpTriggerKind.invoked = 1 |
PSigma.Lex.linearOrder._proof_1 | Mathlib.Data.PSigma.Order | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : LinearOrder ι] [inst_1 : (i : ι) → LinearOrder (α i)]
(a b : Σₗ' (i : ι), α i), a ≤ b ∨ b ≤ a |
_private.Mathlib.Data.Set.Insert.0.Set.subset_pair_iff._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a b : α}, s ⊆ {a, b} ↔ ∀ x ∈ s, x = a ∨ x = b |
Order.Icc_subset_Ioc_pred_left | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a b : α),
Set.Icc a b ⊆ Set.Ioc (Order.pred a) b |
Mathlib.Tactic.Ring.sub_congr | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_2} [inst : CommRing R] {a a' b b' c : R}, a = a' → b = b' → a' - b' = c → a - b = c |
MeasCat | Mathlib.MeasureTheory.Category.MeasCat | Type (u + 1) |
Lean.Meta.DefEqContext._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.DefEqContext → ℕ |
Lean.OLeanLevel.server.elim | Lean.Environment | {motive : Lean.OLeanLevel → Sort u} → (t : Lean.OLeanLevel) → t.ctorIdx = 1 → motive Lean.OLeanLevel.server → motive t |
Std.ExtHashMap.getKey!_eq_of_contains | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
[inst_1 : Inhabited α] {k : α}, m.contains k = true → m.getKey! k = k |
TopologicalSpace.IsTopologicalBasis.recOn | Mathlib.Topology.Bases | {α : Type u} →
[t : TopologicalSpace α] →
{s : Set (Set α)} →
{motive : TopologicalSpace.IsTopologicalBasis s → Sort u_1} →
(t_1 : TopologicalSpace.IsTopologicalBasis s) →
((exists_subset_inter : ∀ t₁ ∈ s, ∀ t₂ ∈ s, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂) →
(sUnion_eq : ⋃₀ s = Set.univ) → (eq_generateFrom : t = TopologicalSpace.generateFrom s) → motive ⋯) →
motive t_1 |
_private.Init.Data.Array.Attach.0.Array.pmap_eq_self._simp_1_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {l : List α} {p : α → Prop} {hp : ∀ a ∈ l, p a} {f : (a : α) → p a → α},
(List.pmap f l hp = l) = ∀ (a : α) (h : a ∈ l), f a ⋯ = a |
Lean.Elab.Do.ReturnCont.mk.injEq | Lean.Elab.Do.Basic | ∀ (resultType : Lean.Expr) (k : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr) (resultType_1 : Lean.Expr)
(k_1 : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr),
({ resultType := resultType, k := k } = { resultType := resultType_1, k := k_1 }) =
(resultType = resultType_1 ∧ k = k_1) |
CategoryTheory.shiftEquiv'._proof_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ {A : Type u_1} [inst : AddGroup A] (i j : A), i + j = 0 → j + i = 0 |
CategoryTheory.MonoidalCategory.MonoidalRightAction.monoidalOppositeRightAction_actionHomLeft | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {d d' : D} (f : d ⟶ d') (c : Cᴹᵒᵖ),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f c =
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight c.unmop f |
Lean.Elab.Tactic.Rfl.evalApplyRfl._regBuiltin.Lean.Elab.Tactic.Rfl.evalApplyRfl_1 | Lean.Elab.Tactic.Rfl | IO Unit |
LinearMap.applyₗ._proof_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {M₂ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂] [inst_2 : Module R M₂],
SMulCommClass R R M₂ |
Representation.ofMulActionSelfAsModuleEquiv._proof_4 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : CommSemiring k] [inst_1 : Group G],
Function.LeftInverse (Representation.ofMulAction k G G).asModuleEquiv.toAddEquiv.invFun
(Representation.ofMulAction k G G).asModuleEquiv.toAddEquiv.toFun |
AlgebraicGeometry.Scheme.Cover.copy._proof_2 | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [P.RespectsIso] {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) (J : Type u_2)
(obj : J → AlgebraicGeometry.Scheme) (map : (i : J) → obj i ⟶ X) (e₁ : J ≃ 𝒰.I₀) (e₂ : (i : J) → obj i ≅ 𝒰.X (e₁ i)),
(∀ (i : J), map i = CategoryTheory.CategoryStruct.comp (e₂ i).hom (𝒰.f (e₁ i))) →
{ I₀ := J, X := obj, f := map }.presieve₀ ∈ (AlgebraicGeometry.Scheme.precoverage P).coverings X |
Std.DHashMap.Const.get!_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {k : α},
k ∉ m₂ → Std.DHashMap.Const.get! (m₁.union m₂) k = Std.DHashMap.Const.get! m₁ k |
absConvexHull_nonempty | Mathlib.Analysis.LocallyConvex.AbsConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : AddCommMonoid E]
[inst_3 : PartialOrder 𝕜] {s : Set E}, ((absConvexHull 𝕜) s).Nonempty ↔ s.Nonempty |
ZFSet.vonNeumann_inj._simp_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {a b : Ordinal.{u}}, (ZFSet.vonNeumann a = ZFSet.vonNeumann b) = (a = b) |
CategoryTheory.PreOneHypercover.map_Y | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (x x_1 : E.I₀) (j : E.I₁ x x_1),
(E.map F).Y j = F.obj (E.Y j) |
Polynomial.roots_expand_map_frobenius | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p : ℕ} [inst_2 : ExpChar R p] {f : Polynomial R}
[PerfectRing R p], Multiset.map (⇑(frobenius R p)) ((Polynomial.expand R p) f).roots = p • f.roots |
instAddCommSemigroupOrderDual | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : AddCommSemigroup α] → AddCommSemigroup αᵒᵈ |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.restoreM_ReaderT._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) |
Ideal.instIsTwoSided | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : CommSemiring α] (I : Ideal α), I.IsTwoSided |
_private.Mathlib.AlgebraicTopology.DoldKan.NCompGamma.0.Fin.succ.match_1.splitter | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | {n : ℕ} → (motive : Fin n → Sort u_1) → (x : Fin n) → ((i : ℕ) → (h : i < n) → motive ⟨i, h⟩) → motive x |
CategoryTheory.Quiv.lift_map | Mathlib.CategoryTheory.Category.Quiv | ∀ {V : Type u} [inst : Quiver V] {C : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} C] (F : V ⥤q C)
{X Y : CategoryTheory.Paths V} (f : X ⟶ Y),
(CategoryTheory.Quiv.lift F).map f = CategoryTheory.composePath (F.mapPath f) |
_private.Mathlib.Tactic.Use.0.Mathlib.Tactic.applyTheConstructor.match_9 | Mathlib.Tactic.Use | (motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) → ((ctor : Lean.Name) → motive [ctor]) → ((x : List Lean.Name) → motive x) → motive x |
Lean.Doc.Data.ConvTactic.casesOn | Lean.Elab.DocString.Builtin | {motive : Lean.Doc.Data.ConvTactic → Sort u} →
(t : Lean.Doc.Data.ConvTactic) → ((name : Lean.Name) → motive { name := name }) → motive t |
Std.DTreeMap.Raw.Equiv.maxKey!_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.maxKey! = t₂.maxKey! |
CochainComplex.shiftFunctorAdd'._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (n₁ n₂ n₁₂ : ℤ)
(h : n₁ + n₂ = n₁₂) (K : CochainComplex C ℤ) (x x_1 : ℤ),
CategoryTheory.CategoryStruct.comp ((fun i => K.shiftFunctorObjXIso n₁₂ i (i + n₂ + n₁) ⋯) x).hom
((((CochainComplex.shiftFunctor C n₁).comp (CochainComplex.shiftFunctor C n₂)).obj K).d x x_1) =
CategoryTheory.CategoryStruct.comp (((CochainComplex.shiftFunctor C n₁₂).obj K).d x x_1)
((fun i => K.shiftFunctorObjXIso n₁₂ i (i + n₂ + n₁) ⋯) x_1).hom |
ModN.basis._proof_7 | Mathlib.LinearAlgebra.FreeModule.ModN | ∀ {G : Type u_1} [inst : AddCommGroup G] {n : ℕ} [NeZero n] {ι : Type u_2} (b : Module.Basis ι ℤ G)
(hker :
((LinearMap.lsmul ℤ G) ↑n).range ≤
(Finsupp.mapRange.linearMap (Int.castAddHom (ZMod n)).toIntLinearMap ∘ₗ ↑b.repr).ker),
Function.Injective
⇑(AddMonoidHom.toZModLinearMap n
(((LinearMap.lsmul ℤ G) ↑n).range.liftQ
(Finsupp.mapRange.linearMap (Int.castAddHom (ZMod n)).toIntLinearMap ∘ₗ ↑b.repr) hker).toAddMonoidHom) ∧
Function.Surjective
⇑(AddMonoidHom.toZModLinearMap n
(((LinearMap.lsmul ℤ G) ↑n).range.liftQ
(Finsupp.mapRange.linearMap (Int.castAddHom (ZMod n)).toIntLinearMap ∘ₗ ↑b.repr) hker).toAddMonoidHom) |
deriv_neg_left_of_sign_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {x₀ : ℝ},
(∀ᶠ (x : ℝ) in nhdsWithin x₀ {x₀}ᶜ, SignType.sign (deriv f x) = SignType.sign (x - x₀)) →
∀ᶠ (b : ℝ) in nhdsWithin x₀ (Set.Iio x₀), deriv f b < 0 |
MeasureTheory.stoppedValue.congr_simp | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] (u u_1 : ι → Ω → β),
u = u_1 →
∀ (τ τ_1 : Ω → WithTop ι),
τ = τ_1 → ∀ (a a_1 : Ω), a = a_1 → MeasureTheory.stoppedValue u τ a = MeasureTheory.stoppedValue u_1 τ_1 a_1 |
_private.Aesop.Script.OptimizeSyntax.0.Aesop.optimizeFocusRenameI.match_1 | Aesop.Script.OptimizeSyntax | (motive : Option (Array (Lean.TSyntax `ident)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `ident))) →
((ns : Array (Lean.TSyntax `ident)) → motive (some ns)) → (Unit → motive none) → motive x |
SimpleGraph.Walk.takeUntil_takeUntil | Mathlib.Combinatorics.SimpleGraph.Connectivity.WalkDecomp | ∀ {V : Type u} {G : SimpleGraph V} {v u : V} [inst : DecidableEq V] {w x : V} (p : G.Walk u v) (hw : w ∈ p.support)
(hx : x ∈ (p.takeUntil w hw).support), (p.takeUntil w hw).takeUntil x hx = p.takeUntil x ⋯ |
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.rankAtStalk_eq_zero_iff_notMem_support._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
[Module.Finite R M], Module.rank R M = ↑(Module.finrank R M) |
CategoryTheory.Functor.leibnizPushout_obj_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) [inst_3 : CategoryTheory.Limits.HasPushouts C₃]
(f₁ : CategoryTheory.Arrow C₁) (f₂ : CategoryTheory.Arrow C₂),
(F.leibnizPushout.obj f₁).obj f₂ =
CategoryTheory.Arrow.mk (CategoryTheory.Functor.PushoutObjObj.ofHasPushout F f₁.hom f₂.hom).ι |
Module.Injective.extension_property | Mathlib.Algebra.Module.Injective | ∀ (R : Type uR) [inst : Ring R] [Small.{uM, uR} R] (M : Type uM) [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inj : Module.Injective R M] (P : Type uP) [inst_4 : AddCommGroup P] [inst_5 : Module R P] (P' : Type uP')
[inst_6 : AddCommGroup P'] [inst_7 : Module R P'] (f : P →ₗ[R] P'),
Function.Injective ⇑f → ∀ (g : P →ₗ[R] M), ∃ h, h ∘ₗ f = g |
Nat.ModEq.of_natCast | Mathlib.Data.Nat.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoidWithOne M] [CharZero M] {a b n : ℕ}, ↑a ≡ ↑b [PMOD ↑n] → a ≡ b [MOD n] |
RingQuot.Rel.sub_left | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Ring R] {r : R → R → Prop} ⦃a b c : R⦄, RingQuot.Rel r a b → RingQuot.Rel r (a - c) (b - c) |
Multiset.coe_countP | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (l : List α),
Multiset.countP p ↑l = List.countP (fun b => decide (p b)) l |
MeasurableEmbedding.schroederBernstein._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α} {A B : Set α}, A ⊆ B → (g '' (f '' A)ᶜ)ᶜ ⊆ (g '' (f '' B)ᶜ)ᶜ |
Ring.ordMonoidWithZeroHom._proof_5 | Mathlib.RingTheory.OrderOfVanishing | ∀ (R : Type u_1) [inst : CommRing R] (x y : R),
(if x * y ∈ nonZeroDivisors R then
(WithZero.map' (AddMonoidHom.toMultiplicative (Nat.castAddMonoidHom ℤ))) (Ring.ord R (x * y))
else 0) =
(if x ∈ nonZeroDivisors R then
(WithZero.map' (AddMonoidHom.toMultiplicative (Nat.castAddMonoidHom ℤ))) (Ring.ord R x)
else 0) *
if y ∈ nonZeroDivisors R then
(WithZero.map' (AddMonoidHom.toMultiplicative (Nat.castAddMonoidHom ℤ))) (Ring.ord R y)
else 0 |
DyckWord.rec | Mathlib.Combinatorics.Enumerative.DyckWord | {motive : DyckWord → Sort u} →
((toList : List DyckStep) →
(count_U_eq_count_D : List.count DyckStep.U toList = List.count DyckStep.D toList) →
(count_D_le_count_U :
∀ (i : ℕ), List.count DyckStep.D (List.take i toList) ≤ List.count DyckStep.U (List.take i toList)) →
motive
{ toList := toList, count_U_eq_count_D := count_U_eq_count_D, count_D_le_count_U := count_D_le_count_U }) →
(t : DyckWord) → motive t |
SetLike.ext_iff | Mathlib.Data.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, p = q ↔ ∀ (x : B), x ∈ p ↔ x ∈ q |
Matroid.closure_subset_closure_iff_subset_closure._auto_1 | Mathlib.Combinatorics.Matroid.Closure | Lean.Syntax |
ZFSet.empty_subset._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x : ZFSet.{u}), (∅ ⊆ x) = True |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_12 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo hi : Fin as.size), (↑lo + ↑hi) / 2 = ↑lo → ↑lo + 1 ≤ as.size |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.equation_zero._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R},
P 2 = 0 → W'.Equation P = (P 1 ^ 2 = P 0 ^ 3) |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.Tendsto.atTop_mul_const_of_neg'._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] {l : Filter α}
{f : α → G}, Filter.Tendsto (fun x => -f x) l Filter.atTop = Filter.Tendsto f l Filter.atBot |
AddCommGrpCat.leftExactFunctorForgetEquivalence.unitIsoAux._proof_2 | Mathlib.Algebra.Category.Grp.LeftExactFunctor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C] (F : CategoryTheory.Functor C AddCommGrpCat)
[inst_3 : CategoryTheory.Limits.PreservesFiniteLimits F] (X : C),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one Multiplicative.toAdd.toIso.hom =
CategoryTheory.MonObj.one |
UpperSet.addCommSemigroup | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} →
[inst : AddCommGroup α] → [inst_1 : Preorder α] → [IsOrderedAddMonoid α] → AddCommSemigroup (UpperSet α) |
NonUnitalContinuousFunctionalCalculus.recOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : Nontrivial R] →
[inst_2 : StarRing R] →
[inst_3 : MetricSpace R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : ContinuousStar R] →
[inst_6 : NonUnitalRing A] →
[inst_7 : StarRing A] →
[inst_8 : TopologicalSpace A] →
[inst_9 : Module R A] →
[inst_10 : IsScalarTower R A A] →
[inst_11 : SMulCommClass R A A] →
{motive : NonUnitalContinuousFunctionalCalculus R A p → Sort u} →
(t : NonUnitalContinuousFunctionalCalculus R A p) →
((predicate_zero : p 0) →
[compactSpace_quasispectrum : ∀ (a : A), CompactSpace ↑(quasispectrum R a)] →
(exists_cfc_of_predicate :
∀ (a : A),
p a →
∃ φ,
Continuous ⇑φ ∧
Function.Injective ⇑φ ∧
φ
{
toContinuousMap :=
ContinuousMap.restrict (quasispectrum R a)
(ContinuousMap.id R),
map_zero' := ⋯ } =
a ∧
(∀ (f : ContinuousMapZero (↑(quasispectrum R a)) R),
quasispectrum R (φ f) = Set.range ⇑f) ∧
∀ (f : ContinuousMapZero (↑(quasispectrum R a)) R), p (φ f)) →
motive ⋯) →
motive t |
Std.DHashMap.Internal.Raw₀.getD_inter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[inst_2 : LawfulBEq α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β k},
(m₁.inter m₂).getD k fallback = if m₂.contains k = true then m₁.getD k fallback else fallback |
CategoryTheory.Limits.coneOfIsSplitMono_π_app | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.IsSplitMono f]
(X_1 : CategoryTheory.Limits.WalkingParallelPair),
(CategoryTheory.Limits.coneOfIsSplitMono f).π.app X_1 =
CategoryTheory.Limits.WalkingParallelPair.casesOn (motive := fun t =>
X_1 = t →
(((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj X).obj X_1 ⟶
(CategoryTheory.Limits.parallelPair (CategoryTheory.CategoryStruct.id Y)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.retraction f) f)).obj
X_1))
X_1 (fun h => ⋯ ▸ f) (fun h => ⋯ ▸ CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y)) ⋯ |
CategoryTheory.SmallObject.SuccStruct.ιIterationFunctor._proof_1 | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} 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] (x x_1 : J) (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const J).obj Φ.X₀).map f)
(CategoryTheory.CategoryStruct.comp (Φ.iterationFunctorObjBotIso J).inv
((Φ.iterationFunctor J).map (CategoryTheory.homOfLE ⋯))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (Φ.iterationFunctorObjBotIso J).inv
((Φ.iterationFunctor J).map (CategoryTheory.homOfLE ⋯)))
((Φ.iterationFunctor J).map f) |
CategoryTheory.Limits.IsColimit.ofCoconeUncurry._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_2} {K : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {D : CategoryTheory.Limits.DiagramOfCocones F}
(Q : (j : J) → CategoryTheory.Limits.IsColimit (D.obj j))
(s : CategoryTheory.Limits.Cocone (CategoryTheory.Functor.uncurry.obj F)) {j j' : J} (f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp (D.coconePoints.map f)
((Q j').desc
((CategoryTheory.Limits.Cocone.precompose
(CategoryTheory.NatIso.ofComponents
(fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.Prod.sectR j' K).comp (CategoryTheory.Functor.uncurry.obj F)).obj x))
⋯).inv).obj
(CategoryTheory.Limits.Cocone.whisker (CategoryTheory.Prod.sectR j' K) s))) =
CategoryTheory.CategoryStruct.comp
((Q j).desc
((CategoryTheory.Limits.Cocone.precompose
(CategoryTheory.NatIso.ofComponents
(fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.Prod.sectR j K).comp (CategoryTheory.Functor.uncurry.obj F)).obj x))
⋯).inv).obj
(CategoryTheory.Limits.Cocone.whisker (CategoryTheory.Prod.sectR j K) s)))
(((CategoryTheory.Functor.const J).obj s.pt).map f) |
_private.Mathlib.Data.Seq.Computation.0.Computation.BisimO.match_1.splitter._sparseCasesOn_5 | Mathlib.Data.Seq.Computation | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : β) → motive (Sum.inr val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.Functor.mapProjectiveResolution._proof_4 | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Preadditive C] {D : Type u_2} [inst_3 : CategoryTheory.Category.{u_1, u_2} D]
[inst_4 : CategoryTheory.Limits.HasZeroObject D] [inst_5 : CategoryTheory.Preadditive D]
[inst_6 : CategoryTheory.CategoryWithHomology D] (F : CategoryTheory.Functor C D) [inst_7 : F.Additive]
[F.PreservesHomology] {Z : C} (P : CategoryTheory.ProjectiveResolution Z),
QuasiIso
(CategoryTheory.CategoryStruct.comp ((F.mapHomologicalComplex (ComplexShape.down ℕ)).map P.π)
((HomologicalComplex.singleMapHomologicalComplex F (ComplexShape.down ℕ) 0).hom.app Z)) |
Plausible.Random.randBool | Plausible.Random | {m : Type → Type u_1} → [Monad m] → {g : Type} → [RandomGen g] → Plausible.RandGT g m Bool |
Finsupp.mapRange.addEquiv_toEquiv | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (e : M ≃+ N),
↑(Finsupp.mapRange.addEquiv e) = Finsupp.mapRange.equiv ↑e ⋯ |
Projectivization.Subspace.mem_submodule_iff | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(s : Projectivization.Subspace K V) {v : V} (hv : v ≠ 0),
v ∈ Projectivization.Subspace.submodule s ↔ Projectivization.mk K v hv ∈ s |
_private.Batteries.Data.Array.Scan.0.Array.take_scanl._proof_1_3 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {f : β → α → β} (init : β) (as : Array α),
-1 * ↑as.size + 1 ≤ 0 →
i + 1 = (Array.scanl f init as).size - 1 →
i = as.size - 1 →
∀ (w : ℕ),
w + 1 ≤ ((Array.scanl f init as).extract 0 (i + 1)).size → w < (Array.scanl f init (as.extract 0 i)).size |
CategoryTheory.Functor.lanCompColimIso._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_5} {D : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
[CategoryTheory.Limits.HasColimitsOfShape D H] (G : CategoryTheory.Functor C H),
CategoryTheory.Limits.HasColimit (L.lan.obj G) |
Finset.singletonAddHom | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [inst : DecidableEq α] → [inst_1 : Add α] → α →ₙ+ Finset α |
Lean.IR.CollectUsedDecls.State.order._default | Lean.Compiler.IR.EmitUtil | Array Lean.Name |
CategoryTheory.Functor.OplaxMonoidal.δ_comp_whiskerLeft_δ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj X)
(CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj Y) (F.obj Z)) ⟶
Z_1),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.OplaxMonoidal.δ F X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) (CategoryTheory.Functor.OplaxMonoidal.δ F Y Z))
h) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.OplaxMonoidal.δ F (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Functor.OplaxMonoidal.δ F X Y) (F.obj Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (F.obj X) (F.obj Y) (F.obj Z)).hom h))) |
CategoryTheory.isCoseparator_iff_faithful_preadditiveYoneda | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsCoseparator G ↔ (CategoryTheory.preadditiveYoneda.obj G).Faithful |
PiNat.self_mem_cylinder | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} (x : (n : ℕ) → E n) (n : ℕ), x ∈ PiNat.cylinder x n |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_inter!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
NonarchAddGroupSeminorm.coe_lt_coe | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p q : NonarchAddGroupSeminorm E}, ⇑p < ⇑q ↔ p < q |
Submodule.map | Mathlib.Algebra.Module.Submodule.Map | {R : Type u_1} →
{R₂ : Type u_3} →
{M : Type u_5} →
{M₂ : Type u_7} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
[inst_5 : Module R₂ M₂] →
{σ₁₂ : R →+* R₂} → [RingHomSurjective σ₁₂] → (M →ₛₗ[σ₁₂] M₂) → Submodule R M → Submodule R₂ M₂ |
concaveOn_univ_piecewise_Iic_of_monotoneOn_Iic_antitoneOn_Ici | Mathlib.Analysis.Convex.Piecewise | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : Module 𝕜 E] [PosSMulMono 𝕜 E] [inst_7 : AddCommGroup β]
[inst_8 : PartialOrder β] [IsOrderedAddMonoid β] [inst_10 : Module 𝕜 β] [PosSMulMono 𝕜 β] {e : E} {f g : E → β},
ConcaveOn 𝕜 (Set.Iic e) f →
ConcaveOn 𝕜 (Set.Ici e) g →
MonotoneOn f (Set.Iic e) → AntitoneOn g (Set.Ici e) → f e = g e → ConcaveOn 𝕜 Set.univ ((Set.Iic e).piecewise f g) |
CategoryTheory.Discrete.sumEquiv.match_1 | Mathlib.CategoryTheory.Discrete.SumsProducts | {J : Type u_1} →
{K : Type u_2} →
(motive : J ⊕ K → Sort u_3) →
(t : J ⊕ K) → ((j : J) → motive (Sum.inl j)) → ((k : K) → motive (Sum.inr k)) → motive t |
_private.Mathlib.Data.Set.Accumulate.0.Set.iUnion_accumulate._simp_1_1 | Mathlib.Data.Set.Accumulate | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
TopologicalSpace.ext_isClosed | Mathlib.Topology.Basic | ∀ {X : Type u_2} {t₁ t₂ : TopologicalSpace X}, (∀ (s : Set X), IsClosed s ↔ IsClosed s) → t₁ = t₂ |
CategoryTheory.Subfunctor.Subpresheaf.equalizer.ι | Mathlib.CategoryTheory.Subfunctor.Equalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F₁ F₂ : CategoryTheory.Functor C (Type w)} →
{A : CategoryTheory.Subfunctor F₁} →
(f g : A.toFunctor ⟶ F₂) → (CategoryTheory.Subfunctor.equalizer f g).toFunctor ⟶ A.toFunctor |
unitary.joined | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u v : ↥(unitary A)), ‖↑v - ↑u‖ < 2 → Joined u v |
nonneg_of_mul_nonneg_right | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [PosMulStrictMono R], 0 ≤ a * b → 0 < a → 0 ≤ b |
initFn._@.Mathlib.Tactic.Attr.Register.1131139975._hygCtx._hyg.5 | Mathlib.Tactic.Attr.Register | IO Lean.Meta.SimpExtension |
CategoryTheory.Functor.LaxMonoidal.comp._proof_1 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCategory E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [inst_6 : F.LaxMonoidal] [inst_7 : G.LaxMonoidal]
{X Y : C} (x : X ⟶ Y) (x_1 : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((F.comp G).map x) ((F.comp G).obj x_1))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ G (F.obj Y) (F.obj x_1))
(G.map (CategoryTheory.Functor.LaxMonoidal.μ F Y x_1))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ G (F.obj X) (F.obj x_1))
(G.map (CategoryTheory.Functor.LaxMonoidal.μ F X x_1)))
((F.comp G).map (CategoryTheory.MonoidalCategoryStruct.whiskerRight x x_1)) |
instAssociativeInt8HAdd | Init.Data.SInt.Lemmas | Std.Associative fun x1 x2 => x1 + x2 |
CategoryTheory._aux_Mathlib_CategoryTheory_Category_Basic___macroRules_CategoryTheory_rfl_cat_1 | Mathlib.CategoryTheory.Category.Basic | Lean.Macro |
Finsupp.coe_smul._simp_1 | Mathlib.Data.Finsupp.SMulWithZero | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (b : R) (v : α →₀ M),
b • ⇑v = ⇑(b • v) |
SSet.Subcomplex.Pairing.II | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → Set A.N |
Mathlib.Tactic.Order.AtomicFact.isTop.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (idx : ℕ), sizeOf (Mathlib.Tactic.Order.AtomicFact.isTop idx) = 1 + sizeOf idx |
Std.TreeMap.Raw.instForMProdOfMonad | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} → {m : Type w → Type w₂} → [Monad m] → ForM m (Std.TreeMap.Raw α β cmp) (α × β) |
Std.TreeMap.le_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → ∀ {k : α}, (cmp k t.minKey!).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true |
IsChain.succ | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α}, IsChain r s → IsChain r (SuccChain r s) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.