name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ULift.subNegAddMonoid._proof_4 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : SubNegMonoid α] (x x_1 : ULift.{u_1, u_2} α), Equiv.ulift (x - x_1) = Equiv.ulift (x - x_1) |
_private.Mathlib.LinearAlgebra.FreeModule.Norm.0.associated_norm_prod_smith._simp_1_3 | Mathlib.LinearAlgebra.FreeModule.Norm | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ : Module R₃ M₃}
{σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_6 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] (f : M₂ →ₛₗ[σ₂₃] M₃)
(g : M₁ →ₛₗ[σ₁₂] M₂) (x : M₁), f (g x) = (f ∘ₛₗ g) x |
RingCon.instCommRingQuotient._proof_3 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : CommRing R] (c : RingCon R) (x x_1 : R), Quotient.mk'' (x * x_1) = Quotient.mk'' (x * x_1) |
_private.Mathlib.Combinatorics.Additive.AP.Three.Behrend.0.Behrend.map_succ._simp_1_2 | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c |
Filter.Germ.coe_vadd'._simp_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {M : Type u_5} [inst : VAdd M β] (c : α → M) (f : α → β),
↑c +ᵥ ↑f = ↑(c +ᵥ f) |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.getRecommendedSpellingString.bullet._sparseCasesOn_1 | Lean.Parser.Term.Doc | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Lean.Meta.Grind.getBuiltinInstance? | Lean.Meta.Tactic.Grind.SynthInstance | Lean.Expr → Option Lean.Expr |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLT.core.nnratArm._proof_1 | Mathlib.Tactic.NormNum.Ineq | ∀ {u : Lean.Level} {α : Q(Type u)} (lα : Q(LT «$α»)) (fst : Q(LinearOrder «$α»)),
«$lα» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toLT |
Lean.Meta.RefinedDiscrTree.PreDiscrTree.toRefinedDiscrTree | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} → Lean.Meta.RefinedDiscrTree.PreDiscrTree α → Lean.Meta.RefinedDiscrTree α |
_private.Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Independence.0.ContinuousLinearMap.diagonalStrongDualPi._proof_10 | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Independence | SMulCommClass ℝ ℝ ℝ |
TopCat.GlueData.ι_fromOpenSubsetsGlue | Mathlib.Topology.Gluing | ∀ {α : Type u} [inst : TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) (i : J),
CategoryTheory.CategoryStruct.comp ((TopCat.GlueData.ofOpenSubsets U).ι i) (TopCat.GlueData.fromOpenSubsetsGlue U) =
(U i).inclusion' |
CategoryTheory.Triangulated.Octahedron.mem | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C} {u₁₂ : X₁ ⟶ X₂} {u₂₃ : X₂ ⟶ X₃} {u₁₃ : X₁ ⟶ X₃}
{comm : CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃} {v₁₂ : X₂ ⟶ Z₁₂}
{w₁₂ : Z₁₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁}
{h₁₂ : CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}
{v₂₃ : X₃ ⟶ Z₂₃} {w₂₃ : Z₂₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₂}
{h₂₃ : CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}
{v₁₃ : X₃ ⟶ Z₁₃} {w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁}
{h₁₃ : CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}
(self : CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃),
CategoryTheory.Pretriangulated.Triangle.mk self.m₁ self.m₃
(CategoryTheory.CategoryStruct.comp w₂₃ ((CategoryTheory.shiftFunctor C 1).map v₁₂)) ∈
CategoryTheory.Pretriangulated.distinguishedTriangles |
StarAlgHom.fst_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] (self : A × B),
(StarAlgHom.fst R A B) self = self.1 |
WithVal.congr_trans | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀)
{S : Type u_3} [inst_2 : Ring S] {Λ₀ : Type u_4} [inst_3 : LinearOrderedCommGroupWithZero Λ₀] (w : Valuation S Λ₀)
{T : Type u_5} [inst_4 : Ring T] (u : Valuation T Γ₀) (f : R ≃+* S) (g : S ≃+* T),
WithVal.congr v u (f.trans g) = (WithVal.congr v w f).trans (WithVal.congr w u g) |
ArchimedeanClass.addSubgroup_eq_bot | Mathlib.Algebra.Order.Archimedean.Class | ∀ (M : Type u_1) [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M],
ArchimedeanClass.addSubgroup ⊤ = ⊥ |
Vector.eraseIdx_set_lt._proof_2 | Init.Data.Vector.Erase | ∀ {n i : ℕ} {w : i < n} {j : ℕ}, j < i → i - 1 < n - 1 |
PowerSeries.invOneSubPow.eq_2 | Mathlib.RingTheory.PowerSeries.WellKnown | ∀ (S : Type u_1) [inst : CommRing S] (d : ℕ),
PowerSeries.invOneSubPow S d.succ =
{ val := PowerSeries.mk fun n => ↑((d + n).choose d), inv := (1 - PowerSeries.X) ^ (d + 1), val_inv := ⋯,
inv_val := ⋯ } |
NumberField.mixedEmbedding.polarCoordReal | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | (K : Type u_1) →
[inst : Field K] →
[NumberField K] →
OpenPartialHomeomorph (NumberField.mixedEmbedding.realMixedSpace K) (NumberField.mixedEmbedding.realMixedSpace K) |
Homeomorph.toEquiv_piCongr | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι₁ : Type u_7} {ι₂ : Type u_8} {Y₁ : ι₁ → Type u_9} {Y₂ : ι₂ → Type u_10}
[inst : (i₁ : ι₁) → TopologicalSpace (Y₁ i₁)] [inst_1 : (i₂ : ι₂) → TopologicalSpace (Y₂ i₂)] (e : ι₁ ≃ ι₂)
(F : (i₁ : ι₁) → Y₁ i₁ ≃ₜ Y₂ (e i₁)),
(Homeomorph.piCongr e F).toEquiv = (Equiv.piCongrRight fun i => (F i).toEquiv).trans (Equiv.piCongrLeft Y₂ e) |
Lean.Grind.instMulBitVecUint | Init.GrindInstances.ToInt | ∀ {v : ℕ}, Lean.Grind.ToInt.Mul (BitVec v) (Lean.Grind.IntInterval.uint v) |
_private.Mathlib.Combinatorics.Enumerative.DyckWord.0.DyckWord.firstReturn_lt_length._proof_1_2 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ {p : DyckWord}, 0 < (↑p).length → (↑p).length - 1 < (↑p).length |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform.0.SimpleGraph.unreduced_edges_subset._simp_1_6 | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) |
Std.ExtDTreeMap.minKey!_insert_le_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β k}, (cmp (t.insert k v).minKey! k).isLE = true |
Lean.Lsp.SemanticTokenModifier.declaration.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenModifier → Sort u} →
(t : Lean.Lsp.SemanticTokenModifier) → t.ctorIdx = 0 → motive Lean.Lsp.SemanticTokenModifier.declaration → motive t |
Algebra.zariskisMainProperty_iff_exists_saturation_eq_top._proof_2 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : S),
IsIntegral R r → Submonoid.powers r ≤ (integralClosure R S).toSubmonoid |
Fin.rev_sub | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} (a b : Fin n), (a - b).rev = a.rev + b |
Finset.sum_eq_zero | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] {f : ι → M},
(∀ x ∈ s, f x = 0) → ∑ x ∈ s, f x = 0 |
TopModuleCat.withModuleTopologyAdj._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u_2) [inst : Ring R] [inst_1 : TopologicalSpace R] ⦃X Y : TopModuleCat R⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.forget₂ (TopModuleCat R) (ModuleCat R)).comp (TopModuleCat.withModuleTopology R)).map f)
(TopModuleCat.ofHom { toLinearMap := LinearMap.id, cont := ⋯ }) =
CategoryTheory.CategoryStruct.comp (TopModuleCat.ofHom { toLinearMap := LinearMap.id, cont := ⋯ })
((CategoryTheory.Functor.id (TopModuleCat R)).map f) |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.cons._proof_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ (head : ℕ) (tail : List ℕ), 1 ≤ (head :: tail).length → 0 < (head :: tail).length |
isOpen.dynEntourage | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {X : Type u_1} {U : SetRel X X} [inst : TopologicalSpace X] {T : X → X},
Continuous T → IsOpen U → ∀ (n : ℕ), IsOpen (Dynamics.dynEntourage T U n) |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.ResultingUniverseResult.u | Lean.Elab.MutualInductive | Lean.Elab.Command.ResultingUniverseResult✝ → Lean.Level |
RKHS.ext | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] {H : Type u_4} [inst_3 : NormedAddCommGroup H] [inst_4 : InnerProductSpace 𝕜 H]
[inst_5 : RKHS 𝕜 H X V] {f g : H}, (∀ (x : X), f x = g x) → f = g |
ContinuousLinearMap | Mathlib.Topology.Algebra.Module.LinearMap | {R : Type u_1} →
{S : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
(R →+* S) →
(M : Type u_3) →
[TopologicalSpace M] →
[inst_3 : AddCommMonoid M] →
(M₂ : Type u_4) →
[TopologicalSpace M₂] →
[inst_5 : AddCommMonoid M₂] → [Module R M] → [Module S M₂] → Type (max u_3 u_4) |
SheafOfModules.instIsLeftAdjointOverOverRingCatPushforwardIdSheafOver | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] [CategoryTheory.Limits.HasBinaryProducts C]
{J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} (x : C),
(SheafOfModules.pushforward (CategoryTheory.CategoryStruct.id (R.over x))).IsLeftAdjoint |
Relation.ReflGen.mono | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r p : α → α → Prop},
(∀ (a b : α), r a b → p a b) → ∀ {a b : α}, Relation.ReflGen r a b → Relation.ReflGen p a b |
AddSubgroup.map_injective | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N},
Function.Injective ⇑f → Function.Injective (AddSubgroup.map f) |
MonoidHom.toHomPerm_apply_symm_apply | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {G : Type u_7} [inst : Group G] (f : G →* Function.End α) (a : G),
⇑(Equiv.symm (f.toHomPerm a)) = ↑(f.toHomUnits a)⁻¹ |
Lean.Grind.CommRing.Expr.pow.inj | Init.Grind.Ring.CommSolver | ∀ {a : Lean.Grind.CommRing.Expr} {k : ℕ} {a_1 : Lean.Grind.CommRing.Expr} {k_1 : ℕ},
a.pow k = a_1.pow k_1 → a = a_1 ∧ k = k_1 |
PresheafOfModules.toPresheaf._proof_3 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat)
(X : PresheafOfModules R),
{
app := fun X_1 =>
AddCommGrpCat.ofHom
(AddMonoidHom.mk' ⇑(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.CategoryStruct.id X).app X_1)) ⋯),
naturality := ⋯ } =
CategoryTheory.CategoryStruct.id X.presheaf |
Rat.den_intFract | Mathlib.Data.Rat.Floor | ∀ (x : ℚ), (Int.fract x).den = x.den |
CategoryTheory.MonadHom.app_μ_assoc | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C}
(self : CategoryTheory.MonadHom T₁ T₂) (X : C) {Z : C} (h : T₂.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp (T₁.μ.app X) (CategoryTheory.CategoryStruct.comp (self.app X) h) =
CategoryTheory.CategoryStruct.comp (T₁.map (self.app X))
(CategoryTheory.CategoryStruct.comp (self.app (T₂.obj X)) (CategoryTheory.CategoryStruct.comp (T₂.μ.app X) h)) |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_500 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
_private.Mathlib.MeasureTheory.Measure.Map.0.MeasurableEquiv.map_ae._simp_1_1 | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {t : Set β}, (t ∈ Filter.map m f) = (m ⁻¹' t ∈ f) |
Lean.Widget.GetWidgetSourceParams.mk.injEq | Lean.Widget.UserWidget | ∀ (hash : UInt64) (pos : Lean.Lsp.Position) (hash_1 : UInt64) (pos_1 : Lean.Lsp.Position),
({ hash := hash, pos := pos } = { hash := hash_1, pos := pos_1 }) = (hash = hash_1 ∧ pos = pos_1) |
MeasurableEmbedding.schroederBernstein._proof_3 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α} (A : Set α),
(fun A => (g '' (f '' A)ᶜ)ᶜ) A = A → Aᶜ = g '' (f '' A)ᶜ |
Rep.coindResAdjunction_counit_app | Mathlib.RepresentationTheory.FiniteIndex | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
[inst_2 : DecidableRel ⇑(QuotientGroup.rightRel S)] [inst_3 : S.FiniteIndex] (B : Rep k G),
(Rep.coindResAdjunction k S).counit.app B =
CategoryTheory.CategoryStruct.comp (Rep.indCoindIso ((Action.res (ModuleCat k) S.subtype).obj B)).inv
((Rep.indResAdjunction k S.subtype).counit.app B) |
CochainComplex.ConnectData.d_sub_one_zero | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L), h.d (-1) 0 = h.d₀ |
IsPreconnected.intermediate_value_Ioc | Mathlib.Topology.Order.IntermediateValue | ∀ {X : Type u} {α : Type v} [inst : TopologicalSpace X] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α]
[OrderClosedTopology α] {s : Set X},
IsPreconnected s →
∀ {a : X} {l : Filter X},
a ∈ s →
∀ [l.NeBot],
l ≤ Filter.principal s →
∀ {f : X → α}, ContinuousOn f s → ∀ {v : α}, Filter.Tendsto f l (nhds v) → Set.Ioc v (f a) ⊆ f '' s |
Set.injOn_iff_injective | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β}, Set.InjOn f s ↔ Function.Injective (s.restrict f) |
Turing.TM2to1.stmtStRec._unsafe_rec | Mathlib.Computability.TuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{motive : Turing.TM2.Stmt Γ Λ σ → Sort l} →
((k : K) →
(s : Turing.TM2to1.StAct K Γ σ k) →
(q : Turing.TM2.Stmt Γ Λ σ) → motive q → motive (Turing.TM2to1.stRun s q)) →
((a : σ → σ) → (q : Turing.TM2.Stmt Γ Λ σ) → motive q → motive (Turing.TM2.Stmt.load a q)) →
((p : σ → Bool) →
(q₁ q₂ : Turing.TM2.Stmt Γ Λ σ) → motive q₁ → motive q₂ → motive (Turing.TM2.Stmt.branch p q₁ q₂)) →
((l : σ → Λ) → motive (Turing.TM2.Stmt.goto l)) →
motive Turing.TM2.Stmt.halt → (n : Turing.TM2.Stmt Γ Λ σ) → motive n |
CategoryTheory.Grp.Hom.hom_hom_div | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_ | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {G H : CategoryTheory.Grp C} [inst_3 : CategoryTheory.IsCommMonObj H.X]
(f g : G ⟶ H), (f / g).hom.hom = f.hom.hom / g.hom.hom |
Lean.Doc.MarkdownInline.mk | Lean.DocString.Markdown | {i : Type u} →
((Lean.Doc.Inline i → Lean.Doc.MarkdownM Unit) → i → Array (Lean.Doc.Inline i) → Lean.Doc.MarkdownM Unit) →
Lean.Doc.MarkdownInline i |
Lean.Linter.LinterOptions.noConfusionType | Lean.Linter.Basic | Sort u → Lean.Linter.LinterOptions → Lean.Linter.LinterOptions → Sort u |
CategoryTheory.Pretriangulated.shortComplexOfDistTriangleIsoOfIso._proof_3 | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C]
{T T' : CategoryTheory.Pretriangulated.Triangle C} (e : T ≅ T')
(hT : T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Pretriangulated.Triangle.π₁.mapIso e).hom
(CategoryTheory.Pretriangulated.shortComplexOfDistTriangle T' ⋯).f =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Pretriangulated.shortComplexOfDistTriangle T hT).f
(CategoryTheory.Pretriangulated.Triangle.π₂.mapIso e).hom |
SubalgebraClass.toAlgebra._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {S : Type u_2} {R : Type u_3} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [inst_4 : SubsemiringClass S A] [hSR : SMulMemClass S R A] (s : S),
↑⟨(algebraMap R A) 1, ⋯⟩ = ↑1 |
ContinuousSqrt.mk.noConfusion | Mathlib.Topology.ContinuousMap.StarOrdered | {R : Type u_1} →
{inst : LE R} →
{inst_1 : NonUnitalSemiring R} →
{inst_2 : TopologicalSpace R} →
{P : Sort u} →
{sqrt : R × R → R} →
{continuousOn_sqrt : ContinuousOn sqrt {x | x.1 ≤ x.2}} →
{sqrt_nonneg : ∀ (x : R × R), x.1 ≤ x.2 → 0 ≤ sqrt x} →
{sqrt_mul_sqrt : ∀ (x : R × R), x.1 ≤ x.2 → x.2 = x.1 + sqrt x * sqrt x} →
{sqrt' : R × R → R} →
{continuousOn_sqrt' : ContinuousOn sqrt' {x | x.1 ≤ x.2}} →
{sqrt_nonneg' : ∀ (x : R × R), x.1 ≤ x.2 → 0 ≤ sqrt' x} →
{sqrt_mul_sqrt' : ∀ (x : R × R), x.1 ≤ x.2 → x.2 = x.1 + sqrt' x * sqrt' x} →
{ sqrt := sqrt, continuousOn_sqrt := continuousOn_sqrt, sqrt_nonneg := sqrt_nonneg,
sqrt_mul_sqrt := sqrt_mul_sqrt } =
{ sqrt := sqrt', continuousOn_sqrt := continuousOn_sqrt', sqrt_nonneg := sqrt_nonneg',
sqrt_mul_sqrt := sqrt_mul_sqrt' } →
(sqrt ≍ sqrt' → P) → P |
Nat.Primes.prodNatEquiv_apply | Mathlib.Data.Nat.Factorization.PrimePow | ∀ (p : Nat.Primes) (k : ℕ), Nat.Primes.prodNatEquiv (p, k) = ⟨↑p ^ (k + 1), ⋯⟩ |
FiniteField.X_pow_card_sub_X_natDegree_eq | Mathlib.FieldTheory.Finite.Basic | ∀ (K' : Type u_3) [inst : Field K'] {p : ℕ}, 1 < p → (Polynomial.X ^ p - Polynomial.X).natDegree = p |
Lean.Meta.EtaStructMode | Init.MetaTypes | Type |
nonzero_span_atom | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] (v : V),
v ≠ 0 → IsAtom (K ∙ v) |
MonoidHom.restrictHomKerEquiv.match_1 | Mathlib.GroupTheory.QuotientGroup.Basic | {G : Type u_1} →
[inst : Group G] →
(A : Type u_2) →
[inst_1 : CommGroup A] →
(H : Subgroup G) →
(motive : ↥(MonoidHom.restrictHom H A).ker → Sort u_3) →
(x : ↥(MonoidHom.restrictHom H A).ker) →
((f : G →* A) → (hf : f ∈ (MonoidHom.restrictHom H A).ker) → motive ⟨f, hf⟩) → motive x |
Polynomial.exists_multiset_roots._unary | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] [inst_2 : DecidableEq R] (_x : (p : Polynomial R) ×' p ≠ 0),
∃ s, ↑s.card ≤ _x.1.degree ∧ ∀ (a : R), Multiset.count a s = Polynomial.rootMultiplicity a _x.1 |
_private.Mathlib.Data.Nat.GCD.BigOperators.0.Nat.coprime_list_prod_left_iff._simp_1_1 | Mathlib.Data.Nat.GCD.BigOperators | ∀ {m n k : ℕ}, (m * n).Coprime k = (m.Coprime k ∧ n.Coprime k) |
CategoryTheory.Abelian.coimageIsoImage' | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{X Y : C} → (f : X ⟶ Y) → CategoryTheory.Abelian.coimage f ≅ CategoryTheory.Limits.image f |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_12 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {v u : V} {p : G.Walk u v}, ∀ i' < p.length, i' + 1 ≤ p.length |
Rep.indCoindIso._proof_3 | Mathlib.RepresentationTheory.FiniteIndex | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
[inst_2 : DecidableRel ⇑(QuotientGroup.rightRel S)] (A : Rep k ↥S) [inst_3 : S.FiniteIndex],
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom A.indToCoind) (ModuleCat.ofHom A.coindToInd) =
CategoryTheory.CategoryStruct.id (Rep.ind S.subtype A).V |
LinearMap.coe_prod | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃), ⇑(f.prod g) = Pi.prod ⇑f ⇑g |
CategoryTheory.Aut.instGroup._proof_7 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C) (x x_1 x_2 : CategoryTheory.Aut X),
x_2 ≪≫ x_1 ≪≫ x = (x_2 ≪≫ x_1) ≪≫ x |
AddMonoidHom.coe_toZModLinearMap | Mathlib.Algebra.Module.ZMod | ∀ (n : ℕ) {M : Type u_1} {M₁ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₁] [inst_2 : Module (ZMod n) M]
[inst_3 : Module (ZMod n) M₁] (f : M →+ M₁), ⇑(AddMonoidHom.toZModLinearMap n f) = ⇑f |
OrderMonoidHom.toMonoidHom | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : MulOneClass α] → [inst_3 : MulOneClass β] → (α →*o β) → α →* β |
RingTheory.Sequence.IsWeaklyRegular.of_flat | Mathlib.RingTheory.Regular.Flat | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [Module.Flat R S]
{rs : List R},
RingTheory.Sequence.IsWeaklyRegular R rs → RingTheory.Sequence.IsWeaklyRegular S (List.map (⇑(algebraMap R S)) rs) |
_private.Mathlib.RingTheory.Idempotents.0.CompleteOrthogonalIdempotents.bijective_pi._simp_1_1 | Mathlib.RingTheory.Idempotents | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x |
Lean.Elab.MacroStackElem.mk.sizeOf_spec | Lean.Elab.Util | ∀ (before after : Lean.Syntax), sizeOf { before := before, after := after } = 1 + sizeOf before + sizeOf after |
Int.land_bit | Mathlib.Data.Int.Bitwise | ∀ (a : Bool) (m : ℤ) (b : Bool) (n : ℤ), (Int.bit a m).land (Int.bit b n) = Int.bit (a && b) (m.land n) |
LinearMap.SeparatingLeft.toMatrix₂ | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M₁ : Type u_6} {M₂ : Type u_7} {n : Type u_11} {m : Type u_12} [inst : CommRing R]
[inst_1 : DecidableEq m] [inst_2 : Fintype m] [inst_3 : DecidableEq n] [inst_4 : Fintype n]
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Module R M₂]
(b₁ : Module.Basis m R M₁) (b₂ : Module.Basis n R M₂) {B : M₁ →ₗ[R] M₂ →ₗ[R] R},
B.SeparatingLeft → ((LinearMap.toMatrix₂ b₁ b₂) B).SeparatingLeft |
List.rightInverse_sigmaCountToIdx_idxToSigmaCount | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs : List α},
Function.RightInverse xs.sigmaCountToIdx xs.idxToSigmaCount |
NormedAddGroupHom.normNoninc_of_isometry | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
{f : NormedAddGroupHom V W}, Isometry ⇑f → f.NormNoninc |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_eq_minKeyD_default._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
CategoryTheory.StrongEpi.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : C} {f : P ⟶ Q},
CategoryTheory.Epi f →
(∀ ⦃X Y : C⦄ (z : X ⟶ Y) [CategoryTheory.Mono z], CategoryTheory.HasLiftingProperty f z) →
CategoryTheory.StrongEpi f |
_private.Init.Data.List.Impl.0.List.erasePTR.go._unsafe_rec | Init.Data.List.Impl | {α : Type u_1} → (α → Bool) → List α → List α → Array α → List α |
SubfieldClass.toDivisionRing._proof_4 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u_1} (S : Type u_2) [inst : SetLike S K] (s : S), Function.Injective fun a => ↑a |
List.nextOr_singleton | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (x y d : α), [y].nextOr x d = d |
SimpleGraph.EdgeLabeling.pairwise_disjoint_labelGraph | Mathlib.Combinatorics.SimpleGraph.EdgeLabeling | ∀ {V : Type u_1} {G : SimpleGraph V} {K : Type u_3} {C : G.EdgeLabeling K},
Pairwise fun k l => Disjoint (C.labelGraph k) (C.labelGraph l) |
Mathlib.Tactic.Hint._aux_Mathlib_Tactic_Hint___elabRules_Mathlib_Tactic_Hint_registerHintStx_1 | Mathlib.Tactic.Hint | Lean.Elab.Command.CommandElab |
BitVec.toInt_ushiftRight_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ}, 0 < n → (x >>> n).toInt = ↑(x.toNat >>> n) |
Mathlib.Tactic.BicategoryLike.MonadMor₂.homM | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
[self : Mathlib.Tactic.BicategoryLike.MonadMor₂ m] →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂ |
Std.Iterators.PostconditionT.operation_lift | Init.Data.Iterators.PostconditionMonad | ∀ {m : Type w → Type w'} [inst : Functor m] {α : Type w} {x : m α},
(Std.Iterators.PostconditionT.lift x).operation = (fun x_1 => ⟨x_1, ⋯⟩) <$> x |
Algebra.TensorProduct.algEquivOfLinearEquivTripleTensorProduct._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type u_5} {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : 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 : Semiring D] [inst_7 : Algebra R D] [inst_8 : Algebra R C]
(f : TensorProduct R (TensorProduct R A B) C ≃ₗ[R] D),
(∀ (a₁ a₂ : A) (b₁ b₂ : B) (c₁ c₂ : C),
f ((a₁ * a₂) ⊗ₜ[R] (b₁ * b₂) ⊗ₜ[R] (c₁ * c₂)) = f (a₁ ⊗ₜ[R] b₁ ⊗ₜ[R] c₁) * f (a₂ ⊗ₜ[R] b₂ ⊗ₜ[R] c₂)) →
(LinearMap.mul R (TensorProduct R (TensorProduct R A B) C)).compr₂ ↑f = (LinearMap.mul R D ∘ₗ ↑f).compl₂ ↑f |
_private.Mathlib.RingTheory.SurjectiveOnStalks.0.RingHom.surjective_localRingHom_iff._simp_1_4 | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {x₁ x₂ : R} {y₁ y₂ : ↥M},
(IsLocalization.mk' S x₁ y₁ = IsLocalization.mk' S x₂ y₂) =
((algebraMap R S) (↑y₂ * x₁) = (algebraMap R S) (↑y₁ * x₂)) |
AffineIsometry.id._proof_1 | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_2} {V : Type u_1} {P : Type u_3} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P] (x : V),
‖(AffineMap.id 𝕜 P).linear x‖ = ‖(AffineMap.id 𝕜 P).linear x‖ |
ContinuousMap.Homotopy.prodMap | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
{Z : Type w} →
{Z' : Type x} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
[inst_3 : TopologicalSpace Z'] →
{f₀ f₁ : C(X, Y)} →
{g₀ g₁ : C(Z, Z')} → f₀.Homotopy f₁ → g₀.Homotopy g₁ → (f₀.prodMap g₀).Homotopy (f₁.prodMap g₁) |
MonoidHom.noncommPiCoprodEquiv._proof_6 | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {M : Type u_3} [inst : Monoid M] {ι : Type u_1} [inst_1 : Fintype ι] {N : ι → Type u_2}
[inst_2 : (i : ι) → Monoid (N i)] [inst_3 : DecidableEq ι] (f : ((i : ι) → N i) →* M),
MonoidHom.noncommPiCoprod ↑⟨fun i => f.comp (MonoidHom.mulSingle N i), ⋯⟩ ⋯ = f |
ContinuousLinearEquiv.equivOfRightInverse | Mathlib.Topology.Algebra.Module.Equiv | {R : Type u_1} →
[inst : Ring R] →
{M : Type u_3} →
[inst_1 : TopologicalSpace M] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
{M₂ : Type u_4} →
[inst_4 : TopologicalSpace M₂] →
[inst_5 : AddCommGroup M₂] →
[inst_6 : Module R M₂] →
[IsTopologicalAddGroup M] →
(f₁ : M →L[R] M₂) → (f₂ : M₂ →L[R] M) → Function.RightInverse ⇑f₂ ⇑f₁ → M ≃L[R] M₂ × ↥(↑f₁).ker |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT_neg_mem._simp_1_5 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro |
AlternatingMap.coe_injective | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7}, Function.Injective DFunLike.coe |
SimpleGraph.cycleGraph_zero_eq_bot | Mathlib.Combinatorics.SimpleGraph.Circulant | SimpleGraph.cycleGraph 0 = ⊥ |
Function.Injective.divisionMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : One M₁] →
[inst_2 : Pow M₁ ℕ] →
[inst_3 : Inv M₁] →
[inst_4 : Div M₁] →
[inst_5 : Pow M₁ ℤ] →
[inst_6 : DivisionMonoid M₂] →
(f : M₁ → M₂) →
Function.Injective f →
f 1 = 1 →
(∀ (x y : M₁), f (x * y) = f x * f y) →
(∀ (x : M₁), f x⁻¹ = (f x)⁻¹) →
(∀ (x y : M₁), f (x / y) = f x / f y) →
(∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n) →
(∀ (x : M₁) (n : ℤ), f (x ^ n) = f x ^ n) → DivisionMonoid M₁ |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Empty.0.Std.IterM.toArray_eq_match_step.match_1.splitter | Std.Data.Iterators.Lemmas.Producers.Monadic.Empty | {α β : Type u_1} →
{m : Type u_1 → Type u_2} →
(motive : Std.IterStep (Std.IterM m β) β → Sort u_3) →
(x : Std.IterStep (Std.IterM m β) β) →
((it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out)) →
((it' : Std.IterM m β) → motive (Std.IterStep.skip it')) → (Unit → motive Std.IterStep.done) → motive x |
Multiset.disjoint_map_map | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} {f : α → γ} {g : β → γ} {s : Multiset α} {t : Multiset β},
Disjoint (Multiset.map f s) (Multiset.map g t) ↔ ∀ a ∈ s, ∀ b ∈ t, f a ≠ g b |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.coeff_eq_sum._simp_1_1 | Mathlib.LinearAlgebra.Lagrange | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.