name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Elab.Term.StructInst.FieldLHS.modifyOp.elim | Lean.Elab.StructInst | {motive : Lean.Elab.Term.StructInst.FieldLHS → Sort u} →
(t : Lean.Elab.Term.StructInst.FieldLHS) →
t.ctorIdx = 3 →
((ref index : Lean.Syntax) → motive (Lean.Elab.Term.StructInst.FieldLHS.modifyOp ref index)) → motive t | false |
FiniteIndexNormalSubgroup.comap_id | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : Group G] (K : FiniteIndexNormalSubgroup G),
FiniteIndexNormalSubgroup.comap (MonoidHom.id G) K = K | true |
_private.Init.Data.Iterators.Lemmas.Basic.0.Std.Iter.inductSteps._proof_2 | Init.Data.Iterators.Lemmas.Basic | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [inst_1 : Std.Iterators.Finite α Id] (it : Std.Iter β)
{it' : Std.Iter β} {x : β},
it.IsPlausibleStep (Std.IterStep.yield it' x) →
(invImage (fun x => x.finitelyManySteps) Std.IterM.TerminationMeasures.instWellFoundedRelationFinite).1 it' it | false |
Complex.instTietzeExtension | Mathlib.Analysis.Complex.Tietze | TietzeExtension ℂ | true |
AlgebraicGeometry.QuasiSeparated | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | true |
Std.DTreeMap.Internal.Impl.insert.congr_simp | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (v v_1 : β k),
v = v_1 →
∀ (t : Std.DTreeMap.Internal.Impl α β) (hl : t.Balanced),
Std.DTreeMap.Internal.Impl.insert k v t hl = Std.DTreeMap.Internal.Impl.insert k v_1 t hl | true |
HNNExtension.NormalWord.cons_toList | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} {d : HNNExtension.NormalWord.TransversalPair G A B} (g : G)
(u : ℤˣ) (w : HNNExtension.NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ HNNExtension.toSubgroup A B u → u = u'),
(HNNExtension.NormalWord.cons g u w h1 h2).toList = (u, w.head) :: w.toList | true |
NumberField.mixedEmbedding.commMap._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] (m : ℝ) (x : (K →+* ℂ) → ℂ),
(fun w => ((m • x) (↑w).embedding).re, fun w => (m • x) (↑w).embedding) =
(RingHom.id ℝ) m • (fun w => (x (↑w).embedding).re, fun w => x (↑w).embedding) | false |
Set.iInter₂_vadd_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} {β : Type u_3} {ι : Sort u_5} {κ : ι → Sort u_6} [inst : VAdd α β] (s : (i : ι) → κ i → Set α)
(t : Set β), (⋂ i, ⋂ j, s i j) +ᵥ t ⊆ ⋂ i, ⋂ j, s i j +ᵥ t | true |
Polynomial.derivative_ofNat | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : Semiring R] (n : ℕ) [inst_1 : n.AtLeastTwo], Polynomial.derivative (OfNat.ofNat n) = 0 | true |
LightDiagram'._sizeOf_inst | Mathlib.Topology.Category.LightProfinite.Basic | SizeOf LightDiagram' | false |
CategoryTheory.Limits.Cofork.unop.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} {f g : X ⟶ Y}
(c : CategoryTheory.Limits.Cofork f g),
c.unop =
((CategoryTheory.Limits.Cocone.precompose (CategoryTheory.Limits.opParallelPairIso f.unop g.unop).hom).obj
(CategoryTheory.Limits.Cocone.whisker CategoryTheory.Limits.walkingParallelPairOpEquiv.inverse c)).unop | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_shiftLeftZeroExtend._proof_1_4 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} (n : ℕ), ¬x.toNat < 2 ^ w → False | false |
SSet.Truncated.Edge.CompStruct.comp_unique | Mathlib.AlgebraicTopology.Quasicategory.TwoTruncated | ∀ {A : SSet.Truncated 2} [A.Quasicategory₂]
{x y z : A.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Quasicategory₂._proof_1 })}
{f f' : SSet.Truncated.Edge x y} {g g' : SSet.Truncated.Edge y z} {h h' : SSet.Truncated.Edge x z}
(s : f.CompStruct g h) (s' : f'.CompStruct g' h'),
SSet.Truncated.HomotopicL f f' → SSet.Truncated.HomotopicL g g' → SSet.Truncated.HomotopicL h h' | true |
Aesop.SimpResult.ctorElim | Aesop.Search.Expansion.Simp | {motive : Aesop.SimpResult → Sort u} →
(ctorIdx : ℕ) → (t : Aesop.SimpResult) → ctorIdx = t.ctorIdx → Aesop.SimpResult.ctorElimType ctorIdx → motive t | false |
HomotopicalAlgebra.BifibrantObject.HoCat.ιCofibrantObject._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x x_1 : HomotopicalAlgebra.BifibrantObject C) (x_2 x_3 : x ⟶ x_1),
HomotopicalAlgebra.BifibrantObject.homRel C x_2 x_3 →
(HomotopicalAlgebra.BifibrantObject.ιCofibrantObject.comp HomotopicalAlgebra.CofibrantObject.toHoCat).map x_2 =
(HomotopicalAlgebra.BifibrantObject.ιCofibrantObject.comp HomotopicalAlgebra.CofibrantObject.toHoCat).map x_3 | false |
instReprExcept | Init.Data.ToString.Basic | {ε : Type u_1} → {α : Type u_2} → [Repr ε] → [Repr α] → Repr (Except ε α) | true |
RestrictedProduct.instPow.eq_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)],
RestrictedProduct.instPow R = { pow := fun x n => ⟨fun i => x i ^ n, ⋯⟩ } | true |
Batteries.Tactic.Lint.instReprLintVerbosity | Batteries.Tactic.Lint.Frontend | Repr Batteries.Tactic.Lint.LintVerbosity | true |
Lean.Grind.CommRing.denoteInt | Init.Grind.Ring.CommSolver | {α : Type u_1} → [Lean.Grind.Ring α] → ℤ → α | true |
NumberField.InfinitePlace.IsUnramified.comap | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_1} [inst : Field k] (K : Type u_2) [inst_1 : Field K] {F : Type u_3} [inst_2 : Field F]
[inst_3 : Algebra k K] [inst_4 : Algebra k F] [inst_5 : Algebra K F] [IsScalarTower k K F]
{w : NumberField.InfinitePlace F},
NumberField.InfinitePlace.IsUnramified k w → NumberField.InfinitePlace.IsUnramified k (w.comap (algebraMap K F)) | true |
CategoryTheory.TwoSquare.op | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
{T : CategoryTheory.Functor C₁ C₂} →
{L : CategoryTheory.Functor C₁ C₃} →
{R : CategoryTheory.Functor C₂ C₄} →
{B : CategoryTheory.Functor C₃ C₄} →
CategoryTheory.TwoSquare T L R B → CategoryTheory.TwoSquare L.op T.op B.op R.op | true |
Subgroup.le_comap_map | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N) (H : Subgroup G),
H ≤ Subgroup.comap f (Subgroup.map f H) | true |
ContinuousMap.ctorIdx | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} → {Y : Type u_2} → {inst : TopologicalSpace X} → {inst_1 : TopologicalSpace Y} → C(X, Y) → ℕ | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.mk.inj | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_2} {κ : Type u_3} {inst : Preorder ι} {c : ℤ → ComplexShape κ} {r₀ : ℤ} {deg : κ → ℤ}
{i₀ : (r : ℤ) → κ → autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_1 → ι}
{i₁ i₂ : κ → ι}
{i₃ : (r : ℤ) → κ → autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_3 → ι}
{le₀₁ :
∀ (r : ℤ) (pq : κ) (hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_5),
i₀ r pq ⋯ ≤ i₁ pq}
{le₁₂ : ∀ (pq : κ), i₁ pq ≤ i₂ pq}
{le₂₃ :
∀ (r : ℤ) (pq : κ) (hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_9),
i₂ pq ≤ i₃ r pq ⋯}
{hc :
∀ (r : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_14 →
deg pq + 1 = deg pq'}
{hc₀₂ :
∀ (r : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
∀ (hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_16),
i₀ r pq ⋯ = i₂ pq'}
{hc₁₃ :
∀ (r : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
∀ (hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_20),
i₁ pq = i₃ r pq' ⋯}
{antitone_i₀ :
∀ (r r' : ℤ) (pq : κ)
(hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_24)
(hrr' : autoParam (r ≤ r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_26),
i₀ r' pq ⋯ ≤ i₀ r pq ⋯}
{monotone_i₃ :
∀ (r r' : ℤ) (pq : κ)
(hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_32)
(hrr' : autoParam (r ≤ r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_34),
i₃ r pq ⋯ ≤ i₃ r' pq ⋯}
{i₀_prev :
∀ (r r' : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
∀ (hrr' : autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_41)
(hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_43),
i₀ r' pq ⋯ = i₁ pq'}
{i₃_next :
∀ (r r' : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
∀ (hrr' : autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_47)
(hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_49),
i₃ r' pq' ⋯ = i₂ pq}
{deg_1 : κ → ℤ}
{i₀_1 : (r : ℤ) → κ → autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_1 → ι}
{i₁_1 i₂_1 : κ → ι}
{i₃_1 : (r : ℤ) → κ → autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_3 → ι}
{le₀₁_1 :
∀ (r : ℤ) (pq : κ) (hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_5),
i₀_1 r pq ⋯ ≤ i₁_1 pq}
{le₁₂_1 : ∀ (pq : κ), i₁_1 pq ≤ i₂_1 pq}
{le₂₃_1 :
∀ (r : ℤ) (pq : κ) (hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_9),
i₂_1 pq ≤ i₃_1 r pq ⋯}
{hc_1 :
∀ (r : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_14 →
deg_1 pq + 1 = deg_1 pq'}
{hc₀₂_1 :
∀ (r : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
∀ (hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_16),
i₀_1 r pq ⋯ = i₂_1 pq'}
{hc₁₃_1 :
∀ (r : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
∀ (hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_20),
i₁_1 pq = i₃_1 r pq' ⋯}
{antitone_i₀_1 :
∀ (r r' : ℤ) (pq : κ)
(hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_24)
(hrr' : autoParam (r ≤ r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_26),
i₀_1 r' pq ⋯ ≤ i₀_1 r pq ⋯}
{monotone_i₃_1 :
∀ (r r' : ℤ) (pq : κ)
(hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_32)
(hrr' : autoParam (r ≤ r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_34),
i₃_1 r pq ⋯ ≤ i₃_1 r' pq ⋯}
{i₀_prev_1 :
∀ (r r' : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
∀ (hrr' : autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_41)
(hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_43),
i₀_1 r' pq ⋯ = i₁_1 pq'}
{i₃_next_1 :
∀ (r r' : ℤ) (pq pq' : κ),
(c r).Rel pq pq' →
∀ (hrr' : autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_47)
(hr : autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_49),
i₃_1 r' pq' ⋯ = i₂_1 pq},
{ deg := deg, i₀ := i₀, i₁ := i₁, i₂ := i₂, i₃ := i₃, le₀₁ := le₀₁, le₁₂ := le₁₂, le₂₃ := le₂₃, hc := hc,
hc₀₂ := hc₀₂, hc₁₃ := hc₁₃, antitone_i₀ := antitone_i₀, monotone_i₃ := monotone_i₃, i₀_prev := i₀_prev,
i₃_next := i₃_next } =
{ deg := deg_1, i₀ := i₀_1, i₁ := i₁_1, i₂ := i₂_1, i₃ := i₃_1, le₀₁ := le₀₁_1, le₁₂ := le₁₂_1, le₂₃ := le₂₃_1,
hc := hc_1, hc₀₂ := hc₀₂_1, hc₁₃ := hc₁₃_1, antitone_i₀ := antitone_i₀_1, monotone_i₃ := monotone_i₃_1,
i₀_prev := i₀_prev_1, i₃_next := i₃_next_1 } →
deg = deg_1 ∧ i₀ = i₀_1 ∧ i₁ = i₁_1 ∧ i₂ = i₂_1 ∧ i₃ = i₃_1 | true |
CasesInfo.mk.injEq | Lean.Meta.CasesInfo | ∀ (declName indName : Lean.Name) (arity discrPos : ℕ) (altsRange : Std.Rco ℕ) (altNumParams : Array CasesAltInfo)
(declName_1 indName_1 : Lean.Name) (arity_1 discrPos_1 : ℕ) (altsRange_1 : Std.Rco ℕ)
(altNumParams_1 : Array CasesAltInfo),
({ declName := declName, indName := indName, arity := arity, discrPos := discrPos, altsRange := altsRange,
altNumParams := altNumParams } =
{ declName := declName_1, indName := indName_1, arity := arity_1, discrPos := discrPos_1,
altsRange := altsRange_1, altNumParams := altNumParams_1 }) =
(declName = declName_1 ∧
indName = indName_1 ∧
arity = arity_1 ∧ discrPos = discrPos_1 ∧ altsRange = altsRange_1 ∧ altNumParams = altNumParams_1) | true |
dist_prod_prod_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {ι : Type u_3} {E : Type u_5} [inst : SeminormedCommGroup E] (s : Finset ι) (f a : ι → E),
dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, dist (f b) (a b) | true |
Real.partialOrder._proof_3 | Mathlib.Data.Real.Basic | ∀ (a b c : ℝ), a ≤ b → b ≤ c → a ≤ c | false |
LocallyConstant.constₐ_apply_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (R : Type u_6) [inst_1 : CommSemiring R]
[inst_2 : Semiring Y] [inst_3 : Algebra R Y] (y : Y) (a : X), ((LocallyConstant.constₐ R) y) a = y | true |
dotProductBilin._proof_5 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {m : Type u_2} (R : Type u_3) {A : Type u_1} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : Fintype m] (x : R) (x_1 x_2 x_3 : m → A),
x • x_1 ⬝ᵥ (x_2 + x_3) = x • x_1 ⬝ᵥ x_2 + x • x_1 ⬝ᵥ x_3 | false |
CategoryTheory.yonedaGrpObjRepresentableBy | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_ | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
(G : C) →
[inst_2 : CategoryTheory.GrpObj G] →
((CategoryTheory.yonedaGrpObj G).comp (CategoryTheory.forget GrpCat)).RepresentableBy G | true |
_private.Init.Data.List.ToArray.0.List.zipWithAll_go_toArray._proof_1_7 | Init.Data.List.ToArray | ∀ {α : Type u_1} {β : Type u_2} (as : List α) (bs : List β) (i : ℕ),
max as.length bs.length ≤ i → ¬bs.length ≤ i → False | false |
mem_nhdsWithin | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {t : Set α} {a : α} {s : Set α},
t ∈ nhdsWithin a s ↔ ∃ u, IsOpen u ∧ a ∈ u ∧ u ∩ s ⊆ t | true |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.ordered_iff._simp_1_1 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) | false |
_private.Init.Data.PLift.0.instDecidableEqPLift.decEq.match_1 | Init.Data.PLift | {α : Sort u_1} →
(motive : PLift α → PLift α → Sort u_2) →
(x x_1 : PLift α) → ((a b : α) → motive { down := a } { down := b }) → motive x x_1 | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.not_isG2_iff_isNotG2._simp_1_2 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N)
[inst_5 : P.IsCrystallographic] [P.IsReduced] [P.IsIrreducible],
P.IsNotG2 = ∀ (i j : ι), P.pairingIn ℤ i j ∈ {-2, -1, 0, 1, 2} | false |
Lean.warnIfUsesSorry | Lean.AddDecl | Lean.Declaration → Lean.CoreM Unit | true |
CategoryTheory.ComposableArrows.Precomp.map_zero_one'._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ}, 0 + 1 < n + 1 + 1 | false |
cauchy_davenport_mul_of_linearOrder_isCancelMul | Mathlib.Combinatorics.Additive.CauchyDavenport | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : Mul α] [IsCancelMul α] [MulLeftMono α] [MulRightMono α]
{s t : Finset α}, s.Nonempty → t.Nonempty → s.card + t.card - 1 ≤ (s * t).card | true |
PartialEquiv.toEquiv.match_1 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) (motive : ↑e.source → Prop) (x : ↑e.source),
(∀ (val : α) (hx : val ∈ e.source), motive ⟨val, hx⟩) → motive x | false |
_private.Mathlib.Topology.UniformSpace.AbstractCompletion.0.AbstractCompletion._aux_Mathlib_Topology_UniformSpace_AbstractCompletion___macroRules__private_Mathlib_Topology_UniformSpace_AbstractCompletion_0_AbstractCompletion_termι_1 | Mathlib.Topology.UniformSpace.AbstractCompletion | Lean.Macro | false |
CategoryTheory.equivToOverUnit._proof_8 | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : CategoryTheory.Over (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Over.forget (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).map
((CategoryTheory.NatIso.ofComponents
(fun X =>
CategoryTheory.Over.isoMk
(CategoryTheory.Iso.refl
((CategoryTheory.Functor.id
(CategoryTheory.Over (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))).obj
X).left)
⋯)
⋯).hom.app
X))
((CategoryTheory.NatIso.ofComponents
(fun X =>
CategoryTheory.Iso.refl
(((CategoryTheory.toOverUnit C).comp
(CategoryTheory.Over.forget (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))).obj
X))
⋯).hom.app
((CategoryTheory.Over.forget (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).obj X)) =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Over.forget (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).obj X) | false |
Module.Invertible.rTensor_bijective_iff | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} (M : Type v) {N : Type u_1} {P : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] [Module.Invertible R M] {f : N →ₗ[R] P},
Function.Bijective ⇑(LinearMap.rTensor M f) ↔ Function.Bijective ⇑f | true |
Matrix.toLinearEquivRight'OfInv | Mathlib.LinearAlgebra.Matrix.ToLin | {R : Type u_1} →
[inst : Semiring R] →
{m : Type u_3} →
{n : Type u_4} →
[inst_1 : Fintype m] →
[inst_2 : DecidableEq m] →
[inst_3 : Fintype n] →
[inst_4 : DecidableEq n] →
{M : Matrix m n R} → {M' : Matrix n m R} → M * M' = 1 → M' * M = 1 → (n → R) ≃ₗ[R] m → R | true |
Std.DHashMap.get!_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
[inst_1 : Inhabited (β k)] {f : β k → β k}, (m.modify k f).get! k = (Option.map f (m.get? k)).get! | true |
smul_eq_self_of_preimage_zpow_eq_self | Mathlib.Dynamics.FixedPoints.Prufer | ∀ {G : Type u_1} [inst : CommGroup G] {n : ℤ} {s : Set G},
(fun x => x ^ n) ⁻¹' s = s → ∀ {g : G} {j : ℕ}, g ^ n ^ j = 1 → g • s = s | true |
Derivation.liftKaehlerDifferential._proof_7 | Mathlib.RingTheory.Kaehler.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {M : Type u_3}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M]
(D : Derivation R S M) ⦃x : ↥(KaehlerDifferential.ideal R S)⦄,
x ∈ Submodule.restrictScalars S (KaehlerDifferential.ideal R S • ⊤) →
x ∈ (D.tensorProductTo ∘ₗ ↑S (Submodule.subtype (KaehlerDifferential.ideal R S))).ker | false |
Filter.pi_neBot | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)}, (Filter.pi f).NeBot ↔ ∀ (i : ι), (f i).NeBot | true |
ProbabilityTheory.exists_integrable_exp_sq_of_map_rotation_eq_self | Mathlib.Probability.Distributions.Fernique | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [SecondCountableTopology E]
[inst_3 : MeasurableSpace E] [BorelSpace E] {μ : MeasureTheory.Measure E} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.Measure.map (⇑(ContinuousLinearMap.rotation (-(Real.pi / 4)))) (μ.prod μ) = μ.prod μ →
∃ C, 0 < C ∧ MeasureTheory.Integrable (fun x => Real.exp (C * ‖x‖ ^ 2)) μ | true |
JordanHolderLattice.IsMaximal | Mathlib.Order.JordanHolder | {X : Type u} → {inst : Lattice X} → [self : JordanHolderLattice X] → X → X → Prop | true |
Rat.num_divInt | Init.Data.Rat.Lemmas | ∀ (a b : ℤ), (Rat.divInt a b).num = b.sign * a / ↑(b.gcd a) | true |
Std.ExtDHashMap.Const.ofList_eq_insertMany_empty | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{l : List (α × β)}, Std.ExtDHashMap.Const.ofList l = Std.ExtDHashMap.Const.insertMany ∅ l | true |
Lean.Compiler.LCNF.LitValue.uint32.noConfusion | Lean.Compiler.LCNF.Basic | {P : Sort u} →
{val val' : UInt32} →
Lean.Compiler.LCNF.LitValue.uint32 val = Lean.Compiler.LCNF.LitValue.uint32 val' → (val = val' → P) → P | false |
SuccOrder.ofSuccLeIff.eq_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] (succ : α → α) (hsucc_le_iff : ∀ {a b : α}, succ a ≤ b ↔ a < b),
SuccOrder.ofSuccLeIff succ hsucc_le_iff = { succ := succ, le_succ := ⋯, max_of_succ_le := ⋯, succ_le_of_lt := ⋯ } | true |
_private.Mathlib.Order.UpperLower.Relative.0.isUpperSet_subtype_iff_isRelUpperSet._simp_1_3 | Mathlib.Order.UpperLower.Relative | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | false |
CategoryTheory.PreZeroHypercover.isoMk_inv_s₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S}
(s₀ : E.I₀ ≃ F.I₀) (h₀ : (i : E.I₀) → E.X i ≅ F.X (s₀ i))
(w₀ :
autoParam (∀ (i : E.I₀), CategoryTheory.CategoryStruct.comp (h₀ i).hom (F.f (s₀ i)) = E.f i)
CategoryTheory.PreZeroHypercover.isoMk._auto_1)
(a : F.I₀), (CategoryTheory.PreZeroHypercover.isoMk s₀ h₀ w₀).inv.s₀ a = s₀.symm a | true |
Std.ExtTreeSet.ofList_eq_foldl | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {l : List α},
Std.ExtTreeSet.ofList l cmp = List.foldl (fun acc a => acc.insert a) ∅ l | true |
_private.Mathlib.GroupTheory.PGroup.0.ZModModule.isPGroup_multiplicative._simp_1_2 | Mathlib.GroupTheory.PGroup | ∀ {α : Type u} {p : Multiplicative α → Prop}, (∀ (a : Multiplicative α), p a) = ∀ (a : α), p (Multiplicative.ofAdd a) | false |
ENNReal.toEReal | Mathlib.Data.EReal.Basic | ENNReal → EReal | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.map_add_toArray_rcc._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n k : ℕ}, ¬n + 1 + k = n + k + 1 → False | false |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_nonempty._simp_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, (a ∈ s.erase b) = (a ≠ b ∧ a ∈ s) | false |
Additive.addCommGroup | Mathlib.Algebra.Group.TypeTags.Basic | {α : Type u} → [CommGroup α] → AddCommGroup (Additive α) | true |
CategoryTheory.Bicategory.Adj.left_triangle_components_assoc | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {C₁ C₂ : CategoryTheory.Bicategory.Adj CategoryTheory.Cat} (α : C₁ ⟶ C₂) (X : ↑C₁.obj) {Z : ↑C₂.obj}
(h : (CategoryTheory.CategoryStruct.id C₂.obj).toFunctor.obj (α.l.toFunctor.obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp (α.l.toFunctor.map (α.adj.unit.toNatTrans.app X))
(CategoryTheory.CategoryStruct.comp (α.adj.counit.toNatTrans.app (α.l.toFunctor.obj X)) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (α.l.toFunctor.obj X)) h | true |
_private.Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform.0.integrable_cexp_quadratic'._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ (x : ℂ), (Complex.exp x = 0) = False | false |
AddAction.fixedBy_mem_fixedBy_of_addCommute | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {g h : G},
AddCommute g h → AddAction.fixedBy α g ∈ AddAction.fixedBy (Set α) h | true |
SSet.OneTruncation₂.HoRel₂.of_compStruct | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2}
{x₀ x₁ x₂ : V.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.OneTruncation₂._proof_1 })}
{e₀₁ : SSet.Truncated.Edge x₀ x₁} {e₁₂ : SSet.Truncated.Edge x₁ x₂} {e₀₂ : SSet.Truncated.Edge x₀ x₂}
(h : e₀₁.CompStruct e₁₂ e₀₂),
SSet.OneTruncation₂.HoRel₂ V
((CategoryTheory.Cat.FreeRefl.quotientFunctor (SSet.OneTruncation₂ V)).map
(CategoryTheory.CategoryStruct.comp (Quiver.Hom.toPath e₀₁) (Quiver.Hom.toPath e₁₂)))
((CategoryTheory.Cat.FreeRefl.quotientFunctor (SSet.OneTruncation₂ V)).map (Quiver.Hom.toPath e₀₂)) | true |
Std.Sat.AIG.RefVec.rec | Std.Sat.AIG.Basic | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{motive : aig.RefVec w → Sort u} →
((refs : Vector Std.Sat.AIG.Fanin w) →
(hrefs : ∀ {i : ℕ} (h : i < w), refs[i].gate < aig.decls.size) →
motive { refs := refs, hrefs := hrefs }) →
(t : aig.RefVec w) → motive t | false |
Finpartition.instLE | Mathlib.Order.Partition.Finpartition | {α : Type u_1} → [inst : Lattice α] → [inst_1 : OrderBot α] → {a : α} → LE (Finpartition a) | true |
Set.iInter_setOf | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} (P : ι → α → Prop), ⋂ i, {x | P i x} = {x | ∀ (i : ι), P i x} | true |
OrderIso.sortedLT_listMap._simp_1 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {l : List α},
(List.map (⇑e) l).SortedLT = l.SortedLT | false |
Std.DHashMap.Internal.Raw₀.toList_keysArray_eq_keys | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β), (↑m).keysArray.toList = (↑m).keys | true |
Lean.Server.Watchdog.RequestData.getRequestQueue | Lean.Server.Watchdog | Lean.Server.Watchdog.RequestData → Lean.Lsp.DocumentUri → Lean.Server.Watchdog.RequestQueueMap | true |
Lean.Server.Test.Runner.Client.HighlightedMsgEmbed.widget | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.WidgetInstance →
Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.HighlightedMsgEmbed →
Lean.Server.Test.Runner.Client.HighlightedMsgEmbed | true |
AlgebraicGeometry.Scheme.isoOfEq_inv_ι | Mathlib.AlgebraicGeometry.Restrict | ∀ (X : AlgebraicGeometry.Scheme) {U V : X.Opens} (e : U = V),
CategoryTheory.CategoryStruct.comp (X.isoOfEq e).inv U.ι = V.ι | true |
instRingCliffordAlgebra._proof_11 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M),
autoParam
(∀ (n : ℕ) (x : CliffordAlgebra Q),
instRingCliffordAlgebra._aux_8 Q (n + 1) x = instRingCliffordAlgebra._aux_8 Q n x + x)
AddMonoid.nsmul_succ._autoParam | false |
Lean.Parser.Tactic.Conv.congr | Init.Conv | Lean.ParserDescr | true |
Lean.Lsp.ClientInfo.mk.sizeOf_spec | Lean.Data.Lsp.InitShutdown | ∀ (name : String) (version? : Option String),
sizeOf { name := name, version? := version? } = 1 + sizeOf name + sizeOf version? | true |
LinearEquiv.ofIsUnitDet.congr_simp | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {M' : Type u_3}
[inst_3 : AddCommGroup M'] [inst_4 : Module R M'] {ι : Type u_4} {inst_5 : DecidableEq ι} [inst_6 : DecidableEq ι]
[inst_7 : Fintype ι] {f f_1 : M →ₗ[R] M'} (e_f : f = f_1) {v v_1 : Module.Basis ι R M} (e_v : v = v_1)
{v' v'_1 : Module.Basis ι R M'} (e_v' : v' = v'_1) (h : IsUnit ((LinearMap.toMatrix v v') f).det),
LinearEquiv.ofIsUnitDet h = LinearEquiv.ofIsUnitDet ⋯ | true |
RingHomIsometric.recOn | Mathlib.Analysis.Normed.Ring.Basic | {R₁ : Type u_5} →
{R₂ : Type u_6} →
[inst : Semiring R₁] →
[inst_1 : Semiring R₂] →
[inst_2 : Norm R₁] →
[inst_3 : Norm R₂] →
{σ : R₁ →+* R₂} →
{motive : RingHomIsometric σ → Sort u} →
(t : RingHomIsometric σ) → ((norm_map : ∀ {x : R₁}, ‖σ x‖ = ‖x‖) → motive ⋯) → motive t | false |
Finset.instEmptyCollection | Mathlib.Data.Finset.Empty | {α : Type u_1} → EmptyCollection (Finset α) | true |
Lean.Lsp.TextEdit.mk.injEq | Lean.Data.Lsp.Basic | ∀ (range : Lean.Lsp.Range) (newText : String) (leanExtSnippet? : Option Lean.Lsp.SnippetString)
(annotationId? : Option String) (range_1 : Lean.Lsp.Range) (newText_1 : String)
(leanExtSnippet?_1 : Option Lean.Lsp.SnippetString) (annotationId?_1 : Option String),
({ range := range, newText := newText, leanExtSnippet? := leanExtSnippet?, annotationId? := annotationId? } =
{ range := range_1, newText := newText_1, leanExtSnippet? := leanExtSnippet?_1,
annotationId? := annotationId?_1 }) =
(range = range_1 ∧ newText = newText_1 ∧ leanExtSnippet? = leanExtSnippet?_1 ∧ annotationId? = annotationId?_1) | true |
String.Slice.ByteIterator.mk.noConfusion | Init.Data.String.Iterate | {P : Sort u} →
{s : String.Slice} →
{offset : String.Pos.Raw} →
{s' : String.Slice} →
{offset' : String.Pos.Raw} →
{ s := s, offset := offset } = { s := s', offset := offset' } → (s = s' → offset = offset' → P) → P | false |
UInt32.decEq._proof_1 | Init.Prelude | ∀ (n m : BitVec 32), n = m → { toBitVec := n } = { toBitVec := m } | false |
LinearEquiv.map_eq_of_mem_fixingSubgroup | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {R : Type u_1} [inst : Semiring R] {V : Type u_3} [inst_1 : AddCommMonoid V] [inst_2 : Module R V] (e : V ≃ₗ[R] V)
(W : Submodule R V), e ∈ fixingSubgroup (V ≃ₗ[R] V) W.carrier → Submodule.map (↑e) W = W | true |
MonoidHom.ext_mnat_iff | Mathlib.Algebra.Group.Nat.Hom | ∀ {M : Type u_1} [inst : Monoid M] {f g : Multiplicative ℕ →* M},
f = g ↔ f (Multiplicative.ofAdd 1) = g (Multiplicative.ofAdd 1) | true |
Fin.succFunEquiv_symm_apply | Mathlib.Logic.Equiv.Fin.Basic | ∀ (α : Type u_1) (n : ℕ) (a : (Fin n → α) × α) (a_1 : Fin (n + 1)),
(Fin.succFunEquiv α n).symm a a_1 = Fin.append a.1 (uniqueElim a.2) a_1 | true |
disjointed_le | Mathlib.Order.Disjointed | ∀ {α : Type u_1} {ι : Type u_2} [inst : GeneralizedBooleanAlgebra α] [inst_1 : Preorder ι]
[inst_2 : LocallyFiniteOrderBot ι] (f : ι → α), disjointed f ≤ f | true |
_private.Mathlib.Tactic.Widget.GCongr.0._aux_Mathlib_Tactic_Widget_GCongr___elabRules_tacticGcongr?_1._sparseCasesOn_1 | Mathlib.Tactic.Widget.GCongr | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Monoidal.instMonoidalTransportedInverseEquivalenceTransported._proof_3 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} D] (e : C ≌ D)
{X₁ X₂ : CategoryTheory.Monoidal.Transported e} (f : X₁ ⟶ X₂) (Y : CategoryTheory.Monoidal.Transported e),
e.inverse.map (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Y) =
CategoryTheory.CategoryStruct.comp
(e.unitIso.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj X₁) (e.inverse.obj Y))).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (e.inverse.map f) (e.inverse.obj Y))
(e.unitIso.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj X₂) (e.inverse.obj Y))).hom) | false |
Monoid.PushoutI.NormalWord.baseAction | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} →
{d : Monoid.PushoutI.NormalWord.Transversal φ} → MulAction H (Monoid.PushoutI.NormalWord d) | true |
Aesop.Percent.mk._flat_ctor | Aesop.Percent | Float → Aesop.Percent | false |
_private.Mathlib.Algebra.Group.Pointwise.Set.ListOfFn.0.Set.mem_list_prod._simp_1_5 | Mathlib.Algebra.Group.Pointwise.Set.ListOfFn | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | false |
Set.Icc.coe_pow | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] (x : ↑(Set.Icc 0 1)) (n : ℕ),
↑(x ^ n) = ↑x ^ n | true |
CategoryTheory.ShortComplex.shortExact_of_iso | Mathlib.Algebra.Homology.ShortComplex.ShortExact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂), S₁.ShortExact → S₂.ShortExact | true |
CategoryTheory.associativity_app_assoc | Mathlib.CategoryTheory.Monoidal.End | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} M]
[inst_2 : CategoryTheory.MonoidalCategory M] (F : CategoryTheory.Functor M (CategoryTheory.Functor C C))
(m₁ m₂ m₃ : M) (X : C) [inst_3 : F.LaxMonoidal] {Z : C}
(h :
(F.obj
(CategoryTheory.MonoidalCategoryStruct.tensorObj m₁
(CategoryTheory.MonoidalCategoryStruct.tensorObj m₂ m₃))).obj
X ⟶
Z),
CategoryTheory.CategoryStruct.comp ((F.obj m₃).map ((CategoryTheory.Functor.LaxMonoidal.μ F m₁ m₂).app X))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.LaxMonoidal.μ F (CategoryTheory.MonoidalCategoryStruct.tensorObj m₁ m₂) m₃).app X)
(CategoryTheory.CategoryStruct.comp
((F.map (CategoryTheory.MonoidalCategoryStruct.associator m₁ m₂ m₃).hom).app X) h)) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.LaxMonoidal.μ F m₂ m₃).app ((F.obj m₁).obj X))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.LaxMonoidal.μ F m₁ (CategoryTheory.MonoidalCategoryStruct.tensorObj m₂ m₃)).app X) h) | true |
permsOfList._unsafe_rec | Mathlib.Data.Fintype.Perm | {α : Type u_1} → [DecidableEq α] → List α → List (Equiv.Perm α) | false |
WithAbs.algebraLeft | Mathlib.Analysis.Normed.Ring.WithAbs | {S : Type u_2} →
[inst : Semiring S] →
[inst_1 : PartialOrder S] →
{R : Type u_3} →
(T : Type u_4) →
[inst_2 : CommSemiring R] →
[inst_3 : Semiring T] → [Algebra R T] → (v : AbsoluteValue R S) → Algebra (WithAbs v) T | true |
_private.Mathlib.Combinatorics.Quiver.Path.Vertices.0.Quiver.Path.verticesSet_nil._simp_1_2 | Mathlib.Combinatorics.Quiver.Path.Vertices | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | false |
instNonUnitalCStarAlgebraSubtypeMemNonUnitalStarSubalgebraComplexElemental._proof_7 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] (x : A), IsClosed ↑(NonUnitalStarAlgebra.elemental ℂ x) | false |
topToLocale_map | Mathlib.Topology.Category.Locale | ∀ {X Y : TopCat} (f : X ⟶ Y), topToLocale.map f = (Frm.ofHom (TopologicalSpace.Opens.comap (TopCat.Hom.hom f))).op | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.