name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Set.unbounded_le_iff | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α], Set.Unbounded (fun x1 x2 => x1 ≤ x2) s ↔ ∀ (a : α), ∃ b ∈ s, a < b |
Polynomial.monic_X_pow_sub_C | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Ring R] (a : R) {n : ℕ}, n ≠ 0 → (Polynomial.X ^ n - Polynomial.C a).Monic |
CategoryTheory.MorphismProperty.MapFactorizationData.hp | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} {X Y : C}
{f : X ⟶ Y} (self : W₁.MapFactorizationData W₂ f), W₂ self.p |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars.0.Lean.Meta.Grind.Arith.Cutsat.cmp₁ | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | Array Lean.Meta.Grind.Arith.Cutsat.VarInfo → Int.Linear.Var → Int.Linear.Var → Ordering |
Lean.Lsp.instToJsonMarkupContent | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.MarkupContent |
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.Environment.mk.sizeOf_spec | Std.Internal.Async.System | ∀ (toHashMap : Std.HashMap String String), sizeOf { toHashMap := toHashMap } = 1 + sizeOf toHashMap |
instFloorSemiringNat._proof_1 | Mathlib.Algebra.Order.Floor.Defs | ∀ {a n : ℕ}, n ≤ id a ↔ ↑n ≤ a |
Std.DTreeMap.Raw.inter_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp}, t₁.inter t₂ = t₁ ∩ t₂ |
Int.neg_clog_inv_eq_log | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [inst_3 : FloorSemiring R]
(b : ℕ) (r : R), -Int.clog b r⁻¹ = Int.log b r |
compl_le_compl | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ≤ b → bᶜ ≤ aᶜ |
CategoryTheory.instQuiverMonad | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → Quiver (CategoryTheory.Monad C) |
Array.back_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : ℕ → α → β} (h : 0 < (Array.mapIdx f xs).size),
(Array.mapIdx f xs).back h = f (xs.size - 1) (xs.back ⋯) |
List.getLast!_eq_getLast?_getD | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Inhabited α] {l : List α}, l.getLast! = l.getLast?.getD default |
MonoidHom.decidableMemRange | Mathlib.Algebra.Group.Subgroup.Finite | {G : Type u_1} →
[inst : Group G] →
{N : Type u_3} →
[inst_1 : Group N] → (f : G →* N) → [Fintype G] → [DecidableEq N] → DecidablePred fun x => x ∈ f.range |
AddSubmonoid.addGroupMultiples._proof_4 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : AddMonoid M] {x : M} {n : ℕ},
n • x = 0 → ∀ (m : ℕ) (x_1 : ↥(AddSubmonoid.multiples x)), (↑m.succ).natMod ↑n • x_1 = (↑m).natMod ↑n • x_1 + x_1 |
CategoryTheory.Functor.whiskerRight._proof_1 | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} E]
{G H : CategoryTheory.Functor C D} (α : G ⟶ H) (F : CategoryTheory.Functor D E) (X Y : C) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((G.comp F).map f) (F.map (α.app Y)) =
CategoryTheory.CategoryStruct.comp (F.map (α.app X)) ((H.comp F).map f) |
UInt64.reduceMul._regBuiltin.UInt64.reduceMul.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4002762760._hygCtx._hyg.55 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
MultilinearMap.dfinsuppFamily._proof_6 | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {ι : Type u_1} {κ : ι → Type u_2} {R : Type u_5} {M : (i : ι) → κ i → Type u_3} {N : ((i : ι) → κ i) → Type u_4}
[inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : Semiring R]
[inst_3 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)] [inst_4 : (p : (i : ι) → κ i) → AddCommMonoid (N p)]
[inst_5 : (i : ι) → (k : κ i) → Module R (M i k)] [inst_6 : (p : (i : ι) → κ i) → Module R (N p)]
(f : (p : (i : ι) → κ i) → MultilinearMap R (fun i => M i (p i)) (N p)) (x : (i : ι) → Π₀ (j : κ i), M i j)
(s : (i : ι) → { s // ∀ (i_1 : κ i), i_1 ∈ s ∨ (x i).toFun i_1 = 0 }) (p : (i : ι) → κ i),
p ∈ Multiset.map (fun f i => f i ⋯) (Finset.univ.val.pi fun i => ↑(s i)) ∨ ((f p) fun i => (x i) (p i)) = 0 |
Set.tprod.eq_def | Mathlib.Data.Prod.TProd | ∀ {ι : Type u} {α : ι → Type v} (x : List ι) (x_1 : (i : ι) → Set (α i)),
Set.tprod x x_1 =
match x, x_1 with
| [], x => Set.univ
| i :: is, t => t i ×ˢ Set.tprod is t |
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop._proof_1 | Init.Data.Array.InsertionSort | ∀ {α : Type u_1} (j : ℕ) (xs : Array α), j < xs.size → ∀ (j' : ℕ), j = j'.succ → j' < xs.size |
Std.DHashMap.Internal.toListModel_replicate_nil | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {c : ℕ},
Std.DHashMap.Internal.toListModel (Array.replicate c Std.DHashMap.Internal.AssocList.nil) = [] |
HomogeneousIdeal.toIdeal_inf | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), (I ⊓ J).toIdeal = I.toIdeal ⊓ J.toIdeal |
isLUB_singleton._simp_2 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsLUB {a} a = True |
Int.getElem?_toArray_rcc_eq_some_iff | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ} {i : ℕ}, (m...=n).toArray[i]? = some k ↔ i < (n + 1 - m).toNat ∧ m + ↑i = k |
HasStrictFDerivAt.const_cpow | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {f' : StrongDual ℂ E} {x : E}
{c : ℂ},
HasStrictFDerivAt f f' x → c ≠ 0 ∨ f x ≠ 0 → HasStrictFDerivAt (fun x => c ^ f x) ((c ^ f x * Complex.log c) • f') x |
CategoryTheory.Abelian.LeftResolution.chainComplexXIso | Mathlib.Algebra.Homology.LeftResolution.Basic | {A : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] →
{ι : CategoryTheory.Functor C A} →
(Λ : CategoryTheory.Abelian.LeftResolution ι) →
(X : A) →
[inst_2 : ι.Full] →
[inst_3 : ι.Faithful] →
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_5 : CategoryTheory.Abelian A] →
(n : ℕ) →
(Λ.chainComplex X).X (n + 2) ≅
Λ.F.obj (CategoryTheory.Limits.kernel (ι.map ((Λ.chainComplex X).d (n + 1) n))) |
_private.Mathlib.Probability.Independence.ZeroOne.0.ProbabilityTheory.Kernel.indep_limsup_atTop_self._simp_1_2 | Mathlib.Probability.Independence.ZeroOne | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) |
Monoid.CoprodI.NeWord.last.eq_def | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (x x_1 : ι) (x_2 : Monoid.CoprodI.NeWord M x x_1),
x_2.last =
match x, x_1, x_2 with
| x, .(x), Monoid.CoprodI.NeWord.singleton x_3 _hne1 => x_3
| x, x_3, _w₁.append _hne w₂ => w₂.last |
Finset.disjoint_val._simp_1 | Mathlib.Data.Finset.Disjoint | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s.val t.val = Disjoint s t |
MeasureTheory.mem_fundamentalFrontier._simp_2 | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] {s : Set α} {x : α},
(x ∈ MeasureTheory.fundamentalFrontier G s) = (x ∈ s ∧ ∃ g, g ≠ 1 ∧ x ∈ g • s) |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comap_isBasis_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
Lean.Expr.hasNonSyntheticSorry | Lean.Util.Sorry | Lean.Expr → Bool |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Solvers.mergeTerms.go.match_3._arg_pusher | Lean.Meta.Tactic.Grind.Types | ∀ (motive : Lean.Meta.Grind.SolverTerms → Lean.Meta.Grind.SolverTerms → Sort u_1) (α : Sort u✝) (β : α → Sort v✝)
(f : (x : α) → β x) (rel : Lean.Meta.Grind.SolverTerms → Lean.Meta.Grind.SolverTerms → α → Prop)
(rhsTerms lhsTerms : Lean.Meta.Grind.SolverTerms)
(h_1 :
Unit →
((y : α) → rel Lean.Meta.Grind.SolverTerms.nil Lean.Meta.Grind.SolverTerms.nil y → β y) →
motive Lean.Meta.Grind.SolverTerms.nil Lean.Meta.Grind.SolverTerms.nil)
(h_2 :
(solverId : ℕ) →
(e : Lean.Expr) →
(rest : Lean.Meta.Grind.SolverTerms) →
((y : α) → rel Lean.Meta.Grind.SolverTerms.nil (Lean.Meta.Grind.SolverTerms.next solverId e rest) y → β y) →
motive Lean.Meta.Grind.SolverTerms.nil (Lean.Meta.Grind.SolverTerms.next solverId e rest))
(h_3 :
(solverId : ℕ) →
(e : Lean.Expr) →
(rest : Lean.Meta.Grind.SolverTerms) →
((y : α) → rel (Lean.Meta.Grind.SolverTerms.next solverId e rest) Lean.Meta.Grind.SolverTerms.nil y → β y) →
motive (Lean.Meta.Grind.SolverTerms.next solverId e rest) Lean.Meta.Grind.SolverTerms.nil)
(h_4 :
(id₁ : ℕ) →
(rhs : Lean.Expr) →
(rhsTerms : Lean.Meta.Grind.SolverTerms) →
(id₂ : ℕ) →
(lhs : Lean.Expr) →
(lhsTerms : Lean.Meta.Grind.SolverTerms) →
((y : α) →
rel (Lean.Meta.Grind.SolverTerms.next id₁ rhs rhsTerms)
(Lean.Meta.Grind.SolverTerms.next id₂ lhs lhsTerms) y →
β y) →
motive (Lean.Meta.Grind.SolverTerms.next id₁ rhs rhsTerms)
(Lean.Meta.Grind.SolverTerms.next id₂ lhs lhsTerms)),
((match (motive :=
(rhsTerms lhsTerms : Lean.Meta.Grind.SolverTerms) →
((y : α) → rel rhsTerms lhsTerms y → β y) → motive rhsTerms lhsTerms)
rhsTerms, lhsTerms with
| Lean.Meta.Grind.SolverTerms.nil, Lean.Meta.Grind.SolverTerms.nil => fun x => h_1 a x
| Lean.Meta.Grind.SolverTerms.nil, Lean.Meta.Grind.SolverTerms.next solverId e rest => fun x =>
h_2 solverId e rest x
| Lean.Meta.Grind.SolverTerms.next solverId e rest, Lean.Meta.Grind.SolverTerms.nil => fun x =>
h_3 solverId e rest x
| Lean.Meta.Grind.SolverTerms.next id₁ rhs rhsTerms, Lean.Meta.Grind.SolverTerms.next id₂ lhs lhsTerms => fun x =>
h_4 id₁ rhs rhsTerms id₂ lhs lhsTerms x)
fun y h => f y) =
match rhsTerms, lhsTerms with
| Lean.Meta.Grind.SolverTerms.nil, Lean.Meta.Grind.SolverTerms.nil => h_1 a fun y h => f y
| Lean.Meta.Grind.SolverTerms.nil, Lean.Meta.Grind.SolverTerms.next solverId e rest =>
h_2 solverId e rest fun y h => f y
| Lean.Meta.Grind.SolverTerms.next solverId e rest, Lean.Meta.Grind.SolverTerms.nil =>
h_3 solverId e rest fun y h => f y
| Lean.Meta.Grind.SolverTerms.next id₁ rhs rhsTerms, Lean.Meta.Grind.SolverTerms.next id₂ lhs lhsTerms =>
h_4 id₁ rhs rhsTerms id₂ lhs lhsTerms fun y h => f y |
CategoryTheory.Join.instUniqueHomLeftRight | Mathlib.CategoryTheory.Join.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{X : C} → {Y : D} → Unique (CategoryTheory.Join.left X ⟶ CategoryTheory.Join.right Y) |
MemHolder.nsmul | Mathlib.Topology.MetricSpace.HolderNorm | ∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : NormedAddCommGroup Y] {r : NNReal} {f : X → Y}
[NormedSpace ℝ Y] (n : ℕ), MemHolder r f → MemHolder r (n • f) |
Fin.val_sub_one_of_ne_zero | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {i : Fin n}, i ≠ 0 → ↑(i - 1) = ↑i - 1 |
_private.Mathlib.Data.Nat.PartENat.0.PartENat.instLinearOrderedAddCommMonoidWithTop._simp_1 | Mathlib.Data.Nat.PartENat | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (a ≠ b) = (a < b ∨ b < a) |
_private.Mathlib.Data.EReal.Basic.0.EReal.exists_rat_btwn_of_lt.match_1_3 | Mathlib.Data.EReal.Basic | ∀ (a : ℝ) (motive : (∃ q, ↑q < a) → Prop) (x : ∃ q, ↑q < a), (∀ (b : ℚ) (hab : ↑b < a), motive ⋯) → motive x |
CategoryTheory.Limits.IsLimit.liftConeMorphism | 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} →
{t : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit t → (s : CategoryTheory.Limits.Cone F) → s ⟶ t |
Equiv.sumIsRight_apply | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_1} {β : Type u_2} (x : { x // x.isRight = true }), Equiv.sumIsRight x = (↑x).getRight ⋯ |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_10 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} (hl : l ≠ []), ¬[l.getLast ⋯].isEmpty = true → [l.getLast ⋯] ≠ [] |
CategoryTheory.Limits.pushoutPushoutRightIsPushout._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X₁ X₂ X₃ Z₁ Z₂ : C} (g₁ : Z₁ ⟶ X₁) (g₂ : Z₁ ⟶ X₂)
(g₃ : Z₂ ⟶ X₂) (g₄ : Z₂ ⟶ X₃) [CategoryTheory.Limits.HasPushout g₁ g₂]
[inst_2 : CategoryTheory.Limits.HasPushout g₃ g₄]
[inst_3 :
CategoryTheory.Limits.HasPushout g₁
(CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄))],
CategoryTheory.CategoryStruct.comp g₁
(CategoryTheory.Limits.pushout.inl g₁
(CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄))) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄))
(CategoryTheory.Limits.pushout.inr g₁
(CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄))) |
CliffordAlgebra.reverse_involutive._simp_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M}, Function.Involutive ⇑CliffordAlgebra.reverse = True |
Lean.Parser.numLitFn | Lean.Parser.Basic | Lean.Parser.ParserFn |
StarAlgebra.elemental.characterSpaceToSpectrum._proof_4 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ {A : Type u_1} [inst : CStarAlgebra A], SubringClass (StarSubalgebra ℂ A) A |
Algebra.normalizedTrace_algebraMap_apply | Mathlib.FieldTheory.NormalizedTrace | ∀ (F : Type u_3) (E : Type u_4) (K : Type u_5) [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra E K] [inst_5 : Algebra F K] [IsScalarTower F E K]
[inst_7 : Algebra.IsIntegral F E] [inst_8 : Algebra.IsIntegral F K] [inst_9 : CharZero F] (a : E),
(Algebra.normalizedTrace F K) ((algebraMap E K) a) = (Algebra.normalizedTrace F E) a |
sup_left_right_swap | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] (a b c : α), a ⊔ b ⊔ c = c ⊔ b ⊔ a |
pythagoreanTriple_comm | Mathlib.NumberTheory.PythagoreanTriples | ∀ {x y z : ℤ}, PythagoreanTriple x y z ↔ PythagoreanTriple y x z |
AlgebraicGeometry.IsOpenImmersion.ΓIsoTop._proof_1 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f],
AlgebraicGeometry.Scheme.Hom.opensRange f = (AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj ⊤ |
Asymptotics.isTheta_of_div_tendsto_nhds_ne_zero | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {𝕜 : Type u_14} [inst : NormedField 𝕜] {l : Filter α} {c : 𝕜} {f g : α → 𝕜},
Filter.Tendsto (fun x => g x / f x) l (nhds c) → c ≠ 0 → f =Θ[l] g |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_rotateLeft_of_lt._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {r n : ℕ} (w : ℕ), r < w + 1 → n < w + 1 - r → ¬n < w + 1 → False |
CategoryTheory.MorphismProperty.IsLocalAtSource.rec | Mathlib.CategoryTheory.MorphismProperty.Local | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{P : CategoryTheory.MorphismProperty C} →
{K : CategoryTheory.Precoverage C} →
{motive : P.IsLocalAtSource K → Sort u_1} →
([toRespects : P.Respects (CategoryTheory.MorphismProperty.isomorphisms C)] →
(comp :
∀ {X Y : C} {f : X ⟶ Y} (𝒰 : K.ZeroHypercover X) (i : 𝒰.I₀),
P f → P (CategoryTheory.CategoryStruct.comp (𝒰.f i) f)) →
(of_zeroHypercover :
∀ {X Y : C} {f : X ⟶ Y} (𝒰 : K.ZeroHypercover X),
(∀ (i : 𝒰.I₀), P (CategoryTheory.CategoryStruct.comp (𝒰.f i) f)) → P f) →
motive ⋯) →
(t : P.IsLocalAtSource K) → motive t |
CategoryTheory.Functor.LaxMonoidal.right_unitality | 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) [self : F.LaxMonoidal] (X : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (F.obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) (CategoryTheory.Functor.LaxMonoidal.ε F))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.μ F X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
(F.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom)) |
_private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.logb_prod._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : CommMonoidWithZero M₀] {f : ι → M₀} {s : Finset ι} [Nontrivial M₀]
[NoZeroDivisors M₀], (∏ x ∈ s, f x ≠ 0) = ∀ a ∈ s, f a ≠ 0 |
CategoryTheory.FreeMonoidalCategory.Hom.ρ_hom.elim | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : (a a_1 : CategoryTheory.FreeMonoidalCategory C) → a.Hom a_1 → Sort u_1} →
{a a_1 : CategoryTheory.FreeMonoidalCategory C} →
(t : a.Hom a_1) →
t.ctorIdx = 5 →
((X : CategoryTheory.FreeMonoidalCategory C) →
motive (X.tensor CategoryTheory.FreeMonoidalCategory.unit) X
(CategoryTheory.FreeMonoidalCategory.Hom.ρ_hom X)) →
motive a a_1 t |
UpperHalfPlane.dist_triangle | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | ∀ (a b c : UpperHalfPlane), dist a c ≤ dist a b + dist b c |
_private.Mathlib.Combinatorics.Pigeonhole.0.Fintype.exists_card_fiber_lt_of_card_lt_nsmul.match_1_1 | Mathlib.Combinatorics.Pigeonhole | ∀ {α : Type u_3} {β : Type u_1} {M : Type u_2} [inst : DecidableEq β] [inst_1 : Fintype α] [inst_2 : Fintype β]
(f : α → β) {b : M} [inst_3 : CommSemiring M] [inst_4 : LinearOrder M]
(motive : (∃ y ∈ Finset.univ, ↑{x | f x = y}.card < b) → Prop) (x : ∃ y ∈ Finset.univ, ↑{x | f x = y}.card < b),
(∀ (y : β) (left : y ∈ Finset.univ) (h : ↑{x | f x = y}.card < b), motive ⋯) → motive x |
MeasureTheory.average_const | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[CompleteSpace E] (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ] [h : NeZero μ] (c : E),
⨍ (_x : α), c ∂μ = c |
Batteries.UnionFind.link | Batteries.Data.UnionFind.Basic | (self : Batteries.UnionFind) → Fin self.size → (y : Fin self.size) → self.parent ↑y = ↑y → Batteries.UnionFind |
CategoryTheory.Iso.self_symm_conj | Mathlib.CategoryTheory.Conj | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.End Y),
α.conj (α.symm.conj f) = f |
_private.Mathlib.Analysis.Complex.Poisson.0.le_re_herglotzRieszKernel_aux._simp_1_4 | Mathlib.Analysis.Complex.Poisson | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
EmbeddingLike.comp_injective._simp_1 | Mathlib.Data.FunLike.Embedding | ∀ {α : Sort u_2} {β : Sort u_3} {γ : Sort u_4} {F : Sort u_5} [inst : FunLike F β γ] [EmbeddingLike F β γ] (f : α → β)
(e : F), Function.Injective (⇑e ∘ f) = Function.Injective f |
_private.Mathlib.Order.OrderIsoNat.0.exists_covBy_seq_of_wellFoundedLT_wellFoundedGT_of_le._simp_1_2 | Mathlib.Order.OrderIsoNat | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) |
AddSubmonoid.matrix._proof_1 | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : AddMonoid A] (S : AddSubmonoid A) {a b : Matrix m n A},
a ∈ (↑S).matrix → b ∈ (↑S).matrix → ∀ (i : m) (j : n), a i j + b i j ∈ S |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero_hom_app_hom₃ | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (X : CategoryTheory.Pretriangulated.Triangle C),
((CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero C).hom.app X).hom₃ =
(CategoryTheory.shiftFunctorZero C ℤ).hom.app X.obj₃ |
IsCyclotomicExtension.Rat.ramificationIdxIn_eq | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (n : ℕ) {m p k : ℕ} [hp : Fact (Nat.Prime p)] (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
[IsCyclotomicExtension {n} ℚ K],
n = p ^ (k + 1) * m → ¬p ∣ m → (Ideal.span {↑p}).ramificationIdxIn (NumberField.RingOfIntegers K) = p ^ k * (p - 1) |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Option.map_dmap | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (x : Option α) (f : (a : α) → x = some a → β) (g : β → γ),
Option.map g (Std.Internal.List.Option.dmap✝ x f) = Std.Internal.List.Option.dmap✝¹ x fun a h => g (f a h) |
Lean.Grind.CommRing.Mon.beq' | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Bool |
Polynomial.natDegree_multiset_prod_of_monic | Mathlib.Algebra.Polynomial.BigOperators | ∀ {R : Type u} [inst : CommSemiring R] (t : Multiset (Polynomial R)),
(∀ f ∈ t, f.Monic) → t.prod.natDegree = (Multiset.map Polynomial.natDegree t).sum |
CategoryTheory.Bicategory.rightUnitor_comp_inv | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
(CategoryTheory.Bicategory.rightUnitor (CategoryTheory.CategoryStruct.comp f g)).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.rightUnitor g).inv)
(CategoryTheory.Bicategory.associator f g (CategoryTheory.CategoryStruct.id c)).inv |
ISize.toBitVec_or | Init.Data.SInt.Bitwise | ∀ (a b : ISize), (a ||| b).toBitVec = a.toBitVec ||| b.toBitVec |
Mathlib.Tactic.BicategoryLike.HorizontalComp.cons.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | ∀ (e : Mathlib.Tactic.BicategoryLike.Mor₂) (η : Mathlib.Tactic.BicategoryLike.WhiskerRight)
(ηs : Mathlib.Tactic.BicategoryLike.HorizontalComp),
sizeOf (Mathlib.Tactic.BicategoryLike.HorizontalComp.cons e η ηs) = 1 + sizeOf e + sizeOf η + sizeOf ηs |
Std.DTreeMap.Raw.instInhabited | Std.Data.DTreeMap.Raw.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Inhabited (Std.DTreeMap.Raw α β cmp) |
AlgCat.instCategory._proof_1 | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (R : Type u_2) [inst : CommRing R] {X Y : AlgCat R} (f : X.Hom Y),
{ hom' := f.hom'.comp { hom' := AlgHom.id R ↑X }.hom' } = f |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionOfMonoidalFunctorToEndofunctor._proof_14 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) [inst_3 : F.Monoidal] (c : C) {c' c'' : C} (f : c' ⟶ c'')
(d : D),
(F.map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft c f)).app d =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.Monoidal.μIso F c c').app d).symm.hom
(CategoryTheory.CategoryStruct.comp ((F.map f).app ((F.obj c).obj d))
((CategoryTheory.Functor.Monoidal.μIso F c c'').app d).symm.inv) |
ContinuousMonoidHom.compLeft._proof_1 | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ {A : Type u_1} {B : Type u_3} (E : Type u_2) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : CommGroup E]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace E]
[inst_6 : IsTopologicalGroup E] (f : A →ₜ* B), ContinuousMonoidHom.comp 1 f = ContinuousMonoidHom.comp 1 f |
Finsupp.Lex.wellFounded | Mathlib.Data.Finsupp.WellFounded | ∀ {α : Type u_1} {N : Type u_2} [inst : Zero N] {r : α → α → Prop} {s : N → N → Prop},
(∀ ⦃n : N⦄, ¬s n 0) → WellFounded s → WellFounded (rᶜ ⊓ fun x1 x2 => x1 ≠ x2) → WellFounded (Finsupp.Lex r s) |
Lean.Elab.Tactic.Conv.evalUnfold | Lean.Elab.Tactic.Conv.Unfold | Lean.Elab.Tactic.Tactic |
ENNReal.add_lt_add_iff_right | Mathlib.Data.ENNReal.Operations | ∀ {a b c : ENNReal}, a ≠ ⊤ → (b + a < c + a ↔ b < c) |
PSigma.Lex.orderTop._proof_1 | Mathlib.Data.PSigma.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : PartialOrder ι] [inst_1 : OrderTop ι] [inst_2 : (i : ι) → Preorder (α i)]
[inst_3 : OrderTop (α ⊤)] (a : ι) (b : α a), ⟨a, b⟩ ≤ ⟨⊤, ⊤⟩ |
Std.DTreeMap.Internal.Unit.RioSliceData._sizeOf_inst | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) → {inst : Ord α} → [SizeOf α] → SizeOf (Std.DTreeMap.Internal.Unit.RioSliceData α) |
Bundle.Trivialization.coordChangeL | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_4} →
[inst : Semiring R] →
[inst_1 : TopologicalSpace F] →
[inst_2 : TopologicalSpace B] →
[inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] →
[inst_4 : AddCommMonoid F] →
[inst_5 : Module R F] →
[inst_6 : (x : B) → AddCommMonoid (E x)] →
[inst_7 : (x : B) → Module R (E x)] →
(e e' : Bundle.Trivialization F Bundle.TotalSpace.proj) →
[Bundle.Trivialization.IsLinear R e] → [Bundle.Trivialization.IsLinear R e'] → B → F ≃L[R] F |
Std.ExtDTreeMap.maxKeyD_le | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp],
t ≠ ∅ → ∀ {k fallback : α}, (cmp (t.maxKeyD fallback) k).isLE = true ↔ ∀ k' ∈ t, (cmp k' k).isLE = true |
Set.subset_symmDiff_union_symmDiff_left | Mathlib.Data.Set.SymmDiff | ∀ {α : Type u} {s t u : Set α}, Disjoint s t → u ⊆ symmDiff s u ∪ symmDiff t u |
HomologicalComplex.extend.d_eq | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {c : ComplexShape ι} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c) {i j : Option ι} {a b : ι} (hi : i = some a) (hj : j = some b),
HomologicalComplex.extend.d K i j =
CategoryTheory.CategoryStruct.comp (HomologicalComplex.extend.XIso K hi).hom
(CategoryTheory.CategoryStruct.comp (K.d a b) (HomologicalComplex.extend.XIso K hj).inv) |
ContinuousMap.tendsto_iff_tendstoLocallyUniformly | Mathlib.Topology.UniformSpace.CompactConvergence | ∀ {α : Type u₁} {β : Type u₂} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {f : C(α, β)} {ι : Type u₃}
{p : Filter ι} {F : ι → C(α, β)} [WeaklyLocallyCompactSpace α],
Filter.Tendsto F p (nhds f) ↔ TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p |
CompletelyRegularSpace.mk | Mathlib.Topology.Separation.CompletelyRegular | ∀ {X : Type u} [inst : TopologicalSpace X],
(∀ (x : X) (K : Set X), IsClosed K → x ∉ K → ∃ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K) → CompletelyRegularSpace X |
BitVec.carry_extractLsb'_eq_carry | Init.Data.BitVec.Bitblast | ∀ {w i len : ℕ},
i < len →
∀ {x y : BitVec w} {b : Bool},
BitVec.carry i (BitVec.extractLsb' 0 len x) (BitVec.extractLsb' 0 len y) b = BitVec.carry i x y b |
CategoryTheory.Bicategory.InducedBicategory.bicategory._proof_2 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c : CategoryTheory.Bicategory.InducedBicategory C F} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.Bicategory.InducedBicategory.mkHom₂
(CategoryTheory.Bicategory.whiskerLeft f.hom (CategoryTheory.CategoryStruct.id g).hom) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f g) |
Flag.ofIsMaxChain._proof_2 | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} [inst : LE α] (c : Set α),
IsMaxChain (fun x1 x2 => x1 ≤ x2) c → ∀ ⦃t : Set α⦄, IsChain (fun x1 x2 => x1 ≤ x2) t → c ⊆ t → c = t |
Mathlib.Tactic.IntervalCases.Bound._sizeOf_1 | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Bound → ℕ |
TopCommRingCat.isCommRing | Mathlib.Topology.Category.TopCommRingCat | (self : TopCommRingCat) → CommRing self.α |
mulActionSphereClosedBall._proof_2 | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ} (x : ↑(Metric.closedBall 0 r)), 1 • x = x |
Submonoid.map.congr_simp | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f f_1 : F),
f = f_1 → ∀ (S S_1 : Submonoid M), S = S_1 → Submonoid.map f S = Submonoid.map f_1 S_1 |
CategoryTheory.Limits.idZeroEquivIsoZero_apply_hom | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C) (h : CategoryTheory.CategoryStruct.id X = 0),
((CategoryTheory.Limits.idZeroEquivIsoZero X) h).hom = 0 |
divisionRingOfFiniteDimensional._proof_15 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ (F : Type u_2) (K : Type u_1) [inst : Field F] [inst_1 : Ring K] [inst_2 : IsDomain K] [inst_3 : Algebra F K]
[inst_4 : FiniteDimensional F K], (if H : 0 = 0 then 0 else Classical.choose ⋯) = 0 |
CentroidHom.instFunLike._proof_1 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f g : CentroidHom α),
(fun f => (↑f.toAddMonoidHom).toFun) f = (fun f => (↑f.toAddMonoidHom).toFun) g → f = g |
CommGroupWithZero.ctorIdx | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} → CommGroupWithZero G₀ → ℕ |
HomologicalComplex.units_smul_f_apply | Mathlib.Algebra.Homology.Linear | ∀ {R : Type u_1} [inst : Semiring R] {C : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {ι : Type u_4} {c : ComplexShape ι}
{X Y : HomologicalComplex C c} (r : Rˣ) (f : X ⟶ Y) (n : ι), (r • f).f n = r • f.f n |
CategoryTheory.Limits.IsImage.lift | 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 → (F' : CategoryTheory.Limits.MonoFactorisation f) → F.I ⟶ F'.I |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.