name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DHashMap.Raw.Const.get?_congr | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {a b : α}, (a == b) = true → Std.DHashMap.Raw.Const.get? m a = Std.DHashMap.Raw.Const.get? m b | true |
CategoryTheory.Limits.Sigma.map_comp_map | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g h : α → C}
[inst_1 : CategoryTheory.Limits.HasCoproduct f] [inst_2 : CategoryTheory.Limits.HasCoproduct g]
[inst_3 : CategoryTheory.Limits.HasCoproduct h] (q : (a : α) → f a ⟶ g a) (q' : (a : α) → g a ⟶ h a),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.map q) (CategoryTheory.Limits.Sigma.map q') =
CategoryTheory.Limits.Sigma.map fun a => CategoryTheory.CategoryStruct.comp (q a) (q' a) | true |
Set.fintypeLENat._simp_1 | Mathlib.Data.Set.Finite.Basic | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | false |
Lean.Parser.Term.letrec._regBuiltin.Lean.Parser.Term.letrec.parenthesizer_123 | Lean.Parser.Term | IO Unit | false |
TopCat.«term∂𝔻_» | Mathlib.Topology.Category.TopCat.Sphere | Lean.ParserDescr | true |
_private.Mathlib.Analysis.MellinInversion.0.mellin_eq_fourier._simp_1_1 | Mathlib.Analysis.MellinInversion | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
CategoryTheory.Limits.WidePullbackShape.struct._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1}, none = none | false |
BiheytingHomClass.map_sdiff | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_6} {α : Type u_7} {β : Type u_8} {inst : BiheytingAlgebra α} {inst_1 : BiheytingAlgebra β}
{inst_2 : FunLike F α β} [self : BiheytingHomClass F α β] (f : F) (a b : α), f (a \ b) = f a \ f b | true |
Subtype.map_eq | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} {f g : α → β} (h₁ : ∀ (a : α), p a → q (f a))
(h₂ : ∀ (a : α), p a → q (g a)) {x y : Subtype p}, Subtype.map f h₁ x = Subtype.map g h₂ y ↔ f ↑x = g ↑y | true |
measurableSMul₂_of_add | Mathlib.MeasureTheory.Group.Arithmetic | ∀ (M : Type u_2) [inst : Add M] [inst_1 : MeasurableSpace M] [MeasurableAdd₂ M], MeasurableVAdd₂ M M | true |
Vector.forall_getElem | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {p : α → Prop}, (∀ (i : ℕ) (h : i < n), p xs[i]) ↔ ∀ a ∈ xs, p a | true |
FractionalIdeal.isPrincipal_of_isPrincipal_num | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] [IsDomain R] (I : FractionalIdeal (nonZeroDivisors R) (FractionRing R)),
Submodule.IsPrincipal I.num → (↑I).IsPrincipal | true |
CategoryTheory.StructuredArrow.commaMapEquivalenceInverse_obj | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor C T}
{R : CategoryTheory.Functor D T} {C' : Type u₄} [inst_3 : CategoryTheory.Category.{v₄, u₄} C'] {D' : Type u₅}
[inst_4 : CategoryTheory.Category.{v₅, u₅} D'] {T' : Type u₆} [inst_5 : CategoryTheory.Category.{v₆, u₆} T']
{L' : CategoryTheory.Functor C' T'} {R' : CategoryTheory.Functor D' T'} {F₁ : CategoryTheory.Functor C C'}
{F₂ : CategoryTheory.Functor D D'} {F : CategoryTheory.Functor T T'} (α : F₁.comp L' ⟶ L.comp F)
(β : R.comp F ⟶ F₂.comp R') [inst_6 : CategoryTheory.IsIso β] (X : CategoryTheory.Comma L' R')
(Y :
CategoryTheory.Comma (CategoryTheory.StructuredArrow.map₂ (CategoryTheory.CategoryStruct.id (L'.obj X.left)) α)
(CategoryTheory.StructuredArrow.map₂ X.hom (CategoryTheory.inv β))),
(CategoryTheory.StructuredArrow.commaMapEquivalenceInverse α β X).obj Y =
CategoryTheory.StructuredArrow.mk { left := Y.left.hom, right := Y.right.hom, w := ⋯ } | true |
CategoryTheory.Limits.PullbackCone.flipIsLimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.PullbackCone g f),
CategoryTheory.CategoryStruct.comp ((fun s => ht.lift s.flip) s) t.fst = s.snd | false |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.elabDoElemFns.match_1 | Lean.Elab.Do.Basic | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) →
((x : Lean.Exception) → motive x) → motive ex | false |
CategoryTheory.Bicategory.iterated_mateEquiv_conjugateEquiv_symm | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f₁ : a ⟶ c} {u₁ : c ⟶ a} {f₂ : b ⟶ d} {u₂ : d ⟶ b}
{l₁ : a ⟶ b} {r₁ : b ⟶ a} {l₂ : c ⟶ d} {r₂ : d ⟶ c} (adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (adj₃ : CategoryTheory.Bicategory.Adjunction f₁ u₁)
(adj₄ : CategoryTheory.Bicategory.Adjunction f₂ u₂)
(α : CategoryTheory.CategoryStruct.comp u₂ r₁ ⟶ CategoryTheory.CategoryStruct.comp r₂ u₁),
(CategoryTheory.Bicategory.mateEquiv adj₁ adj₂).symm ((CategoryTheory.Bicategory.mateEquiv adj₄ adj₃).symm α) =
(CategoryTheory.Bicategory.conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)).symm α | true |
CategoryTheory.TwistShiftData.z_zero_left | Mathlib.CategoryTheory.Shift.Twist | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (t : CategoryTheory.TwistShiftData C A) (b : A), t.z 0 b = 1 | true |
LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered | Mathlib.GroupTheory.ArchimedeanDensely | ∀ (G : Type u_2) [inst : LinearOrderedCommGroupWithZero G] [Nontrivial Gˣ] [MulArchimedean G],
Nonempty (G ≃*o WithZero (Multiplicative ℤ)) ↔ ¬DenselyOrdered G | true |
Real.exp_approx_end' | Mathlib.Analysis.Complex.Exponential | ∀ {n : ℕ} {x a b : ℝ} (m : ℕ),
n + 1 = m →
∀ (rm : ℝ),
↑m = rm →
|x| ≤ 1 →
|1 - a| ≤ b - |x| / rm * ((rm + 1) / rm) → |Real.exp x - Real.expNear n x a| ≤ |x| ^ n / ↑n.factorial * b | true |
ite_nonpos | Mathlib.Algebra.Notation.Lemmas | ∀ {α : Type u_1} [inst : Zero α] {p : Prop} [inst_1 : Decidable p] {a b : α} [inst_2 : LE α],
a ≤ 0 → b ≤ 0 → (if p then a else b) ≤ 0 | true |
Part.get_eq_of_mem | Mathlib.Data.Part | ∀ {α : Type u_1} {o : Part α} {a : α}, a ∈ o → ∀ (h' : o.Dom), o.get h' = a | true |
DirectLimit.lift_injective | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} [inst : Preorder ι] {F : ι → Type u_4} {T : ⦃i j : ι⦄ → i ≤ j → Sort u_8}
(f : (i j : ι) → (h : i ≤ j) → T h) [inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T h) (F i) (F j)]
[inst_2 : DirectedSystem F fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] {C : Sort u_9}
(ih : (i : ι) → F i → C) (compat : ∀ (i j : ι) (h : i ≤ j) (x : F i), ih i x = ih j ((f i j h) x)),
(∀ (i : ι), Function.Injective (ih i)) → Function.Injective (DirectLimit.lift f ih compat) | true |
Std.Sat.AIG.relabel.eq_1 | Std.Sat.AIG.Relabel | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Type} [inst_2 : Hashable β] [inst_3 : DecidableEq β]
(r : α → β) (aig : Std.Sat.AIG α),
Std.Sat.AIG.relabel r aig =
{ decls := Array.map (Std.Sat.AIG.Decl.relabel r) aig.decls, cache := Std.Sat.AIG.Cache.empty, hdag := ⋯,
hzero := ⋯, hconst := ⋯ } | true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.unfold?.unfoldDeclToUnfold?.match_1 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((cinfo : Lean.ConstantInfo) → motive (some cinfo)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x | false |
CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono | Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{R₁ R₂ : CategoryTheory.ComposableArrows C 3} (φ : R₁ ⟶ R₂),
R₁.Exact →
R₂.Exact →
CategoryTheory.Epi
(CategoryTheory.ComposableArrows.app' φ 0 CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono'._proof_13) →
CategoryTheory.Mono
(CategoryTheory.ComposableArrows.app' φ 1 CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono'._proof_11) →
CategoryTheory.Mono
(CategoryTheory.ComposableArrows.app' φ 3 CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono'._proof_7) →
CategoryTheory.Mono
(CategoryTheory.ComposableArrows.app' φ 2 CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono'._proof_4) | true |
UInt16.ne_not_self | Init.Data.UInt.Bitwise | ∀ {a : UInt16}, a ≠ ~~~a | true |
_private.Lean.Compiler.IR.EmitC.0.Lean.IR.EmitC.isIf._proof_5 | Lean.Compiler.IR.EmitC | ∀ (alts : Array Lean.IR.Alt), ¬alts.size ≠ 2 → ¬1 < alts.size → False | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord.0.NumberField.mixedEmbedding.volume_eq_two_pi_pow_mul_integral._simp_1_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n | false |
Module.AEval.restrict_equiv_mapSubmodule._proof_2 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_2} {A : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (p : Submodule R M) (hp : p ∈ ((Algebra.lsmul R R M) a).invtSubmodule) (x : ↥p),
(Module.AEval.equiv_mapSubmodule a p hp) (LinearMap.restrict ((Algebra.lsmul R R M) a) hp • x) =
Polynomial.X • (Module.AEval.equiv_mapSubmodule a p hp) x | false |
HomotopicalAlgebra.RightHomotopyClass.precomp_bijective_of_weakEquivalence | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C} (Z : C)
[HomotopicalAlgebra.IsFibrant Z] (f : X ⟶ Y) [HomotopicalAlgebra.IsCofibrant X] [HomotopicalAlgebra.IsCofibrant Y]
[HomotopicalAlgebra.WeakEquivalence f], Function.Bijective fun g => g.precomp f | true |
SetRel.isCover_univ._simp_1 | Mathlib.Data.Rel.Cover | ∀ {X : Type u_1} {s N : Set X}, SetRel.IsCover Set.univ s N = (s.Nonempty → N.Nonempty) | false |
UInt64.toFin_not | Init.Data.UInt.Bitwise | ∀ (a : UInt64), (~~~a).toFin = a.toFin.rev | true |
LocallyFiniteSupport.locallyFinite_support | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_2} [inst_1 : Zero Y] (f : X → Y),
LocallyFiniteSupport f → LocallyFinite fun s => {↑s} | true |
wrapped._@.Mathlib.Analysis.Calculus.FDeriv.Defs.639413672._hygCtx._hyg.8 | Mathlib.Analysis.Calculus.FDeriv.Defs | Subtype (Eq definition✝) | false |
UniformOnFun.hasBasis_nhds_zero_of_basis | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {G : Type u_2} {ι : Type u_3} [inst : AddGroup G] [inst_1 : UniformSpace G] [IsUniformAddGroup G]
(𝔖 : Set (Set α)),
𝔖.Nonempty →
DirectedOn (fun x1 x2 => x1 ⊆ x2) 𝔖 →
∀ {p : ι → Prop} {b : ι → Set G},
(nhds 0).HasBasis p b →
(nhds 0).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
{f | ∀ x ∈ Si.1, (UniformOnFun.toFun 𝔖) f x ∈ b Si.2} | true |
USize.toNat.eq_1 | Init.Data.UInt.Lemmas | ∀ (n : USize), n.toNat = n.toBitVec.toNat | true |
Nat.cast_list_sum | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {R : Type u_4} [inst : AddMonoidWithOne R] (s : List ℕ), ↑s.sum = (List.map Nat.cast s).sum | true |
MonoidHom.instCommMonoid._proof_6 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : CommMonoid N] (a b : M →* N), a * b = b * a | false |
Std.TreeSet.Raw.getD_ofList_of_mem | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List α} {k k' fallback : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.Raw.ofList l cmp).getD k' fallback = k | true |
AlgebraicGeometry.IsNoetherian.mk | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X : AlgebraicGeometry.Scheme} [toIsLocallyNoetherian : AlgebraicGeometry.IsLocallyNoetherian X]
[toCompactSpace : CompactSpace ↥X], AlgebraicGeometry.IsNoetherian X | true |
FirstOrder.Field.FieldAxiom.existsPairNE.sizeOf_spec | Mathlib.ModelTheory.Algebra.Field.Basic | sizeOf FirstOrder.Field.FieldAxiom.existsPairNE = 1 | true |
CategoryTheory.Limits.PreservesPullback.iso.eq_1 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullback f g] [inst_4 : CategoryTheory.Limits.HasPullback (G.map f) (G.map g)],
CategoryTheory.Limits.PreservesPullback.iso G f g =
CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso
(CategoryTheory.Limits.isLimitOfHasPullbackOfPreservesLimit G f g)
(CategoryTheory.Limits.limit.isLimit (CategoryTheory.Limits.cospan (G.map f) (G.map g))) | true |
Lean.Meta.LazyDiscrTree.patternPath | Lean.Meta.LazyDiscrTree | Lean.Expr → Lean.MetaM (Array Lean.Meta.LazyDiscrTree.Key) | true |
CategoryTheory.MonoidalLinear.casesOn | Mathlib.CategoryTheory.Monoidal.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] →
[inst_4 : CategoryTheory.MonoidalCategory C] →
[inst_5 : CategoryTheory.MonoidalPreadditive C] →
{motive : CategoryTheory.MonoidalLinear R C → Sort u} →
(t : CategoryTheory.MonoidalLinear R C) →
((whiskerLeft_smul :
∀ (X : C) {Y Z : C} (r : R) (f : Y ⟶ Z),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (r • f) =
r • CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f) →
(smul_whiskerRight :
∀ (r : R) {Y Z : C} (f : Y ⟶ Z) (X : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (r • f) X =
r • CategoryTheory.MonoidalCategoryStruct.whiskerRight f X) →
motive ⋯) →
motive t | false |
MeasureTheory.OuterMeasure.isCaratheodory_disjointed | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α) {ι : Type u_1} [inst : Preorder ι] [inst_1 : LocallyFiniteOrderBot ι]
{s : ι → Set α}, (∀ (i : ι), m.IsCaratheodory (s i)) → ∀ (i : ι), m.IsCaratheodory (disjointed s i) | true |
Std.ExtDTreeMap.Const.size_alter_eq_add_one | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : Option β → Option β},
k ∉ t → (f (Std.ExtDTreeMap.Const.get? t k)).isSome = true → (Std.ExtDTreeMap.Const.alter t k f).size = t.size + 1 | true |
inseparable_iff_forall_isOpen | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, Inseparable x y ↔ ∀ (s : Set X), IsOpen s → (x ∈ s ↔ y ∈ s) | true |
PowerSeries.invUnitsSub_mul_X | Mathlib.RingTheory.PowerSeries.WellKnown | ∀ {R : Type u_1} [inst : Ring R] (u : Rˣ),
PowerSeries.invUnitsSub u * PowerSeries.X = PowerSeries.invUnitsSub u * PowerSeries.C ↑u - 1 | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.instBEqKey.beq._sparseCasesOn_2 | Lean.Compiler.LCNF.InferBorrow | {motive : Lean.Compiler.LCNF.ParamMap.Key✝ → Sort u} →
(t : Lean.Compiler.LCNF.ParamMap.Key✝¹) →
((name : Lean.Name) → (jpId : Lean.FVarId) → motive (Lean.Compiler.LCNF.ParamMap.Key.jp✝ name jpId)) →
(Nat.hasNotBit 2 (Lean.Compiler.LCNF.ParamMap.Key.ctorIdx✝ t) → motive t) → motive t | false |
Polynomial.X_pow_sub_one_splits | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {n : ℕ}, IsPrimitiveRoot ζ n → (Polynomial.X ^ n - Polynomial.C 1).Splits | true |
derivWithin_const | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (c : F), derivWithin (Function.const 𝕜 c) s = 0 | true |
CochainComplex.mappingCone.inr_fst_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
{d e f : ℤ} (γ : CochainComplex.HomComplex.Cochain F K d) (he : 1 + d = e) (hf : 0 + e = f),
(CochainComplex.HomComplex.Cochain.ofHom (CochainComplex.mappingCone.inr φ)).comp
((↑(CochainComplex.mappingCone.fst φ)).comp γ he) hf =
0 | true |
finsum_mem_def | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (s : Set α) (f : α → M),
∑ᶠ (a : α) (_ : a ∈ s), f a = ∑ᶠ (a : α), s.indicator f a | true |
Finset.prod_mulIndicator_eq_prod_inter | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {β : Type u_4} [inst : CommMonoid β] [inst_1 : DecidableEq ι] (s t : Finset ι) (f : ι → β),
∏ i ∈ s, (↑t).mulIndicator f i = ∏ i ∈ s ∩ t, f i | true |
TensorPower.toTensorAlgebra | Mathlib.LinearAlgebra.TensorAlgebra.ToTensorPower | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {n : ℕ} → TensorPower R n M →ₗ[R] TensorAlgebra R M | true |
instOrOpInt64 | Init.Data.SInt.Basic | OrOp Int64 | true |
CategoryTheory.IsFiltered.of_right_adjoint | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor D C} {R : CategoryTheory.Functor C D}
(h : L ⊣ R), CategoryTheory.IsFiltered D | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_45 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (head : α) (tail : List α) (i : ℕ),
tail.length + 1 ≤ i →
i + 1 ≤ (head :: tail).length → (head :: tail).length + 1 ≤ tail.length → tail.length < tail.length | false |
VectorBundle.continuousLinearEquivAt | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
(F : Type u_3) →
(E : B → Type u_4) →
[inst : NontriviallyNormedField R] →
[inst_1 : (x : B) → AddCommMonoid (E x)] →
[inst_2 : (x : B) → Module R (E x)] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace R F] →
[inst_5 : TopologicalSpace B] →
[inst_6 : (x : B) → TopologicalSpace (E x)] →
[inst_7 : TopologicalSpace (Bundle.TotalSpace F E)] →
[inst_8 : FiberBundle F E] → [VectorBundle R F E] → (b : B) → E b ≃L[R] F | true |
_private.Mathlib.Data.Finset.Powerset.0.Finset.pairwiseDisjoint_pair_insert._simp_1_3 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract._proof_8 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {newWidth : ℕ}, 0 ≤ newWidth | false |
ContDiffWithinAt.ccosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E}
{n : WithTop ℕ∞}, ContDiffWithinAt ℂ n f s x → ContDiffWithinAt ℂ n (fun x => Complex.cosh (f x)) s x | true |
MultilinearMap.uncurry_curryLeft | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂] (f : MultilinearMap R M M₂),
f.curryLeft.uncurryLeft = f | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0._regBuiltin.Nat.reduceMod.declare_46._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.3686920086._hygCtx._hyg.19 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | false |
Std.TreeSet.minD_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
(t.insert k).minD fallback = t.min?.elim k fun k' => if cmp k k' = Ordering.lt then k else k' | true |
Std.Format.FlattenBehavior.fill.sizeOf_spec | Init.Data.Format.Basic | sizeOf Std.Format.FlattenBehavior.fill = 1 | true |
Polynomial.eval_sumIDeriv_of_pos | Mathlib.Algebra.Polynomial.SumIteratedDerivative | ∀ {R : Type u_1} [inst : CommRing R] [Nontrivial R] [NoZeroDivisors R] (p : Polynomial R) {q : ℕ},
0 < q →
∃ gp,
gp.natDegree ≤ p.natDegree - q ∧
∀ (r : R) {p' : Polynomial R},
p = (Polynomial.X - Polynomial.C r) ^ (q - 1) * p' →
Polynomial.eval r (Polynomial.sumIDeriv p) =
(q - 1).factorial • Polynomial.eval r p' + q.factorial • Polynomial.eval r gp | true |
List.isChain_range | Mathlib.Data.List.Range | ∀ (r : ℕ → ℕ → Prop) (n : ℕ), List.IsChain r (List.range n) ↔ ∀ m < n - 1, r m m.succ | true |
isScalarTower_closedBall_closedBall_closedBall | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜']
[inst_2 : SeminormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜' E] {r : ℝ}
[inst_5 : NormedAlgebra 𝕜 𝕜'] [IsScalarTower 𝕜 𝕜' E],
IsScalarTower ↑(Metric.closedBall 0 1) ↑(Metric.closedBall 0 1) ↑(Metric.closedBall 0 r) | true |
HasFibers.inducedMap_comp_assoc | Mathlib.CategoryTheory.FiberedCategory.HasFibers | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} [inst_2 : HasFibers p] {R S : 𝒮} {a : 𝒳} {b b' : HasFibers.Fib p R} (f : R ⟶ S)
(ψ : (HasFibers.ι R).obj b' ⟶ a) [inst_3 : p.IsCartesian f ψ] (φ : (HasFibers.ι R).obj b ⟶ a)
[inst_4 : p.IsHomLift f φ] {Z : 𝒳} (h : a ⟶ Z),
CategoryTheory.CategoryStruct.comp ((HasFibers.ι R).map (HasFibers.inducedMap f ψ φ))
(CategoryTheory.CategoryStruct.comp ψ h) =
CategoryTheory.CategoryStruct.comp φ h | true |
CategoryTheory.CommGrp.instCategory._proof_9 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {W X Y Z : CategoryTheory.CommGrp C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
CategoryTheory.Category.assoc._autoParam | false |
Unitization.instRing._proof_7 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (a : Unitization R A), -a + a = 0 | false |
AddUnits.neg_nsmul_eq_nsmul_neg | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α) (n : ℕ), ↑(-(n • a)) = n • ↑(-a) | true |
OreLocalization.oreDivSMulChar'.eq_1 | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : MulAction R X] (r₁ : R) (r₂ : X) (s₁ s₂ : ↥S),
OreLocalization.oreDivSMulChar' r₁ r₂ s₁ s₂ = ⟨OreLocalization.oreNum r₁ s₂, ⟨OreLocalization.oreDenom r₁ s₂, ⋯⟩⟩ | true |
Lean.Elab.Tactic.ElabSimpArgsResult | Lean.Elab.Tactic.Simp | Type | true |
Lean.Meta.LazyDiscrTree.ModuleDiscrTreeRef.mk._flat_ctor | Lean.Meta.LazyDiscrTree | {α : Type} → IO.Ref (Lean.Meta.LazyDiscrTree α) → Lean.Meta.LazyDiscrTree.ModuleDiscrTreeRef α | false |
MvPolynomial.zeroLocus_bot | Mathlib.RingTheory.Nullstellensatz | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {σ : Type u_3},
MvPolynomial.zeroLocus K ⊥ = ⊤ | true |
CategoryTheory.Limits.CatCospanTransform.comp_whiskerLeft_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] [inst_4 : CategoryTheory.Category.{v₅, u₅} B']
[inst_5 : CategoryTheory.Category.{v₆, u₆} C'] {F' : CategoryTheory.Functor A' B'} {G' : CategoryTheory.Functor C' B'}
[inst_6 : CategoryTheory.Category.{v₇, u₇} A''] [inst_7 : CategoryTheory.Category.{v₈, u₈} B'']
[inst_8 : CategoryTheory.Category.{v₉, u₉} C''] {F'' : CategoryTheory.Functor A'' B''}
{G'' : CategoryTheory.Functor C'' B''} {A''' : Type u₁₀} {B''' : Type u₁₁} {C''' : Type u₁₂}
[inst_9 : CategoryTheory.Category.{v₁₀, u₁₀} A'''] [inst_10 : CategoryTheory.Category.{v₁₁, u₁₁} B''']
[inst_11 : CategoryTheory.Category.{v₁₂, u₁₂} C'''] {F''' : CategoryTheory.Functor A''' B'''}
{G''' : CategoryTheory.Functor C''' B'''} {ψ : CategoryTheory.Limits.CatCospanTransform F G F' G'}
{φ : CategoryTheory.Limits.CatCospanTransform F' G' F'' G''}
{τ τ' : CategoryTheory.Limits.CatCospanTransform F'' G'' F''' G'''} (γ : τ ⟶ τ')
{Z : CategoryTheory.Limits.CatCospanTransform F G F''' G'''} (h : (ψ.comp φ).comp τ' ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.CatCospanTransformMorphism.whiskerLeft (ψ.comp φ) γ) h =
CategoryTheory.CategoryStruct.comp (ψ.associator φ τ).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.CatCospanTransformMorphism.whiskerLeft ψ
(CategoryTheory.Limits.CatCospanTransformMorphism.whiskerLeft φ γ))
(CategoryTheory.CategoryStruct.comp (ψ.associator φ τ').inv h)) | true |
Nat.div_left_inj._simp_1 | Init.Data.Nat.Lemmas | ∀ {a b d : ℕ}, d ∣ a → d ∣ b → (a / d = b / d) = (a = b) | false |
RingCon.subsingleton_iff | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R], Subsingleton (RingCon R) ↔ Subsingleton R | true |
Filter.biInter_finset_mem | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {f : Filter α} {β : Type v} {s : β → Set α} (is : Finset β), ⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f | true |
CompleteBooleanAlgebra.mk | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
[toCompleteLattice : CompleteLattice α] →
(∀ (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z) →
[toCompl : Compl α] →
[toSDiff : SDiff α] →
[toHImp : HImp α] →
(∀ (x : α), x ⊓ xᶜ ≤ ⊥) →
(∀ (x : α), ⊤ ≤ x ⊔ xᶜ) →
autoParam (∀ (x y : α), x \ y = x ⊓ yᶜ) BooleanAlgebra.sdiff_eq._autoParam →
autoParam (∀ (x y : α), x ⇨ y = y ⊔ xᶜ) BooleanAlgebra.himp_eq._autoParam → CompleteBooleanAlgebra α | true |
Graded.equiv | Mathlib.Data.FunLike.Graded | {E : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_4} →
{τ : Type u_5} →
{ι : Type u_6} →
[inst : SetLike σ A] →
[inst_1 : SetLike τ B] →
{𝒜 : ι → σ} →
{ℬ : ι → τ} → [inst_2 : EquivLike E A B] → [GradedEquivLike E 𝒜 ℬ] → E → (i : ι) → ↥(𝒜 i) ≃ ↥(ℬ i) | true |
List.instInterOfBEq_batteries | Batteries.Data.List.Basic | {α : Type u_1} → [BEq α] → Inter (List α) | true |
Lean.Meta.Simp.Context.simpTheorems._default | Lean.Meta.Tactic.Simp.Types | Lean.Meta.SimpTheoremsArray | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.setWidth_ofNat_of_le_of_lt._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w v x : ℕ}, ¬1 < 2 → False | false |
LinearMap.range_toContinuousLinearMap | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : IsTopologicalAddGroup F']
[inst_9 : ContinuousSMul 𝕜 F'] [inst_10 : CompleteSpace 𝕜] [inst_11 : T2Space E] [inst_12 : FiniteDimensional 𝕜 E]
(f : E →ₗ[𝕜] F'), (↑(LinearMap.toContinuousLinearMap f)).range = f.range | true |
Int.gcd_mul_lcm | Init.Data.Int.Gcd | ∀ (m n : ℤ), m.gcd n * m.lcm n = m.natAbs * n.natAbs | true |
RelEmbedding.natLT._proof_2 | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {r : α → α → Prop} [IsStrictOrder α r] (f : ℕ → α),
(∀ (n : ℕ), r (f n) (f (n + 1))) → ∀ ⦃a b : ℕ⦄, a < b → r (f a) (f b) | false |
CategoryTheory.Limits.isoZeroBiprod_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (hY : CategoryTheory.Limits.IsZero X),
(CategoryTheory.Limits.isoZeroBiprod hY).inv = CategoryTheory.Limits.biprod.snd | true |
CategoryTheory.NatIso.pi._proof_2 | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type u_3} {C : I → Type u_1} [inst : (i : I) → CategoryTheory.Category.{u_5, u_1} (C i)] {D : I → Type u_4}
[inst_1 : (i : I) → CategoryTheory.Category.{u_2, u_4} (D i)] {F G : (i : I) → CategoryTheory.Functor (C i) (D i)}
(e : (i : I) → F i ≅ G i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.pi fun i => (e i).hom)
(CategoryTheory.NatTrans.pi fun i => (e i).inv) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.pi F) | false |
Batteries.mkHashMap | Batteries.Data.HashMap.Basic | {α : Type u_1} → {β : Type u_2} → [inst : BEq α] → [inst_1 : Hashable α] → optParam ℕ 0 → Batteries.HashMap α β | true |
Action.FunctorCategoryEquivalence.unitIso_inv_app_hom | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] (X : Action V G),
(Action.FunctorCategoryEquivalence.unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.V | true |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.Const.minEntry.match_1._arg_pusher | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → Sort u_3)
(α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → α_1 → Prop)
(x : Std.DTreeMap.Internal.Impl α fun x => β) (x_1 : x.isEmpty = false)
(h_1 :
(size : ℕ) →
(k : α) →
(v : β) →
(r : Std.DTreeMap.Internal.Impl α fun x => β) →
(x : (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r).isEmpty = false) →
((y : α_1) →
rel (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r) x y → β_1 y) →
motive (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r) x)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β) →
(l : Std.DTreeMap.Internal.Impl α fun x => β) →
(size_1 : ℕ) →
(k_1 : α) →
(v_1 : β) →
(l_1 r : Std.DTreeMap.Internal.Impl α fun x => β) →
(h : l = Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) →
(r_1 : Std.DTreeMap.Internal.Impl α fun x => β) →
(h_2 :
(Std.DTreeMap.Internal.Impl.inner size k v
(namedPattern l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) h)
r_1).isEmpty =
false) →
((y : α_1) →
rel
(Std.DTreeMap.Internal.Impl.inner size k v
(namedPattern l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) h) r_1)
h_2 y →
β_1 y) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v
(namedPattern l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) h) r_1)
h_2),
((match (motive :=
(x : Std.DTreeMap.Internal.Impl α fun x => β) →
(x_2 : x.isEmpty = false) → ((y : α_1) → rel x x_2 y → β_1 y) → motive x x_2)
x, x_1 with
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r, x => fun x_2 =>
h_1 size k v r x x_2
| Std.DTreeMap.Internal.Impl.inner size k v (l@h:(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)) r_1,
h_3 => fun x => h_2 size k v l size_1 k_1 v_1 l_1 r h r_1 h_3 x)
fun y h => f y) =
match x, x_1 with
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r, x => h_1 size k v r x fun y h => f y
| Std.DTreeMap.Internal.Impl.inner size k v (l@h:(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)) r_1,
h_3 => h_2 size k v l size_1 k_1 v_1 l_1 r h r_1 h_3 fun y h => f y | false |
_private.Mathlib.MeasureTheory.Integral.TorusIntegral.0.term___ | Mathlib.MeasureTheory.Integral.TorusIntegral | Lean.TrailingParserDescr | true |
CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖᵒᵖ)
(n m : ℤ) (hnm : autoParam (n + m = 0) CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._auto_1),
(CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso C n).inv.app X =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pretriangulated.shiftFunctorOpIso C m n ⋯).hom.app (Opposite.unop X)).unop
((CategoryTheory.Pretriangulated.shiftFunctorOpIso Cᵒᵖ n m hnm).inv.app X).unop.unop | true |
dvd_mul | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : CommSemigroup α] [DecompositionMonoid α] {k m n : α},
k ∣ m * n ↔ ∃ d₁ d₂, d₁ ∣ m ∧ d₂ ∣ n ∧ k = d₁ * d₂ | true |
Subsemiring.instMin._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (s t : Subsemiring R) {a b : R},
a ∈ (s.toSubmonoid ⊓ t.toSubmonoid).carrier →
b ∈ (s.toSubmonoid ⊓ t.toSubmonoid).carrier → a * b ∈ (s.toSubmonoid ⊓ t.toSubmonoid).carrier | false |
Fintype.card_coe | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} (s : Finset α) [inst : Fintype ↥s], Fintype.card ↥s = s.card | true |
_private.Mathlib.Data.Int.Cast.Basic.0.Int.cast_neg.match_1_1 | Mathlib.Data.Int.Cast.Basic | ∀ (motive : ℤ → Prop) (x : ℤ),
(∀ (a : Unit), motive (Int.ofNat 0)) →
(∀ (n : ℕ), motive (Int.ofNat n.succ)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.