name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Function.Surjective.semiring._proof_1 | Mathlib.Algebra.Ring.InjSurj | ∀ {R : Type u_2} {S : Type u_1} (f : R → S) (hf : Function.Surjective f) [inst : Mul S] [inst_1 : Zero S]
[inst_2 : One S] [inst_3 : Pow S ℕ] [inst_4 : Semiring R] (zero : f 0 = 0) (one : f 1 = 1)
(mul : ∀ (x y : R), f (x * y) = f x * f y) (npow : ∀ (x : R) (n : ℕ), f (x ^ n) = f x ^ n) (x : S),
Monoid.npow 0 x = 1 | false |
ContMDiffMap.group._proof_4 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_4}
[inst_5 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {H' : Type u_5} [inst_6 : TopologicalSpace H']
{I' : ModelWithCorners 𝕜 E' H'} {N : Type u_6} [inst_7 : TopologicalSpace N] [inst_8 : ChartedSpace H N]
{n : WithTop ℕ∞} {G : Type u_7} [inst_9 : Group G] [inst_10 : TopologicalSpace G] [inst_11 : ChartedSpace H' G]
[inst_12 : LieGroup I' n G] (n_1 : ℕ) (a : ContMDiffMap I I' N G n),
zpowRec npowRec (Int.negSucc n_1) a = ⟨fun x => ((zpowRec npowRec (↑n_1.succ) a) x)⁻¹, ⋯⟩ | false |
Set.Pairwise.eq | Mathlib.Logic.Pairwise | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a b : α}, s.Pairwise r → a ∈ s → b ∈ s → ¬r a b → a = b | true |
ContinuousLinearMap.hasFDerivAtFilter | Mathlib.Analysis.Calculus.FDeriv.Linear | ∀ {𝕜 : 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 →L[𝕜] F) {L : Filter (E × E)}, HasFDerivAtFilter (⇑f) f L | true |
Lean.PrettyPrinter.ppConstNameWithInfos | Lean.PrettyPrinter | Lean.Name → Lean.MetaM Lean.FormatWithInfos | true |
HeytAlg | Mathlib.Order.Category.HeytAlg | Type (u_1 + 1) | true |
Std.DHashMap.Internal.Raw₀.Const.getKey?_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Bool} {k : α} (h : (↑m).WF),
(Std.DHashMap.Internal.Raw₀.filter f m).getKey? k =
(m.getKey? k).pfilter fun x h' => f x (Std.DHashMap.Internal.Raw₀.Const.get m x ⋯) | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk₀.match_1.splitter | Mathlib.CategoryTheory.ComposableArrows.Basic | (motive : Fin (0 + 1) → Sort u_1) → (i : Fin (0 + 1)) → ((isLt : 0 < 0 + 1) → motive ⟨0, isLt⟩) → motive i | true |
Irrational.of_natCast_add | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ} (m : ℕ), Irrational (↑m + x) → Irrational x | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_inter_of_contains_right._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) | false |
List.merge_perm_append._unary | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (le : α → α → Bool) (_x : (_ : List α) ×' List α), (_x.1.merge _x.2 le).Perm (_x.1 ++ _x.2) | false |
_private.Mathlib.Tactic.DeriveCountable.0.Mathlib.Deriving.Countable.cons_eq_imp_init | Mathlib.Tactic.DeriveCountable | ∀ {p : Prop} {a b b' : ℕ}, (b = b' → p) → Nat.pair a b = Nat.pair a b' → p | true |
CategoryTheory.CommShift₂Setup.hε._autoParam | Mathlib.CategoryTheory.Shift.CommShiftTwo | Lean.Syntax | false |
Function.locallyFinsuppWithin.single_pos_int_one._simp_1 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : DecidableEq X] {x : X},
(0 < Function.locallyFinsuppWithin.single x 1) = True | false |
AddMonoidAlgebra.instHopfAlgebraStruct._proof_2 | Mathlib.RingTheory.HopfAlgebra.MonoidAlgebra | ∀ (R : Type u_1) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : HopfAlgebra R A] (G : Type u_2),
SMulCommClass R R (AddMonoidAlgebra A G) | false |
Finset.mem_sigmaLift | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
(f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (a : Sigma α) (b : Sigma β) (x : Sigma γ),
x ∈ Finset.sigmaLift f a b ↔ ∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd) | true |
CategoryTheory.Abelian.SpectralObject.dKernelSequence_X₃ | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{i₀ i₁ i₂ i₃ i₄ i₅ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (f₂₃ : i₁ ⟶ i₃)
(h₂₃ : CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃) (n₀ n₁ n₂ n₃ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.dKernelSequence._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.dKernelSequence._auto_3)
(hn₃ : autoParam (n₂ + 1 = n₃) CategoryTheory.Abelian.SpectralObject.dKernelSequence._auto_5),
(X.dKernelSequence f₁ f₂ f₃ f₄ f₅ f₂₃ h₂₃ n₀ n₁ n₂ n₃ hn₁ hn₂ hn₃).X₃ = X.E f₁ f₂ f₃ n₁ n₂ n₃ ⋯ ⋯ | true |
_private.Mathlib.RingTheory.PicardGroup.0.Submodule.ker_unitsToPic.match_1_1 | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(I : (Submodule R A)ˣ) (e : R ≃ₗ[R] ↥↑I) (e' : R ≃ₗ[R] ↥↑I⁻¹)
(motive : (∃ r, ↑(e 1) * ↑(e' 1) = (algebraMap R A) ↑r) → Prop) (x : ∃ r, ↑(e 1) * ↑(e' 1) = (algebraMap R A) ↑r),
(∀ (r : Rˣ) (hr : ↑(e 1) * ↑(e' 1) = (algebraMap R A) ↑r), motive ⋯) → motive x | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL!.match_1.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (size : ℕ) (lk : α) (lv : β lk)
(size_1 : ℕ) (lrk : α) (lrv : β lrk) (l r : Std.DTreeMap.Internal.Impl α β)
(h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf))
(h_3 :
(size : ℕ) →
(lk : α) →
(lv : β lk) →
(size_2 : ℕ) →
(lrk : α) →
(lrv : β lrk) →
(l r : Std.DTreeMap.Internal.Impl α β) →
motive
(Std.DTreeMap.Internal.Impl.inner size lk lv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_2 lrk lrv l r)))
(h_4 :
(size : ℕ) →
(lk : α) →
(lv : β lk) →
(ll : Std.DTreeMap.Internal.Impl α β) →
(size_2 : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
ll = Std.DTreeMap.Internal.Impl.inner size_2 k v l r →
motive
(Std.DTreeMap.Internal.Impl.inner size lk lv (Std.DTreeMap.Internal.Impl.inner size_2 k v l r)
Std.DTreeMap.Internal.Impl.leaf))
(h_5 :
(ls : ℕ) →
(lk : α) →
(lv : β lk) →
(ll : Std.DTreeMap.Internal.Impl α β) →
(size : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
ll = Std.DTreeMap.Internal.Impl.inner size k v l r →
(lr : Std.DTreeMap.Internal.Impl α β) →
(lrs : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) →
lr = Std.DTreeMap.Internal.Impl.inner lrs k_1 v_1 l_1 r_1 →
motive
(Std.DTreeMap.Internal.Impl.inner ls lk lv
(Std.DTreeMap.Internal.Impl.inner size k v l r)
(Std.DTreeMap.Internal.Impl.inner lrs k_1 v_1 l_1 r_1))),
(match
Std.DTreeMap.Internal.Impl.inner size lk lv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_1 lrk lrv l r) with
| Std.DTreeMap.Internal.Impl.leaf => h_1 ()
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf =>
h_2 size k v
|
Std.DTreeMap.Internal.Impl.inner size lk lv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_2 lrk lrv l r) =>
h_3 size lk lv size_2 lrk lrv l r
|
Std.DTreeMap.Internal.Impl.inner size lk lv (ll@h:(Std.DTreeMap.Internal.Impl.inner size_2 k v l r))
Std.DTreeMap.Internal.Impl.leaf =>
h_4 size lk lv ll size_2 k v l r h
|
Std.DTreeMap.Internal.Impl.inner ls lk lv (ll@h:(Std.DTreeMap.Internal.Impl.inner size k v l r))
lr@h_6:(Std.DTreeMap.Internal.Impl.inner lrs k_1 v_1 l_1 r_1) =>
h_5 ls lk lv ll size k v l r h lr lrs k_1 v_1 l_1 r_1 h_6) =
h_3 size lk lv size_1 lrk lrv l r | true |
instCommMonoidPNat._proof_7 | Mathlib.Data.PNat.Basic | autoParam (∀ (n : ℕ) (x : ℕ+), instCommMonoidPNat._aux_4 (n + 1) x = instCommMonoidPNat._aux_4 n x * x)
Monoid.npow_succ._autoParam | false |
Units.coe_star_inv | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (u : Rˣ), ↑(star u)⁻¹ = star ↑u⁻¹ | true |
Order.IsSuccLimit.bot_lt | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : OrderBot α], Order.IsSuccLimit a → ⊥ < a | true |
Std.Net.IPv6Addr.toString | Std.Net.Addr | Std.Net.IPv6Addr → String | true |
AlgebraicGeometry.mono_pushoutSection_of_iSup_eq | 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)
{ι : Type u_1} [Finite ι] (VX : ι → X.Opens) (hVU : iSup VX = UX),
(∀ (i : ι), CategoryTheory.Mono (AlgebraicGeometry.pushoutSection H hUST ⋯ ⋯)) →
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f US UT hUST)).Flat →
CategoryTheory.Mono (AlgebraicGeometry.pushoutSection H hUST hUSX hUY) | true |
_private.Init.Data.Nat.Fold.0.Nat.foldTR.loop | Init.Data.Nat.Fold | {α : Type u} → (n : ℕ) → ((i : ℕ) → i < n → α → α) → (j : ℕ) → j ≤ n → α → α | true |
Lean.Elab.InlayHintKind | Lean.Elab.InfoTree.InlayHints | Type | true |
CategoryTheory.forget_obj | Mathlib.CategoryTheory.ConcreteCategory.Forget | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {FC : outParam (C → C → Type u_2)}
{CC : outParam (C → Type w)} [inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))]
[inst_2 : CategoryTheory.ConcreteCategory C FC] (X : C), (CategoryTheory.forget C).obj X = CategoryTheory.ToType X | true |
SimpleGraph.natCast_card_dart_eq_dotProduct | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} (G : SimpleGraph V) [inst : DecidableRel G.Adj] [inst_1 : Fintype V]
[inst_2 : NonAssocSemiring α], ↑(Fintype.card G.Dart) = (SimpleGraph.adjMatrix α G).mulVec 1 ⬝ᵥ 1 | true |
FreeAbelianGroup.liftMonoid._proof_8 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u_1} {R : Type u_2} [inst : Monoid α] [inst_1 : Ring R] (f : α →* R),
(↑{ toFun := ⇑(FreeAbelianGroup.lift ⇑f), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).comp
FreeAbelianGroup.ofMulHom =
f | false |
RingHom.id_apply | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {x : NonAssocSemiring α} (x_1 : α), (RingHom.id α) x_1 = x_1 | true |
Nat.cast_pow._simp_1 | Mathlib.Data.Nat.Cast.Basic | ∀ {α : Type u_1} [inst : Semiring α] (m n : ℕ), ↑m ^ n = ↑(m ^ n) | false |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPoly.match_4.eq_6 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (a b : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_3 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x))
(h_5 : (a b : Lean.Grind.CommRing.Expr) → motive (a.add b))
(h_6 : (a b : Lean.Grind.CommRing.Expr) → motive (a.mul b)) (h_7 : (a : Lean.Grind.CommRing.Expr) → motive a.neg)
(h_8 : (a b : Lean.Grind.CommRing.Expr) → motive (a.sub b))
(h_9 : (a : Lean.Grind.CommRing.Expr) → (k : ℕ) → motive (a.pow k)),
(match a.mul b with
| Lean.Grind.CommRing.Expr.num k => h_1 k
| Lean.Grind.CommRing.Expr.intCast k => h_2 k
| Lean.Grind.CommRing.Expr.natCast k => h_3 k
| Lean.Grind.CommRing.Expr.var x => h_4 x
| a.add b => h_5 a b
| a.mul b => h_6 a b
| a.neg => h_7 a
| a.sub b => h_8 a b
| a.pow k => h_9 a k) =
h_6 a b | true |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.argsToMonoRedArg.match_1 | Lean.Compiler.LCNF.ToMono | (motive : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(redArg : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Arg.fvar fvarId)) →
(Unit → motive Lean.Compiler.LCNF.Arg.erased) →
((expr : Lean.Expr) → motive (Lean.Compiler.LCNF.Arg.type expr ⋯)) → motive redArg | false |
List.Cursor.casesOn | Std.Do.Triple.SpecLemmas | {α : Type u} →
{l : List α} →
{motive : l.Cursor → Sort u_1} →
(t : l.Cursor) →
((«prefix» suffix : List α) →
(property : «prefix» ++ suffix = l) →
motive { «prefix» := «prefix», suffix := suffix, property := property }) →
motive t | false |
Lean.IR.IRType.isDefiniteRef | Lean.Compiler.IR.Basic | Lean.IR.IRType → Bool | true |
_private.Init.Data.Sum.Lemmas.0.Sum.exists.match_1_3 | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {p : α ⊕ β → Prop} (motive : ((∃ a, p (Sum.inl a)) ∨ ∃ b, p (Sum.inr b)) → Prop)
(x : (∃ a, p (Sum.inl a)) ∨ ∃ b, p (Sum.inr b)),
(∀ (a : α) (h : p (Sum.inl a)), motive ⋯) → (∀ (b : β) (h : p (Sum.inr b)), motive ⋯) → motive x | false |
Lean.Grind.instCommRingBitVec._proof_2 | Init.GrindInstances.Ring.BitVec | ∀ {w : ℕ} (n : ℕ) (a : BitVec w), n • a = ↑n * a | false |
CategoryTheory.Limits.pushoutPushoutRightIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ X₃ Z₁ Z₂ : C} →
(g₁ : Z₁ ⟶ X₁) →
(g₂ : Z₁ ⟶ X₂) →
(g₃ : Z₂ ⟶ X₂) →
(g₄ : Z₂ ⟶ X₃) →
[inst_1 : 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.Limits.IsColimit
(CategoryTheory.Limits.PushoutCocone.mk
(CategoryTheory.Limits.pushout.desc
(CategoryTheory.Limits.pushout.inl g₁
(CategoryTheory.CategoryStruct.comp g₂ (CategoryTheory.Limits.pushout.inl g₃ g₄)))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl g₃ g₄)
(CategoryTheory.Limits.pushout.inr g₁
(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₄)))
⋯) | true |
Affine.Simplex.exsphere_compl | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1))),
s.exsphere signsᶜ = s.exsphere signs | true |
Subspace.orderIsoFiniteCodimDim | Mathlib.LinearAlgebra.Dual.Lemmas | {K : Type u_4} →
{V : Type u_5} →
[inst : Field K] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module K V] → { W // FiniteDimensional K (V ⧸ W) } ≃o { W // FiniteDimensional K ↥W }ᵒᵈ | true |
MeasureTheory.Measure.ae_le_pi | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] {β : ι → Type u_4}
[inst_3 : (i : ι) → Preorder (β i)] {f f' : (i : ι) → α i → β i},
(∀ (i : ι), f i ≤ᵐ[μ i] f' i) → (fun x i => f i (x i)) ≤ᵐ[MeasureTheory.Measure.pi μ] fun x i => f' i (x i) | true |
Aesop.ForwardRulePriority.normSafe.sizeOf_spec | Aesop.Rule.Forward | ∀ (n : ℤ), sizeOf (Aesop.ForwardRulePriority.normSafe n) = 1 + sizeOf n | true |
LinearMap.kerComplementEquivRange._proof_1 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} [inst : Ring R], RingHomSurjective (RingHom.id R) | false |
Function.Bijective.existsUnique_iff | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → ∀ {p : β → Prop}, (∃! y, p y) ↔ ∃! x, p (f x) | true |
BitVec.msb_neg_of_ne_intMin_of_ne_zero | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, x ≠ BitVec.intMin w → x ≠ 0#w → (-x).msb = !x.msb | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.card_nonuniformWitness_sdiff_biUnion_star._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
CharTwo.natCast_cases | Mathlib.Algebra.CharP.Two | ∀ (R : Type u_1) [inst : AddMonoidWithOne R] [CharP R 2] (n : ℕ), ↑n = 0 ∨ ↑n = 1 | true |
Std.Internal.List.getValue?_filter_not_contains_map_fst_of_contains_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getValue? k (List.filter (fun p => !(List.map Sigma.fst l₂).contains p.fst) l₁) = none | true |
Int.log_zpow | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [inst_3 : FloorSemiring R]
{b : ℕ}, 1 < b → ∀ (z : ℤ), Int.log b (↑b ^ z) = z | true |
ProbabilityTheory.condExpKernel_ae_eq_condExp | Mathlib.Probability.Kernel.Condexp | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω]
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ],
m ≤ mΩ →
∀ {s : Set Ω},
MeasurableSet s → (fun ω => ((ProbabilityTheory.condExpKernel μ m) ω).real s) =ᵐ[μ] μ[s.indicator fun ω => 1 | m] | true |
Subfield.mk.injEq | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u} [inst : DivisionRing K] (toSubring : Subring K)
(inv_mem' : ∀ x ∈ toSubring.carrier, x⁻¹ ∈ toSubring.carrier) (toSubring_1 : Subring K)
(inv_mem'_1 : ∀ x ∈ toSubring_1.carrier, x⁻¹ ∈ toSubring_1.carrier),
({ toSubring := toSubring, inv_mem' := inv_mem' } = { toSubring := toSubring_1, inv_mem' := inv_mem'_1 }) =
(toSubring = toSubring_1) | true |
Lean.Compiler.LCNF.JoinPointFinder.FindState.mk.injEq | Lean.Compiler.LCNF.JoinPoints | ∀ (candidates candidates_1 : Std.HashMap Lean.FVarId Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo),
({ candidates := candidates } = { candidates := candidates_1 }) = (candidates = candidates_1) | true |
RCLike.realRingEquiv._proof_1 | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.I = 0 → ∀ (x : K), ↑(RCLike.re x) = x | false |
Mathlib.Tactic.Ring.pow_add | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_1} [inst : CommSemiring R] {a c₁ c₂ : R} {b₁ b₂ : ℕ} {d : R},
a ^ b₁ = c₁ → a ^ b₂ = c₂ → c₁ * c₂ = d → a ^ (b₁ + b₂) = d | true |
CategoryTheory.Triangulated.Octahedron'.triangle_mor₁ | 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₁₂ : Z₁₂ ⟶ X₁}
{w₁₂ : X₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj Z₁₂}
(h₁₂ : CategoryTheory.Pretriangulated.Triangle.mk v₁₂ u₁₂ w₁₂ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
{v₂₃ : Z₂₃ ⟶ X₂} {w₂₃ : X₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj Z₂₃}
(h₂₃ : CategoryTheory.Pretriangulated.Triangle.mk v₂₃ u₂₃ w₂₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
{v₁₃ : Z₁₃ ⟶ X₁} {w₁₃ : X₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj Z₁₃}
(h₁₃ : CategoryTheory.Pretriangulated.Triangle.mk v₁₃ u₁₃ w₁₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
(h : CategoryTheory.Triangulated.Octahedron' comm h₁₂ h₂₃ h₁₃),
(CategoryTheory.Triangulated.Octahedron'.triangle comm h₁₂ h₂₃ h₁₃ h).mor₁ = h.m₁ | true |
_private.Mathlib.RingTheory.MvPolynomial.EulerIdentity.0.MvPolynomial.IsWeightedHomogeneous.sum_weight_X_mul_pderiv._simp_1_3 | Mathlib.RingTheory.MvPolynomial.EulerIdentity | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : ℕ) (a : α), ↑n * a = n • a | false |
FirstOrder.Language.Substructure.gciMapComap | Mathlib.ModelTheory.Substructures | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type u_1} →
[inst : L.Structure M] →
[inst_1 : L.Structure N] →
{f : L.Hom M N} →
Function.Injective ⇑f →
GaloisCoinsertion (FirstOrder.Language.Substructure.map f) (FirstOrder.Language.Substructure.comap f) | true |
ContinuousMonoidHom.instContinuousEval | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ (A : Type u_2) (B : Type u_3) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] [LocallyCompactPair A B], ContinuousEval (A →ₜ* B) A B | true |
Polynomial.Splits.neg | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Ring R] {f : Polynomial R}, f.Splits → (-f).Splits | true |
ContinuousMap.liftCover_coe' | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {A : Set (Set α)}
{F : (s : Set α) → s ∈ A → C(↑s, β)}
{hF :
∀ (s : Set α) (hs : s ∈ A) (t : Set α) (ht : t ∈ A) (x : α) (hxi : x ∈ s) (hxj : x ∈ t),
(F s hs) ⟨x, hxi⟩ = (F t ht) ⟨x, hxj⟩}
{hA : ∀ (x : α), ∃ i ∈ A, i ∈ nhds x} {s : Set α} {hs : s ∈ A} (x : ↑s),
(ContinuousMap.liftCover' A F hF hA) ↑x = (F s hs) x | true |
Std.Time.Day.instLEOffset._aux_1 | Std.Time.Date.Unit.Day | Std.Time.Day.Offset → Std.Time.Day.Offset → Prop | false |
AffineSubspace.instCompleteLattice._proof_13 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_3} {V : Type u_2} {P : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (x : k) (x_1 x_2 x_3 : P), False → x_2 ∈ ∅ → x_3 ∈ ∅ → x • (x_1 -ᵥ x_2) +ᵥ x_3 ∈ ∅ | false |
CategoryTheory.Sieve._sizeOf_1 | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} → {inst : CategoryTheory.Category.{v₁, u₁} C} → {X : C} → [SizeOf C] → CategoryTheory.Sieve X → ℕ | false |
Ideal.minimalPrimes.equivIrreducibleComponents._proof_4 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} [inst : CommSemiring R] (I : Ideal R) (x : ↑{p | p.IsPrime ∧ I ≤ p}),
(↑⟨{ asIdeal := ↑x, isPrime := ⋯ }, ⋯⟩).asIdeal.IsPrime ∧ I ≤ (↑⟨{ asIdeal := ↑x, isPrime := ⋯ }, ⋯⟩).asIdeal | false |
Lean.SubExpr.Pos.typeCoord | Lean.SubExpr | ℕ | true |
_private.Mathlib.GroupTheory.Commutator.Basic.0.Subgroup.commutator_prod_prod._simp_1_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {H : Subgroup G} {K : Subgroup N}
{J : Subgroup (G × N)},
(J ≤ H.prod K) = (Subgroup.map (MonoidHom.fst G N) J ≤ H ∧ Subgroup.map (MonoidHom.snd G N) J ≤ K) | false |
Lean.Widget.InteractiveGoal | Lean.Widget.InteractiveGoal | Type | true |
Membership.ctorIdx | Init.Prelude | {α : outParam (Type u)} → {γ : Type v} → Membership α γ → ℕ | false |
HomologicalComplex.instIsStrictlySupportedTruncLE | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsTruncLE] [inst_3 : ∀ (i' : ι'), K.HasHomology i']
[inst_4 : CategoryTheory.Limits.HasZeroObject C], (K.truncLE e).IsStrictlySupported e | true |
Hyperreal.epsilon_ne_zero | Mathlib.Analysis.Real.Hyperreal | Hyperreal.epsilon ≠ 0 | true |
String.Slice.ByteIterator.s | Init.Data.String.Iterate | String.Slice.ByteIterator → String.Slice | true |
Circle.instIsTopologicalGroup | Mathlib.Analysis.Complex.Circle | IsTopologicalGroup Circle | true |
CategoryTheory.Groupoid.isoEquivHom._proof_6 | Mathlib.CategoryTheory.Groupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] (X Y : C),
Function.RightInverse (fun f => { hom := f, inv := CategoryTheory.Groupoid.inv f, hom_inv_id := ⋯, inv_hom_id := ⋯ })
CategoryTheory.Iso.hom | false |
_private.Std.Time.Format.Basic.0.Std.Time.parseQuarterNumber | Std.Time.Format.Basic | Std.Internal.Parsec.String.Parser Std.Time.Month.Quarter | true |
TopologicalSpace.Opens.functor_map_eq_inf | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U V : TopologicalSpace.Opens ↑X),
⋯.functor.obj ((TopologicalSpace.Opens.map U.inclusion').obj V) = V ⊓ U | true |
Set.subset_accumulate | Mathlib.Data.Set.Accumulate | ∀ {α : Type u_1} {β : Type u_2} {s : α → Set β} [inst : Preorder α] {x : α}, s x ⊆ Set.accumulate s x | true |
WithAbs.map_apply | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) {T : Type u_3} [inst_3 : Semiring T] (w : AbsoluteValue T S) (f : R →+* T) (x : WithAbs v),
(WithAbs.map v w f) x = WithAbs.toAbs w (f x.ofAbs) | true |
contDiff_prodMk_right | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
(e₀ : E), ContDiff 𝕜 n fun f => (e₀, f) | true |
_private.Std.Internal.Async.Select.0.Std.Internal.IO.Async.shuffleIt.go.eq_def | Std.Internal.Async.Select | ∀ {α : Type u} (xs : Array α) (gen : StdGen) (i : ℕ),
Std.Internal.IO.Async.shuffleIt.go✝ xs gen i =
if x : i < xs.size - 1 then
match randNat gen i (xs.size - 1) with
| (j, gen) =>
have xs := xs.swapIfInBounds i j;
Std.Internal.IO.Async.shuffleIt.go✝¹ xs gen (i + 1)
else xs | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.noConfusionType | Mathlib.Tactic.Linter.TextBased | Sort u → Mathlib.Linter.TextBased.StyleError✝ → Mathlib.Linter.TextBased.StyleError✝ → Sort u | false |
PEquiv.mk.inj | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} {toFun : α → Option β} {invFun : β → Option α}
{inv : ∀ (a : α) (b : β), invFun b = some a ↔ toFun a = some b} {toFun_1 : α → Option β} {invFun_1 : β → Option α}
{inv_1 : ∀ (a : α) (b : β), invFun_1 b = some a ↔ toFun_1 a = some b},
{ toFun := toFun, invFun := invFun, inv := inv } = { toFun := toFun_1, invFun := invFun_1, inv := inv_1 } →
toFun = toFun_1 ∧ invFun = invFun_1 | true |
_private.Mathlib.Analysis.Matrix.Normed.0.Matrix.norm_unitOf | Mathlib.Analysis.Matrix.Normed | ∀ {α : Type u_5} [inst : NormedDivisionRing α] [inst_1 : NormedAlgebra ℝ α] (a : α), ‖Matrix.unitOf✝ a‖₊ = 1 | true |
instTotallyDisconnectedSpaceSum | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [TotallyDisconnectedSpace α]
[TotallyDisconnectedSpace β], TotallyDisconnectedSpace (α ⊕ β) | true |
Topology.CWComplex.instRelCWComplex._proof_5 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (C : Set X) [inst_1 : Topology.CWComplex C],
∀ A ⊆ C,
(∀ (n : ℕ) (j : Topology.CWComplex.cell C n),
IsClosed (A ∩ ↑(Topology.CWComplex.map n j) '' Metric.closedBall 0 1)) ∧
IsClosed (A ∩ ∅) →
IsClosed A | false |
Nat.fermatNumber | Mathlib.NumberTheory.Fermat | ℕ → ℕ | true |
Std.Time.instHAddOffsetOffset | Std.Time.Date.Basic | HAdd Std.Time.Nanosecond.Offset Std.Time.Millisecond.Offset Std.Time.Nanosecond.Offset | true |
ωCPO.instLargeCategory._proof_3 | Mathlib.Order.Category.OmegaCompletePartialOrder | ∀ {W X Y Z : ωCPO} (f : W.carrier →𝒄 X.carrier) (g : X.carrier →𝒄 Y.carrier) (h : Y.carrier →𝒄 Z.carrier),
h.comp (g.comp f) = (h.comp g).comp f | false |
CategoryTheory.Linear.homCongr_symm_apply | Mathlib.CategoryTheory.Linear.Basic | ∀ (k : Type u_1) {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C] [inst_1 : Semiring k]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear k C] {X Y W Z : C} (f₁ : X ≅ Y) (f₂ : W ≅ Z)
(f : Y ⟶ Z),
(CategoryTheory.Linear.homCongr k f₁ f₂).symm f =
CategoryTheory.CategoryStruct.comp f₁.hom (CategoryTheory.CategoryStruct.comp f f₂.inv) | true |
_private.Lean.Meta.Tactic.Grind.PP.0.Lean.Meta.Grind.Result.and.match_1 | Lean.Meta.Tactic.Grind.PP | (motive : Lean.Meta.Grind.Result✝ → Lean.Meta.Grind.Result✝ → Sort u_1) →
(x x_1 : Lean.Meta.Grind.Result✝¹) →
((x : Lean.Meta.Grind.Result✝²) → motive Lean.Meta.Grind.Result.no✝ x) →
((x : Lean.Meta.Grind.Result✝³) → motive x Lean.Meta.Grind.Result.no✝¹) →
((x : Lean.Meta.Grind.Result✝⁴) → motive Lean.Meta.Grind.Result.cast✝ x) →
((x : Lean.Meta.Grind.Result✝⁵) → motive x Lean.Meta.Grind.Result.cast✝¹) →
(Unit → motive Lean.Meta.Grind.Result.num✝ Lean.Meta.Grind.Result.num✝¹) → motive x x_1 | false |
ONote.NF.mk | Mathlib.SetTheory.Ordinal.Notation | ∀ {o : ONote}, Exists o.NFBelow → o.NF | true |
CategoryTheory.Functor.CoreMonoidal.associativity._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | false |
MeasureTheory.definition._@.Mathlib.MeasureTheory.Function.ConditionalLExpectation.118845607._hygCtx._hyg.8 | Mathlib.MeasureTheory.Function.ConditionalLExpectation | {Ω : Type u_1} → {mΩ₀ : MeasurableSpace Ω} → MeasurableSpace Ω → MeasureTheory.Measure Ω → (Ω → ENNReal) → Ω → ENNReal | false |
AddAction.compHom._proof_1 | Mathlib.Algebra.Group.Action.Hom | ∀ {M : Type u_3} {N : Type u_2} (α : Type u_1) [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : AddMonoid N]
(g : N →+ M) (x x_1 : N) (x_2 : α), (x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 | false |
_private.Init.Meta.Defs.0.Lean.Syntax.structEq._sparseCasesOn_2 | Init.Meta.Defs | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive_1 (Lean.Syntax.node info kind args)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | false |
_private.Mathlib.Topology.Connected.Clopen.0.IsClopen.isPreconnected_iff._proof_1_5 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u_1} {s : Set α} (a b : Set α), s ∩ (a ∩ b) = ∅ → Disjoint (s ∩ a) (s ∩ b) | false |
Nat.digits_of_two_le_of_pos | Mathlib.Data.Nat.Digits.Defs | ∀ {n b : ℕ}, 2 ≤ b → 0 < n → b.digits n = n % b :: b.digits (n / b) | true |
NonUnitalAlgHom.inr_apply | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} [inst : Monoid R] {A : Type v} {B : Type w} [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : DistribMulAction R B] (x : B),
(NonUnitalAlgHom.inr R A B) x = (0, x) | true |
Pi.instLattice._proof_2 | Mathlib.Order.Lattice | ∀ {ι : Type u_1} {α' : ι → Type u_2} [inst : (i : ι) → Lattice (α' i)] (a b : (i : ι) → α' i),
SemilatticeInf.inf a b ≤ b | false |
OpenPartialHomeomorph.lift_openEmbedding_symm | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_7} {X' : Type u_8} {Z : Type u_9} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace X']
[inst_2 : TopologicalSpace Z] [inst_3 : Nonempty Z] {f : X → X'} (e : OpenPartialHomeomorph X Z)
(hf : Topology.IsOpenEmbedding f), ↑(e.lift_openEmbedding hf).symm = f ∘ ↑e.symm | true |
CategoryTheory.Functor.LeftLinear.μₗIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | ∀ {D : Type u_6} {D' : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} D]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D'] (F : CategoryTheory.Functor D D') {C : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} C] [inst_3 : CategoryTheory.MonoidalCategory C]
[inst_4 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D]
[inst_5 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D'] [inst_6 : F.LeftLinear C] (c : C) (d : D),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxLeftLinear.μₗ F c d)
(CategoryTheory.Functor.OplaxLeftLinear.δₗ F c d) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj c (F.obj d)) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.