name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Submodule.starProjection_inner_eq_zero | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E} [inst_3 : K.HasOrthogonalProjection] (v w : E), w ∈ K → inner 𝕜 (v - K.starProjection v) w = 0 |
Std.DHashMap.diff | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Std.DHashMap α β → Std.DHashMap α β → Std.DHashMap α β |
Turing.TM1to0.trAux.eq_6 | Mathlib.Computability.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (M : Λ → Turing.TM1.Stmt Γ Λ σ) (s : Γ) (x : σ),
Turing.TM1to0.trAux M s Turing.TM1.Stmt.halt x = ((none, x), Turing.TM0.Stmt.write s) |
MonomialOrder.div_set | Mathlib.RingTheory.MvPolynomial.Groebner | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommRing R] {B : Set (MvPolynomial σ R)},
(∀ b ∈ B, IsUnit (m.leadingCoeff b)) →
∀ (f : MvPolynomial σ R),
∃ g r,
f = (Finsupp.linearCombination (MvPolynomial σ R) fun b => ↑b) g + r ∧
(∀ (b : ↑B), m.toSyn (m.degree (↑b * g b)) ≤ m.toSyn (m.degree f)) ∧ ∀ c ∈ r.support, ∀ b ∈ B, ¬m.degree b ≤ c |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.kwImpl.makeHint.match_1 | Lean.Elab.DocString.Builtin.Keywords | (motive : Option Lean.Syntax.Range → Sort u_1) →
(range? : Option Lean.Syntax.Range) →
((b e : String.Pos.Raw) → motive (some { start := b, stop := e })) →
((x : Option Lean.Syntax.Range) → motive x) → motive range? |
Lean.Widget.DiffTag.ctorElimType | Lean.Widget.InteractiveCode | {motive : Lean.Widget.DiffTag → Sort u} → ℕ → Sort (max 1 u) |
sup_le_of_le_sdiff_left | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, b ≤ c \ a → a ≤ c → a ⊔ b ≤ c |
Lean.Grind.Linarith.Expr.denote | Init.Grind.Ordered.Linarith | {α : Type u_1} → [Lean.Grind.IntModule α] → Lean.Grind.Linarith.Context α → Lean.Grind.Linarith.Expr → α |
CategoryTheory.Limits.isLimitConeUnopOfCocone_lift | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
(s : CategoryTheory.Limits.Cone F.unop),
(CategoryTheory.Limits.isLimitConeUnopOfCocone F hc).lift s =
(hc.desc (CategoryTheory.Limits.coconeOfConeUnop s)).unop |
Finset.card_neg_le | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Neg α] {s : Finset α}, (-s).card ≤ s.card |
Lean.Server.lookupStatefulLspRequestHandler | Lean.Server.Requests | String → BaseIO (Option Lean.Server.StatefulRequestHandler) |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiNat.firstDiff_comm._simp_1_1 | Mathlib.Topology.MetricSpace.PiNat | ∀ {α : Sort u_1} {a b : α}, (a ≠ b) = (b ≠ a) |
Std.Do.SPred.bientails.eq_1 | Std.Do.SPred.Laws | ∀ (P_2 Q_2 : Std.Do.SPred []), (P_2 ⊣⊢ₛ Q_2) = (P_2.down ↔ Q_2.down) |
Lean.SerialMessage.casesOn | Lean.Message | {motive : Lean.SerialMessage → Sort u} →
(t : Lean.SerialMessage) →
((toBaseMessage : Lean.BaseMessage String) →
(kind : Lean.Name) → motive { toBaseMessage := toBaseMessage, kind := kind }) →
motive t |
_private.Mathlib.Data.List.TakeDrop.0.List.span.loop_eq_take_drop | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} (p : α → Bool) (l₁ l₂ : List α),
List.span.loop p l₁ l₂ = (l₂.reverse ++ List.takeWhile p l₁, List.dropWhile p l₁) |
PartENat.addCommMonoid._proof_1 | Mathlib.Data.Nat.PartENat | ∀ (x : PartENat), nsmulRec 0 x = 0 |
_private.Mathlib.Data.Finset.Filter.0.Finset.filter_nonempty_iff._simp_1_4 | Mathlib.Data.Finset.Filter | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
ContinuousMap.instCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {A : Type u_1} [inst : CStarAlgebra A], IsTopologicalSemiring A |
Stream'.WSeq.bind_assoc._simp_1 | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.WSeq α) (f : α → Stream'.WSeq β) (g : β → Stream'.WSeq γ),
((s.bind f).bind g ~ʷ s.bind fun x => (f x).bind g) = True |
Function.End.mul_def | Mathlib.Algebra.Group.Action.End | ∀ {α : Type u_5} (f g : Function.End α), f * g = f ∘ g |
Aesop.CompleteMatch.mk.inj | Aesop.Forward.Match.Types | ∀ {clusterMatches clusterMatches_1 : Array Aesop.Match},
{ clusterMatches := clusterMatches } = { clusterMatches := clusterMatches_1 } → clusterMatches = clusterMatches_1 |
Std.Time.ValidDate | Std.Time.Date.ValidDate | Bool → Type |
IncidenceAlgebra.ext | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : Zero 𝕜] [inst_1 : LE α] ⦃f g : IncidenceAlgebra 𝕜 α⦄,
(∀ (a b : α), a ≤ b → f a b = g a b) → f = g |
tensorKaehlerQuotKerSqEquiv._proof_4 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (P : Type u_1) (S : Type u_2) [inst : CommRing P] [inst_1 : CommRing S] [inst_2 : Algebra P S],
SMulCommClass (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S S |
invOf_eq_left_inv | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] {a b : α} [inst_1 : Invertible a], b * a = 1 → ⅟a = b |
CategoryTheory.Oplax.StrongTrans.whiskerRight_naturality_naturality_app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {F G : CategoryTheory.OplaxFunctor B CategoryTheory.Cat}
(η : CategoryTheory.Oplax.StrongTrans F G) {a b : B} {a' : CategoryTheory.Cat} {f g : a ⟶ b} (β : f ⟶ g)
(h : G.obj b ⟶ a') (X : ↑(F.obj a)),
CategoryTheory.CategoryStruct.comp (h.toFunctor.map ((η.app b).toFunctor.map ((F.map₂ β).toNatTrans.app X)))
(h.toFunctor.map ((η.naturality g).hom.toNatTrans.app X)) =
CategoryTheory.CategoryStruct.comp (h.toFunctor.map ((η.naturality f).hom.toNatTrans.app X))
(h.toFunctor.map ((G.map₂ β).toNatTrans.app ((η.app a).toFunctor.obj X))) |
_private.Std.Time.Format.Basic.0.Std.Time.instReprText.repr.match_1 | Std.Time.Format.Basic | (motive : Std.Time.Text → Sort u_1) →
(x : Std.Time.Text) →
(Unit → motive Std.Time.Text.short) →
(Unit → motive Std.Time.Text.full) → (Unit → motive Std.Time.Text.narrow) → motive x |
CategoryTheory.Comon.MonOpOpToComonObj | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → CategoryTheory.Mon Cᵒᵖ → CategoryTheory.Comon C |
Std.ExtTreeSet.isSome_min?_of_isSome_min?_erase | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
(t.erase k).min?.isSome = true → t.min?.isSome = true |
TensorProduct.AlgebraTensorModule.map_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : AddCommMonoid P]
[inst_10 : Module R P] [inst_11 : Module A P] [inst_12 : IsScalarTower R A P] [inst_13 : AddCommMonoid Q]
[inst_14 : Module R Q] (f : M →ₗ[A] P) (g : N →ₗ[R] Q) (m : M) (n : N),
(TensorProduct.AlgebraTensorModule.map f g) (m ⊗ₜ[R] n) = f m ⊗ₜ[R] g n |
Set.encard_le_encard_iff_encard_diff_le_encard_diff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, (s ∩ t).Finite → (s.encard ≤ t.encard ↔ (s \ t).encard ≤ (t \ s).encard) |
Set.infs_subset_iff | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] {s t u : Set α}, s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.oangle_smul_add_right_eq_zero_or_eq_pi_iff._simp_1_3 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{v : ι → M} [inst_3 : Fintype ι], (¬LinearIndependent R v) = ∃ g, ∑ i, g i • v i = 0 ∧ ∃ i, g i ≠ 0 |
ContinuousAlgEquiv.image_symm_eq_preimage | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (e : A ≃A[R] B) (S : Set B), ⇑e.symm '' S = ⇑e ⁻¹' S |
DoubleCentralizer.instInhabited | Mathlib.Analysis.CStarAlgebra.Multiplier | {𝕜 : Type u_1} →
{A : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] →
[inst_2 : NormedSpace 𝕜 A] →
[inst_3 : SMulCommClass 𝕜 A A] → [inst_4 : IsScalarTower 𝕜 A A] → Inhabited (DoubleCentralizer 𝕜 A) |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.Key.noConfusion | Lean.Compiler.LCNF.InferBorrow | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.ParamMap.Key✝} → t = t' → Lean.Compiler.LCNF.ParamMap.Key.noConfusionType✝ P t t' |
_private.Mathlib.RingTheory.Adjoin.Basic.0.Subalgebra.adjoin_eq_span_basis._simp_1_1 | Mathlib.RingTheory.Adjoin.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) |
CategoryTheory.Cat.HasLimits.limitCone._proof_2 | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) (j : J)
(X : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)),
CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X X) j (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) j X) |
_private.Init.Data.SInt.Bitwise.0.Int8.or_eq_zero_iff._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) |
Std.DTreeMap.Internal.Impl.Const.alter._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : Type v} →
[Ord α] →
α →
(Option β → Option β) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α (fun x => β) (t.size - 1) (t.size + 1) |
boolRingCatEquivBoolAlg | Mathlib.Algebra.Category.BoolRing | BoolRing ≌ BoolAlg |
_private.Lean.Elab.Util.0.Lean.Elab.getBetterRef.match_1 | Lean.Elab.Util | (motive : Option Lean.Elab.MacroStackElem → Sort u_1) →
(x : Option Lean.Elab.MacroStackElem) →
((elem : Lean.Elab.MacroStackElem) → motive (some elem)) → (Unit → motive none) → motive x |
Fin.div_val | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (a b : Fin n), ↑(a / b) = ↑a / ↑b |
EuclideanSpace.inner_eq_star_dotProduct | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : Fintype ι] (x y : EuclideanSpace 𝕜 ι),
inner 𝕜 x y = y.ofLp ⬝ᵥ star x.ofLp |
AlgebraicGeometry.Scheme.fromSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | (X : AlgebraicGeometry.Scheme) → (x : ↥X) → AlgebraicGeometry.Spec (X.residueField x) ⟶ X |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.cmp_veblenWith.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.eq) (h_2 : Unit → motive Ordering.lt)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.eq with
| Ordering.eq => h_1 ()
| Ordering.lt => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.eqOn_right_half_plane_of_superexponential_decay._simp_1_1 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
MvPowerSeries.support_truncFinset_subset | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : Finset (σ →₀ ℕ)} (p : MvPowerSeries σ R),
((MvPowerSeries.truncFinset R s) p).support ⊆ s |
inf_le_inf | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b c d : α}, b ≤ a → d ≤ c → b ⊓ d ≤ a ⊓ c |
_private.Mathlib.RingTheory.Norm.Transitivity.0.Algebra.Norm.Transitivity.auxMat_blockTriangular._simp_1_2 | Mathlib.RingTheory.Norm.Transitivity | ∀ {a b : Prop}, (¬(a → b)) = (a ∧ ¬b) |
IsCompact.isSigmaCompact | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → IsSigmaCompact s |
List.alternatingProd_cons_cons' | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : One G] [inst_1 : Mul G] [inst_2 : Inv G] (a b : G) (l : List G),
(a :: b :: l).alternatingProd = a * b⁻¹ * l.alternatingProd |
AlgebraicGeometry.mono_pushoutSection_of_isCompact_of_flat_left_of_ringHomFlat | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y S T : AlgebraicGeometry.Scheme} {f : T ⟶ S} {g : Y ⟶ X} {iX : X ⟶ S} {iY : Y ⟶ T}
(H : CategoryTheory.IsPullback g iY iX f) {US : S.Opens} {UT : T.Opens} {UX : X.Opens}
(hUST : UT ≤ (TopologicalSpace.Opens.map f.base).obj US) (hUSX : UX ≤ (TopologicalSpace.Opens.map iX.base).obj US)
{UY : Y.Opens} (hUY : UY = (TopologicalSpace.Opens.map g.base).obj UX ⊓ (TopologicalSpace.Opens.map iY.base).obj UT)
[AlgebraicGeometry.Flat iX],
AlgebraicGeometry.IsAffineOpen US →
IsCompact ↑UT →
IsCompact ↑UX →
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f US UT hUST)).Flat →
CategoryTheory.Mono (AlgebraicGeometry.pushoutSection H hUST hUSX hUY) |
HasFDerivWithinAt.of_insert | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E} {y : E},
HasFDerivWithinAt f f' (insert y s) x → HasFDerivWithinAt f f' s x |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Stepwise.imp_1eq._simp_1_3 | Init.Grind.Ring.CommSolver | ∀ {M : Type u} [inst : Lean.Grind.AddCommGroup M] {a b : M}, (a - b = 0) = (a = b) |
isCompact_setOf_finiteMeasure_le_of_isCompact | Mathlib.MeasureTheory.Measure.Prokhorov | ∀ {E : Type u_1} [inst : MeasurableSpace E] [inst_1 : TopologicalSpace E] [T2Space E] [inst_3 : BorelSpace E]
(C : NNReal) {K : Set E}, IsCompact K → IsCompact {μ | μ.mass ≤ C ∧ μ Kᶜ = 0} |
Algebra.algebraMapSubmonoid_self | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R), Algebra.algebraMapSubmonoid R M = M |
_private.Mathlib.CategoryTheory.Monoidal.Mon_.0.CategoryTheory.Functor.FullyFaithful.monObj._simp_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {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) [self : F.OplaxMonoidal] {X Y : C} (f : X ⟶ Y) (X' : C) {Z : D}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj Y) (F.obj X') ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.whiskerRight f X'))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OplaxMonoidal.δ F Y X') h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OplaxMonoidal.δ F X X')
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight (F.map f) (F.obj X')) h) |
CategoryTheory.Abelian.SpectralObject.shortComplexMap._proof_26 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) {i' j' k' l' : ι}
(f₁' : i' ⟶ j') (f₂' : j' ⟶ k') (f₃' : k' ⟶ l')
(α : CategoryTheory.ComposableArrows.mk₃ f₁ f₂ f₃ ⟶ CategoryTheory.ComposableArrows.mk₃ f₁' f₂' f₃') (n₀ n₁ n₂ : ℤ)
(hn₂ : n₁ + 1 = n₂),
CategoryTheory.CategoryStruct.comp ((X.H n₁).map (CategoryTheory.ComposableArrows.homMk₁ (α.app 1) (α.app 2) ⋯))
(X.δ f₁' f₂' n₁ n₂ ⋯) =
CategoryTheory.CategoryStruct.comp (X.δ f₁ f₂ n₁ n₂ ⋯)
((X.H n₂).map (CategoryTheory.ComposableArrows.homMk₁ (α.app 0) (α.app 1) ⋯)) |
Lean.instInhabitedVersoDocString.default | Lean.DocString.Extension | Lean.VersoDocString |
CategoryTheory.Limits.ImageFactorisation.mk | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
(F : CategoryTheory.Limits.MonoFactorisation f) →
CategoryTheory.Limits.IsImage F → CategoryTheory.Limits.ImageFactorisation f |
AddSubmonoid.pi | Mathlib.Algebra.Group.Submonoid.Operations | {ι : Type u_4} →
{M : ι → Type u_5} →
[inst : (i : ι) → AddZeroClass (M i)] → Set ι → ((i : ι) → AddSubmonoid (M i)) → AddSubmonoid ((i : ι) → M i) |
_private.Mathlib.Algebra.Order.BigOperators.GroupWithZero.List.0.List.one_le_prod._simp_1_2 | Mathlib.Algebra.Order.BigOperators.GroupWithZero.List | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∀ (a : α), a = a' ∨ q a → p a) = (p a' ∧ ∀ (a : α), q a → p a) |
Lean.Meta.Simp.NormCastConfig.beta._default | Init.MetaTypes | Bool |
DiscreteMeasurableSpace.toMeasurableSub | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : Sub α] [DiscreteMeasurableSpace α], MeasurableSub α |
FundamentalGroupoid.map_obj_as | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y))
(x : FundamentalGroupoid X), ((FundamentalGroupoid.map f).obj x).as = f x.as |
ContinuousLinearMap.toNormedRing._proof_14 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] (a b : E →L[𝕜] E), a - b = a + -b |
GrpWithZero.groupWithZeroConcreteCategory._proof_3 | Mathlib.Algebra.Category.GrpWithZero | ∀ {X : GrpWithZero} (x : X.carrier), (CategoryTheory.CategoryStruct.id X) x = x |
Option.merge_eq_some_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o o' : Option α} {f : α → α → α} {a : α},
Option.merge f o o' = some a ↔
o = some a ∧ o' = none ∨ o = none ∧ o' = some a ∨ ∃ b c, o = some b ∧ o' = some c ∧ f b c = a |
AlgebraicGeometry.PresheafedSpace.stalkMap.congr_hom | Mathlib.Geometry.RingedSpace.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C]
{X Y : AlgebraicGeometry.PresheafedSpace C} (α β : X ⟶ Y) (h : α = β) (x : ↑↑X),
AlgebraicGeometry.PresheafedSpace.Hom.stalkMap α x =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (AlgebraicGeometry.PresheafedSpace.Hom.stalkMap β x) |
MulAlgebraNorm.noConfusionType | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | Sort u →
{R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
MulAlgebraNorm R S →
{R' : Type u_1} →
[inst' : SeminormedCommRing R'] →
{S' : Type u_2} → [inst'_1 : Ring S'] → [inst'_2 : Algebra R' S'] → MulAlgebraNorm R' S' → Sort u |
_private.Mathlib.Topology.EMetricSpace.Lipschitz.0.continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith.match_1_1 | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} (motive : α × β → Prop) (h : α × β), (∀ (a : α) (b : β), motive (a, b)) → motive h |
AlgebraicGeometry.Scheme.map_basicOpen | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens) (r : ↑((↑U).presheaf.obj (Opposite.op ⊤))),
(AlgebraicGeometry.Scheme.Hom.opensFunctor U.ι).obj ((↑U).basicOpen r) =
X.basicOpen ((CategoryTheory.ConcreteCategory.hom (X.presheaf.map (CategoryTheory.eqToHom ⋯).op)) r) |
Nat.instTransLe | Init.Data.Nat.Basic | Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 |
SchwartzMap.fderivCLM._proof_7 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ (F : Type u_1) [inst : NormedAddCommGroup F], ContinuousAdd F |
CategoryTheory.Limits.isBilimitOfIsLimit._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_3}
[inst_2 : Fintype J] {f : J → C} (t : CategoryTheory.Limits.Bicone f) (j : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (∑ j, CategoryTheory.CategoryStruct.comp (t.π j) (t.ι j)) (t.toCone.π.app j) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id t.pt) (t.toCone.π.app j) |
Nat.Prime.mem_primeFactors | Mathlib.Data.Nat.PrimeFin | ∀ {n p : ℕ}, Nat.Prime p → p ∣ n → n ≠ 0 → p ∈ n.primeFactors |
trapezoidal_integral | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | (ℝ → ℝ) → ℕ → ℝ → ℝ → ℝ |
Orientation.kahler_rotation_left' | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V) (θ : Real.Angle),
(o.kahler ((o.rotation θ) x)) y = ↑(-θ).toCircle * (o.kahler x) y |
commutatorElement_def | Mathlib.Algebra.Group.Commutator | ∀ {G : Type u_1} [inst : Group G] (g₁ g₂ : G), ⁅g₁, g₂⁆ = g₁ * g₂ * g₁⁻¹ * g₂⁻¹ |
Polynomial.leadingCoeff_X_pow_sub_one | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Ring R] {n : ℕ}, 0 < n → (Polynomial.X ^ n - 1).leadingCoeff = 1 |
IsGreatest.nnnorm_cfcₙ_nnreal._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax |
Monotone.of_left_le_map_sup | Mathlib.Order.Lattice | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup α] [inst_1 : Preorder β] {f : α → β},
(∀ (x y : α), f x ≤ f (x ⊔ y)) → Monotone f |
Aesop.NormRuleResult.proved.injEq | Aesop.Search.Expansion.Norm | ∀ (steps? steps?_1 : Option (Array Aesop.Script.LazyStep)),
(Aesop.NormRuleResult.proved steps? = Aesop.NormRuleResult.proved steps?_1) = (steps? = steps?_1) |
_private.Lean.Elab.DocString.0.Lean.Doc.commandExpandersForUnsafe | Lean.Elab.DocString | Lean.Ident →
Lean.Elab.TermElabM
(Array
(Lean.Name ×
StateT (Array (Lean.TSyntax `doc_arg)) Lean.Doc.DocM (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))) |
Matroid.IsBasis.isBasis_isRestriction | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α} {N : Matroid α},
M.IsBasis I X → N.IsRestriction M → X ⊆ N.E → N.IsBasis I X |
Lean.Meta.SolveByElim.SolveByElimConfig.testPartialSolutions | Lean.Meta.Tactic.SolveByElim | optParam Lean.Meta.SolveByElim.SolveByElimConfig { } →
(List Lean.Expr → Lean.MetaM Bool) → Lean.Meta.SolveByElim.SolveByElimConfig |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.unsat_of_encounteredBoth._proof_1_6 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {n : ℕ} (assignment : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
(if (!l.2) = true then Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit l
else Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty) =
Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth →
Std.Tactic.BVDecide.LRAT.Internal.Unsatisfiable (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) assignment |
CategoryTheory.Functor.sheafPushforwardContinuousComp' | Mathlib.CategoryTheory.Sites.Continuous | {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 : CategoryTheory.Functor D E} →
{FG : CategoryTheory.Functor C E} →
(F.comp G ≅ FG) →
(A : Type u) →
[inst_3 : CategoryTheory.Category.{t, u} A] →
(J : CategoryTheory.GrothendieckTopology C) →
(K : CategoryTheory.GrothendieckTopology D) →
(L : CategoryTheory.GrothendieckTopology E) →
[inst_4 : F.IsContinuous J K] →
[inst_5 : G.IsContinuous K L] →
[inst_6 : FG.IsContinuous J L] →
(G.sheafPushforwardContinuous A K L).comp (F.sheafPushforwardContinuous A J K) ≅
FG.sheafPushforwardContinuous A J L |
Array.merge.go._unsafe_rec | Batteries.Data.Array.Merge | {α : Type u_1} → (α → α → Bool) → Array α → Array α → Array α → ℕ → ℕ → Array α |
CategoryTheory.LaxMonoidalFunctor.laxMonoidal._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax |
Con.ker_rel._simp_2 | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_4} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[inst_3 : MulHomClass F M N] (f : F) {x y : M}, (Con.ker f) x y = (f x = f y) |
BitVec.toInt_sub_of_not_ssubOverflow | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, ¬x.ssubOverflow y = true → (x - y).toInt = x.toInt - y.toInt |
_private.Mathlib.Analysis.Analytic.Inverse.0.FormalMultilinearSeries.rightInv_removeZero.match_1_1 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_1} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) (x : E)
(motive : (n : ℕ) → (∀ m < n, p.removeZero.rightInv i x m = p.rightInv i x m) → Prop) (n : ℕ)
(IH : ∀ m < n, p.removeZero.rightInv i x m = p.rightInv i x m),
(∀ (IH : ∀ m < 0, p.removeZero.rightInv i x m = p.rightInv i x m), motive 0 IH) →
(∀ (IH : ∀ m < 1, p.removeZero.rightInv i x m = p.rightInv i x m), motive 1 IH) →
(∀ (n : ℕ) (IH : ∀ m < n + 2, p.removeZero.rightInv i x m = p.rightInv i x m), motive n.succ.succ IH) →
motive n IH |
CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{s t : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit s → CategoryTheory.Limits.IsLimit t → (s.pt ≅ t.pt) |
Lean.Meta.Grind.Arith.CommRing.MonadCanon.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.MonadCanon | {P : Sort u} →
{m : Type → Type} →
{t : Lean.Meta.Grind.Arith.CommRing.MonadCanon m} →
{m' : Type → Type} →
{t' : Lean.Meta.Grind.Arith.CommRing.MonadCanon m'} →
m = m' → t ≍ t' → Lean.Meta.Grind.Arith.CommRing.MonadCanon.noConfusionType P t t' |
Cardinal.ofENat_le_lift._simp_1 | Mathlib.SetTheory.Cardinal.ENat | ∀ {x : Cardinal.{v}} {m : ℕ∞}, (↑m ≤ Cardinal.lift.{u, v} x) = (↑m ≤ x) |
List.minOn_eq_min | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : LE α] [DecidableLE α] [Std.LawfulOrderLeftLeaningMin α]
[inst_4 : LE β] [inst_5 : DecidableLE β] {f : α → β} {l : List α} {h : l ≠ []},
(∀ (a b : α), f a ≤ f b ↔ a ≤ b) → List.minOn f l h = l.min h |
nhds_subtype_eq_comap | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {p : X → Prop} {x : X} {h : p x},
nhds ⟨x, h⟩ = Filter.comap Subtype.val (nhds x) |
lt_of_lt_add_of_nonpos_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddRightMono α] {a b c : α}, a < b + c → b ≤ 0 → a < c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.