name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Elab.Tactic.evalIntro | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic |
SSet.StrictSegal._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | {X : SSet} → X.StrictSegal → ℕ |
Finset.max'_lt_iff._simp_1 | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty) {x : α}, (s.max' H < x) = ∀ y ∈ s, y < x |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.Finite.einfsep._simp_1_5 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u} {x : α × α} {s : Set α}, (x ∈ s.offDiag) = (x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2) |
CategoryTheory.Abelian.Ext.mk₀_smul | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | ∀ {R : Type t} [inst : Ring R] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.Linear R C] [inst_4 : CategoryTheory.HasExt C] {X Y : C}
(r : R) (f : X ⟶ Y), CategoryTheory.Abelian.Ext.mk₀ (r • f) = r • CategoryTheory.Abelian.Ext.mk₀ f |
Lean.Widget.DiffTag.willInsert.sizeOf_spec | Lean.Widget.InteractiveCode | sizeOf Lean.Widget.DiffTag.willInsert = 1 |
List.reduceOption_length_le | Mathlib.Data.List.ReduceOption | ∀ {α : Type u_1} (l : List (Option α)), l.reduceOption.length ≤ l.length |
spectralNorm.spectralNorm_pow_natDegree_eq_prod_roots | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ (K : Type u) [inst : NontriviallyNormedField K] (L : Type v) [inst_1 : Field L] [inst_2 : Algebra K L]
[hu : IsUltrametricDist K] [inst_3 : CompleteSpace K] (x : L) {E : Type u_2} [inst_4 : Field E] [inst_5 : Algebra K E]
[inst_6 : Algebra L E] [IsScalarTower K L E] [Polynomial.IsSplittingField L E ((Polynomial.mapAlg K L) (minpoly K x))]
[inst_9 : Algebra.IsAlgebraic K E],
(spectralMulAlgNorm K E) ((algebraMap L E) x) ^ (minpoly K x).natDegree =
(spectralMulAlgNorm K E) ((Polynomial.mapAlg K E) (minpoly K x)).roots.prod |
HomotopicalAlgebra.PathObject.weakEquivalence_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
{A : C} (self : HomotopicalAlgebra.PathObject A), HomotopicalAlgebra.WeakEquivalence self.ι |
Ordnode.erase._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α |
QuadraticMap.mk.sizeOf_spec | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u} {M : Type v} {N : Type w} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : SizeOf R] [inst_6 : SizeOf M] [inst_7 : SizeOf N]
(toFun : M → N) (toFun_smul : ∀ (a : R) (x : M), toFun (a • x) = (a * a) • toFun x)
(exists_companion' : ∃ B, ∀ (x y : M), toFun (x + y) = toFun x + toFun y + (B x) y),
sizeOf { toFun := toFun, toFun_smul := toFun_smul, exists_companion' := exists_companion' } =
1 + sizeOf exists_companion' |
Std.DTreeMap.Raw.get!_inter_of_mem_right | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α} [inst_1 : Inhabited (β k)], k ∈ t₂ → (t₁ ∩ t₂).get! k = t₁.get! k |
OrderIso.sumLexIioIci_symm_apply_of_ge | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α} (h : x ≤ y), (OrderIso.sumLexIioIci x).symm y = toLex (Sum.inr ⟨y, h⟩) |
DyckWord.insidePart._proof_1 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord) (h : ¬p = 0),
p.take (p.firstReturn + 1) ⋯ ≠ 0 ∧
∀ ⦃i : ℕ⦄,
0 < i →
i < (↑(p.take (p.firstReturn + 1) ⋯)).length →
List.count DyckStep.D (List.take i ↑(p.take (p.firstReturn + 1) ⋯)) <
List.count DyckStep.U (List.take i ↑(p.take (p.firstReturn + 1) ⋯)) |
Finset.mul_prod_Ioo_eq_prod_Ico | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] {f : α → M} {a b : α} [inst_1 : PartialOrder α]
[inst_2 : LocallyFiniteOrder α], a < b → f a * ∏ x ∈ Finset.Ioo a b, f x = ∏ x ∈ Finset.Ico a b, f x |
Std.HashMap.Raw.getKey?_alter | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k k' : α} {f : Option β → Option β},
m.WF →
(m.alter k f).getKey? k' =
if (k == k') = true then if (f m[k]?).isSome = true then some k else none else m.getKey? k' |
_private.Std.Data.DTreeMap.Raw.Lemmas.0.Std.DTreeMap.Raw.Const.contains_of_contains_insertMany_list'._simp_1_1 | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
Rat.lt_of_mul_lt_mul_left | Init.Data.Rat.Lemmas | ∀ {a b c : ℚ}, c * a < c * b → 0 ≤ c → a < b |
List.finIdxOf?_cons | Init.Data.List.Find | ∀ {α : Type u_1} {b : α} [inst : BEq α] {a : α} {xs : List α},
List.finIdxOf? b (a :: xs) =
if (a == b) = true then some ⟨0, ⋯⟩ else Option.map (fun x => x.succ) (List.finIdxOf? b xs) |
BitVec.sub_neg | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x - -y = x + y |
Array.countP_empty | Init.Data.Array.Count | ∀ {α : Type u_1} {p : α → Bool}, Array.countP p #[] = 0 |
_private.Batteries.Data.Fin.Lemmas.0.Fin.find?_le_findRev?._proof_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ}, none ≤ none |
NumberField.InfinitePlace.IsRamified.ne_conjugate | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
{w₁ w₂ : NumberField.InfinitePlace K},
NumberField.InfinitePlace.IsRamified k w₂ → w₁.embedding ≠ NumberField.ComplexEmbedding.conjugate w₂.embedding |
CategoryTheory.Cat.opEquivalence._proof_4 | Mathlib.CategoryTheory.Category.Cat.Op | ∀ {X Y : CategoryTheory.Cat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Cat.opFunctor.comp CategoryTheory.Cat.opFunctor).map f)
((fun x =>
{ hom := (CategoryTheory.unopUnop ↑x).toCatHom, inv := (CategoryTheory.opOp ↑x).toCatHom, hom_inv_id := ⋯,
inv_hom_id := ⋯ })
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun x =>
{ hom := (CategoryTheory.unopUnop ↑x).toCatHom, inv := (CategoryTheory.opOp ↑x).toCatHom, hom_inv_id := ⋯,
inv_hom_id := ⋯ })
X).hom
((CategoryTheory.Functor.id CategoryTheory.Cat).map f) |
CategoryTheory.Mon.equivLaxMonoidalFunctorPUnit_functor | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.Mon.equivLaxMonoidalFunctorPUnit.functor =
CategoryTheory.Mon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToMon C |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.qNF.sub._unary._proof_3 | Mathlib.Tactic.Module | ∀ {u v : Lean.Level} {M : Q(Type v)} {R : Q(Type u)} (a₁ : Q(«$R»)) (x₁ : Q(«$M»)) (k₁ : ℕ)
(t₁ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ) (a₂ : Q(«$R»)) (x₂ : Q(«$M»)) (k₂ : ℕ)
(t₂ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 ⟨t₁, t₂⟩
⟨((a₁, x₁), k₁) :: t₁, ((a₂, x₂), k₂) :: t₂⟩ |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Metric.isBounded_iff_subset_ball.match_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : PseudoMetricSpace α] (c : α) (motive : (∃ r, s ⊆ Metric.ball c r) → Prop)
(x : ∃ r, s ⊆ Metric.ball c r), (∀ (_r : ℝ) (hr : s ⊆ Metric.ball c _r), motive ⋯) → motive x |
Lean.Grind.CommRing.Expr.intCast | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Expr |
_private.Mathlib.Topology.Separation.Regular.0.SeparatedNhds.of_isCompact_isClosed._simp_1_2 | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [RegularSpace X] {x : X} {s : Set X},
Disjoint (nhds x) (nhdsSet s) = (x ∉ closure s) |
ContinuousMap.abs_mem_subalgebra_closure | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : CompactSpace X] (A : Subalgebra ℝ C(X, ℝ)) (f : ↥A),
|↑f| ∈ A.topologicalClosure |
IsLprojection.instLatticeSubtypeOfFaithfulSMul | Mathlib.Analysis.Normed.Module.MStructure | {X : Type u_1} →
[inst : NormedAddCommGroup X] →
{M : Type u_2} → [inst_1 : Ring M] → [inst_2 : Module M X] → [FaithfulSMul M X] → Lattice { P // IsLprojection X P } |
Nat.leRecOn_injective | Mathlib.Data.Nat.Basic | ∀ {C : ℕ → Sort u_1} {n m : ℕ} (hnm : n ≤ m) (next : {k : ℕ} → C k → C (k + 1)),
(∀ (n : ℕ), Function.Injective next) → Function.Injective (Nat.leRecOn hnm fun {k} => next) |
Nat.Prime.dvd_choose_pow | Mathlib.Data.Nat.Multiplicity | ∀ {p n k : ℕ}, Nat.Prime p → k ≠ 0 → k ≠ p ^ n → p ∣ (p ^ n).choose k |
QuaternionAlgebra.Basis.casesOn | Mathlib.Algebra.QuaternionBasis | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : Ring A] →
[inst_2 : Algebra R A] →
{c₁ c₂ c₃ : R} →
{motive : QuaternionAlgebra.Basis A c₁ c₂ c₃ → Sort u} →
(t : QuaternionAlgebra.Basis A c₁ c₂ c₃) →
((i j k : A) →
(i_mul_i : i * i = c₁ • 1 + c₂ • i) →
(j_mul_j : j * j = c₃ • 1) →
(i_mul_j : i * j = k) →
(j_mul_i : j * i = c₂ • j - k) →
motive
{ i := i, j := j, k := k, i_mul_i := i_mul_i, j_mul_j := j_mul_j, i_mul_j := i_mul_j,
j_mul_i := j_mul_i }) →
motive t |
EMetric.NonemptyCompacts.isClosed_in_closeds | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} [inst : EMetricSpace α] [CompleteSpace α],
IsClosed (Set.range TopologicalSpace.NonemptyCompacts.toCloseds) |
LinearMap.isNilpotent_mulRight_iff | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ (R : Type u_1) {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (a : A),
IsNilpotent (LinearMap.mulRight R a) ↔ IsNilpotent a |
Equiv.toIso_hom | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} {e : X ≃ Y}, e.toIso.hom = ⇑e |
_private.Mathlib.Data.Fin.Basic.0.Fin.cast_injective._simp_1_1 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} (a b : Fin n), (a = b) = (↑a = ↑b) |
Lean.Language.Lean.CommandParsedSnapshot.below_1 | Lean.Language.Lean.Types | {motive_1 : Lean.Language.Lean.CommandParsedSnapshot → Sort u} →
{motive_2 : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) → Sort u} →
{motive_3 : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot → Sort u} →
{motive_4 : Task Lean.Language.Lean.CommandParsedSnapshot → Sort u} →
Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) → Sort (max 1 u) |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq.0.Lean.Meta.Grind.Arith.Linear.updateDiseqs.match_3 | Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq | (motive :
Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCnstr × Array (ℤ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) →
Sort u_1) →
(x : Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCnstr × Array (ℤ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr)) →
((diseqs' : Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCnstr) →
(todo : Array (ℤ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr)) → motive (diseqs', todo)) →
motive x |
TensorProduct.finsuppLeft._proof_1 | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ (R : Type u_1) (S : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module S M] [IsScalarTower R S M] (ι : Type u_4),
SMulCommClass R S (ι →₀ M) |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_insertRupUnits._proof_1_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (li : Std.Tactic.BVDecide.LRAT.Internal.PosFin n), ↑li < n |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne_preserves_strongAssignmentsInvariant.match_1_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (motive : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n) → Prop)
(x : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)),
(x = none → motive none) →
(∀ (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n), x = some c → motive (some c)) → motive x |
rieszContentAux_image_nonempty | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (Λ : CompactlySupportedContinuousMap X NNReal →ₗ[NNReal] NNReal)
[T2Space X] [LocallyCompactSpace X] (K : TopologicalSpace.Compacts X), (⇑Λ '' {f | ∀ x ∈ K, 1 ≤ f x}).Nonempty |
Finset.orderIsoOfFin._proof_4 | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Finset α), (fun x => List.Mem x (s.sort fun a b => a ≤ b)) = ↑s |
Lean.Meta.AbstractNestedProofs.Context | Lean.Meta.AbstractNestedProofs | Type |
MeasurableSpace.monotone_map | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Monotone (MeasurableSpace.map f) |
List.pairwise_le_finRange | Batteries.Data.List.Lemmas | ∀ (n : ℕ), List.Pairwise (fun x1 x2 => x1 ≤ x2) (List.finRange n) |
HahnSeries.cardSuppLTAddSubgroup | Mathlib.RingTheory.HahnSeries.Cardinal | (Γ : Type u_1) →
(R : Type u_2) →
(κ : Cardinal.{u_1}) →
[inst : PartialOrder Γ] → [inst_1 : AddGroup R] → [hκ : Fact (Cardinal.aleph0 ≤ κ)] → AddSubgroup (HahnSeries Γ R) |
CompositionAsSet.length.eq_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : CompositionAsSet n), c.length = c.boundaries.card - 1 |
VAddCon._sizeOf_inst | Mathlib.Algebra.Module.Congruence.Defs | (S : Type u_2) → (M : Type u_3) → {inst : VAdd S M} → [SizeOf S] → [SizeOf M] → SizeOf (VAddCon S M) |
Filter.Tendsto.units._proof_1 | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_2} {N : Type u_1} [inst : TopologicalSpace N] [inst_1 : Monoid N] [ContinuousMul N] [T2Space N]
{f : ι → Nˣ} {r₁ r₂ : N} {l : Filter ι} [l.NeBot],
Filter.Tendsto (fun x => ↑(f x)) l (nhds r₁) → Filter.Tendsto (fun x => ↑(f x)⁻¹) l (nhds r₂) → r₁ * r₂ = 1 |
Lean.Meta.Grind.UnitLike.State.ctorIdx | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.UnitLike.State → ℕ |
CommMonoidWithZero.rec | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u_2} →
{motive : CommMonoidWithZero M₀ → Sort u} →
([toCommMonoid : CommMonoid M₀] →
[toZero : Zero M₀] →
(zero_mul : ∀ (a : M₀), 0 * a = 0) →
(mul_zero : ∀ (a : M₀), a * 0 = 0) →
motive { toCommMonoid := toCommMonoid, toZero := toZero, zero_mul := zero_mul, mul_zero := mul_zero }) →
(t : CommMonoidWithZero M₀) → motive t |
GrpCat.ext_iff | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : GrpCat} {f g : X ⟶ Y},
f = g ↔ ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x |
ModN.natCard_eq | Mathlib.LinearAlgebra.FreeModule.ModN | ∀ (G : Type u_1) [inst : AddCommGroup G] (n : ℕ) [NeZero n] [Module.Free ℤ G] [Module.Finite ℤ G],
Nat.card (ModN G n) = n ^ Module.finrank ℤ G |
Algebra.traceMatrix_reindex | Mathlib.RingTheory.Trace.Basic | ∀ {κ : Type w} (A : Type u) {B : Type v} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
{κ' : Type u_7} (b : Module.Basis κ A B) (f : κ ≃ κ'),
Algebra.traceMatrix A ⇑(b.reindex f) = (Matrix.reindex f f) (Algebra.traceMatrix A ⇑b) |
Algebra.instCompleteLatticeSubalgebra | Mathlib.Algebra.Algebra.Subalgebra.Lattice | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → CompleteLattice (Subalgebra R A) |
CategoryTheory.MonoidalCategory.prodMonoidal._proof_15 | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C₁ : Type u_1) [inst : CategoryTheory.Category.{u_3, u_1} C₁] [inst_1 : CategoryTheory.MonoidalCategory C₁]
(C₂ : Type u_2) [inst_2 : CategoryTheory.Category.{u_4, u_2} C₂] [inst_3 : CategoryTheory.MonoidalCategory C₂]
{X Y : C₁ × C₂} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Prod.mkHom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C₁, CategoryTheory.MonoidalCategoryStruct.tensorUnit C₂).1
f.1)
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C₁, CategoryTheory.MonoidalCategoryStruct.tensorUnit C₂).2
f.2))
(match Y with
| (X₁, X₂) =>
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X₁).prod
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X₂)).hom =
CategoryTheory.CategoryStruct.comp
(match X with
| (X₁, X₂) =>
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X₁).prod
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X₂)).hom
f |
Matrix.vecMulBilin._proof_6 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {m : Type u_1} {n : Type u_2} (R : Type u_4) {A : Type u_3} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : Fintype m] (x : R) (x_1 : m → A) (x_2 x_3 : Matrix m n A),
Matrix.vecMul (x • x_1) (x_2 + x_3) = Matrix.vecMul (x • x_1) x_2 + Matrix.vecMul (x • x_1) x_3 |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.matchesAt_iff_exists_isMatch._simp_1_5 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {s : String.Slice} {p : s.Pos} {q r : (s.sliceFrom p).Pos},
(q ≤ r) = (String.Slice.Pos.ofSliceFrom q ≤ String.Slice.Pos.ofSliceFrom r) |
truncSigmaOfExists._proof_1 | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} {P : α → Prop}, (∃ a, P a) → Nonempty ((a : α) ×' P a) |
Int.add_neg | Init.Data.Int.Order | ∀ {a b : ℤ}, a < 0 → b < 0 → a + b < 0 |
LieAlgebra.polyCharpoly_coeff_rank_ne_zero | Mathlib.Algebra.Lie.Rank | ∀ (R : Type u_1) (L : Type u_3) {ι : Type u_5} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [inst_5 : Fintype ι] (b : Module.Basis ι R L) [Nontrivial R]
[inst_7 : DecidableEq ι], ((↑(LieAlgebra.ad R L)).polyCharpoly b).coeff (LieAlgebra.rank R L) ≠ 0 |
CategoryTheory.BasedCategory.whiskerLeft_toNatTrans | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} {𝒵 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴)
{G H : CategoryTheory.BasedFunctor 𝒴 𝒵} (α : G ⟶ H),
(CategoryTheory.BasedCategory.whiskerLeft F α).toNatTrans = F.whiskerLeft α.toNatTrans |
Int.instTransLe | Init.Data.Int.Order | Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 |
List.forIn_map | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} {init : γ} [inst : Monad m] [LawfulMonad m]
{l : List α} {g : α → β} {f : β → γ → m (ForInStep γ)},
forIn (List.map g l) init f = forIn l init fun a y => f (g a) y |
Left.neg_lt_self | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftStrictMono α] {a : α}, 0 < a → -a < a |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ult._regBuiltin.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ult.declare_1._@.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.2445608185._hygCtx._hyg.16 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | IO Unit |
BitVec.equivFin._proof_1 | Mathlib.Data.BitVec | ∀ {m : ℕ}, Function.LeftInverse (fun a => { toFin := a }) fun a => a.toFin |
EReal.neg_mul | Mathlib.Data.EReal.Operations | ∀ (x y : EReal), -x * y = -(x * y) |
Std.IdempotentOp.idempotent | Init.Core | ∀ {α : Sort u} {op : α → α → α} [self : Std.IdempotentOp op] (x : α), op x x = x |
LinearEquiv.conjAlgEquiv | Mathlib.Algebra.Algebra.Equiv | (R : Type u_1) →
{S : Type u_2} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : Module R M₁] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M₂] →
[inst_5 : Semiring S] →
[inst_6 : Module S M₁] →
[inst_7 : Module S M₂] →
[inst_8 : SMulCommClass S R M₁] →
[inst_9 : SMulCommClass S R M₂] →
[inst_10 : SMul R S] →
[inst_11 : IsScalarTower R S M₁] →
[inst_12 : IsScalarTower R S M₂] → (M₁ ≃ₗ[S] M₂) → Module.End S M₁ ≃ₐ[R] Module.End S M₂ |
Lean.Compiler.LCNF.Closure.State.rec | Lean.Compiler.LCNF.Closure | {motive : Lean.Compiler.LCNF.Closure.State → Sort u} →
((visited : Lean.FVarIdHashSet) →
(params : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) →
(decls : Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure)) →
motive { visited := visited, params := params, decls := decls }) →
(t : Lean.Compiler.LCNF.Closure.State) → motive t |
CategoryTheory.Monad.monadToMon._proof_2 | Mathlib.CategoryTheory.Monad.EquivMon | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : CategoryTheory.Monad C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one f.toNatTrans = CategoryTheory.MonObj.one |
HahnModule.instSMulZeroClass | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{Γ' : Type u_2} →
{R : Type u_3} →
{V : Type u_5} →
[inst : PartialOrder Γ] →
[inst_1 : PartialOrder Γ'] →
[inst_2 : VAdd Γ Γ'] →
[IsOrderedCancelVAdd Γ Γ'] →
[inst_4 : AddCommMonoid V] →
[inst_5 : Zero R] → [inst_6 : SMulZeroClass R V] → SMulZeroClass (HahnSeries Γ R) (HahnModule Γ' R V) |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rcc.size_eq_if_roc._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxc.HasSize α]
[Std.Rxc.LawfulHasSize α] {lo hi : α}, (Std.Rxc.HasSize.size lo hi = 0) = ¬lo ≤ hi |
HasMFDerivAt.mdifferentiableAt | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {x : M}
{f' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)}, HasMFDerivAt I I' f x f' → MDifferentiableAt I I' f x |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryFst._proof_2 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) {X_1 Y_1 : CategoryTheory.Over X} (g : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight g.left Y)
(CategoryTheory.Over.mk (CategoryTheory.MonoidalCategoryStruct.whiskerRight Y_1.hom Y)).hom =
(CategoryTheory.Over.mk (CategoryTheory.MonoidalCategoryStruct.whiskerRight X_1.hom Y)).hom |
AddMonoidAlgebra.ofMagma | Mathlib.Algebra.MonoidAlgebra.Defs | (R : Type u_8) → (M : Type u_9) → [inst : Semiring R] → [inst_1 : Add M] → Multiplicative M →ₙ* AddMonoidAlgebra R M |
CategoryTheory.MorphismProperty.Over.map.congr_simp | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) [inst_1 : Q.IsMultiplicative] {X Y : T} [inst_2 : P.IsStableUnderComposition]
{f f_1 : X ⟶ Y} (e_f : f = f_1) (hPf : P f),
CategoryTheory.MorphismProperty.Over.map Q hPf = CategoryTheory.MorphismProperty.Over.map Q ⋯ |
CategoryTheory.Aut.autMulEquivOfIso._proof_13 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (h : X ≅ Y) (x y : CategoryTheory.Aut X),
{ hom := CategoryTheory.CategoryStruct.comp h.inv (CategoryTheory.CategoryStruct.comp (x * y).hom h.hom),
inv := CategoryTheory.CategoryStruct.comp h.inv (CategoryTheory.CategoryStruct.comp (x * y).inv h.hom),
hom_inv_id := ⋯, inv_hom_id := ⋯ } =
{ hom := CategoryTheory.CategoryStruct.comp h.inv (CategoryTheory.CategoryStruct.comp x.hom h.hom),
inv := CategoryTheory.CategoryStruct.comp h.inv (CategoryTheory.CategoryStruct.comp x.inv h.hom),
hom_inv_id := ⋯, inv_hom_id := ⋯ } *
{ hom := CategoryTheory.CategoryStruct.comp h.inv (CategoryTheory.CategoryStruct.comp y.hom h.hom),
inv := CategoryTheory.CategoryStruct.comp h.inv (CategoryTheory.CategoryStruct.comp y.inv h.hom),
hom_inv_id := ⋯, inv_hom_id := ⋯ } |
MonoidWithZeroHom.funLike._proof_1 | Mathlib.Algebra.GroupWithZero.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : MulZeroOneClass α] [inst_1 : MulZeroOneClass β] (f g : α →*₀ β),
(fun f => (↑f).toFun) f = (fun f => (↑f).toFun) g → f = g |
Nonneg.one | Mathlib.Algebra.Order.Nonneg.Basic | {α : Type u_1} → [inst : Zero α] → [inst_1 : One α] → [inst_2 : LE α] → [ZeroLEOneClass α] → One { x // 0 ≤ x } |
Nondet.bind.match_3 | Batteries.Control.Nondet.Basic | {σ : Type} →
{m : Type → Type} →
{α : Type} →
(motive : Option ((α × σ) × MLList m (α × σ)) → Sort u_1) →
(__do_lift : Option ((α × σ) × MLList m (α × σ))) →
(Unit → motive none) →
((x : α) → (s : σ) → (xs : MLList m (α × σ)) → motive (some ((x, s), xs))) → motive __do_lift |
_private.Mathlib.MeasureTheory.Function.UnifTight.0.MeasureTheory.unifTight_of_tendsto_Lp | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : NormedAddCommGroup β] {μ : MeasureTheory.Measure α}
{p : ENNReal} {f : ℕ → α → β} {g : α → β},
p ≠ ⊤ →
(∀ (n : ℕ), MeasureTheory.MemLp (f n) p μ) →
MeasureTheory.MemLp g p μ →
Filter.Tendsto (fun n => MeasureTheory.eLpNorm (f n - g) p μ) Filter.atTop (nhds 0) →
MeasureTheory.UnifTight f p μ |
Lean.Meta.Simp.registerBuiltinSimproc | Lean.Meta.Tactic.Simp.Simproc | Lean.Name → Array Lean.Meta.SimpTheoremKey → Lean.Meta.Simp.Simproc → IO Unit |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_714 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
¬[g a, g (g a)].Nodup →
∀ (w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] [g (g a)].length) <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
_private.Mathlib.Data.Sign.Basic.0.sign_sum._simp_1_1 | Mathlib.Data.Sign.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] {a : α}, (SignType.sign a = 0) = (a = 0) |
TopologicalSpace.CompactOpens.instInf._proof_1 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [QuasiSeparatedSpace α] (U V : TopologicalSpace.CompactOpens α),
IsCompact (U.carrier ∩ V.carrier) |
ZeroAtInftyContinuousMap.instStarModule | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] {𝕜 : Type u_2} [inst_1 : Zero 𝕜] [inst_2 : Star 𝕜]
[inst_3 : AddMonoid β] [inst_4 : StarAddMonoid β] [inst_5 : TopologicalSpace β] [inst_6 : ContinuousStar β]
[inst_7 : SMulWithZero 𝕜 β] [inst_8 : ContinuousConstSMul 𝕜 β] [StarModule 𝕜 β],
StarModule 𝕜 (ZeroAtInftyContinuousMap α β) |
CategoryTheory.Limits.CategoricalPullback.mkIso._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_3} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_2, u_4} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
{x y : CategoryTheory.Limits.CategoricalPullback F G} (eₗ : x.fst ≅ y.fst) (eᵣ : x.snd ≅ y.snd)
(w :
CategoryTheory.CategoryStruct.comp (F.map eₗ.hom) y.iso.hom =
CategoryTheory.CategoryStruct.comp x.iso.hom (G.map eᵣ.hom)),
CategoryTheory.CategoryStruct.comp { fst := eₗ.hom, snd := eᵣ.hom, w := w } { fst := eₗ.inv, snd := eᵣ.inv, w := ⋯ } =
CategoryTheory.CategoryStruct.id x |
PseudoEpimorphism.comp_apply | Mathlib.Topology.Order.Hom.Esakia | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
(g : PseudoEpimorphism β γ) (f : PseudoEpimorphism α β) (a : α), (g.comp f) a = g (f a) |
AlgebraicGeometry.LocallyRingedSpace.Γevaluation_naturality | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) (x : ↑X.toTopCat),
CategoryTheory.CategoryStruct.comp (Y.Γevaluation ((CategoryTheory.ConcreteCategory.hom f.base) x))
(AlgebraicGeometry.LocallyRingedSpace.residueFieldMap f x) =
CategoryTheory.CategoryStruct.comp (f.c.app (Opposite.op ⊤)) (X.Γevaluation x) |
CategoryTheory.ShortComplex.toCycles_comp_leftHomologyπ | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology],
CategoryTheory.CategoryStruct.comp S.toCycles S.leftHomologyπ = 0 |
NFA.Path.supp._sunfold | Mathlib.Computability.NFA | {α : Type u} → {σ : Type v} → {M : NFA α σ} → [DecidableEq σ] → {s t : σ} → {x : List α} → M.Path s t x → Finset σ |
IntermediateField.add_mem | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L)
{x y : L}, x ∈ S → y ∈ S → x + y ∈ S |
Order.IsPredPrelimit.subtypeVal | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α},
IsUpperSet s → ∀ {a : ↑s}, Order.IsPredPrelimit a → Order.IsPredPrelimit ↑a |
unitInterval.instLinearOrderedCommMonoidWithZeroElemReal._proof_1 | Mathlib.Topology.UnitInterval | ∀ (i : ↑unitInterval), 0 * i = 0 |
CategoryTheory.Limits.multicospanShapeEnd_fst | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ (J : Type u) [inst : CategoryTheory.Category.{v, u} J] (f : CategoryTheory.Arrow J),
(CategoryTheory.Limits.multicospanShapeEnd J).fst f = f.left |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.