name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.TraceData._sizeOf_inst | Lean.Message | SizeOf Lean.TraceData | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm.0.IntervalIntegrable.ae_hasDerivAt_integral._proof_1_7 | Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm | ∀ {a b : ℝ} (x : ℝ), x ≠ b → x ∈ Set.Icc a b → x < b | false |
CategoryTheory.ProjectiveResolution.liftHomotopyZeroOne_comp | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
{P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex ⟶ Q.complex)
(comm : CategoryTheory.CategoryStruct.comp f Q.π = 0),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftHomotopyZeroOne f comm)
(Q.complex.d 2 1) =
f.f 1 -
CategoryTheory.CategoryStruct.comp (P.complex.d 1 0)
(CategoryTheory.ProjectiveResolution.liftHomotopyZeroZero f comm) | true |
CategoryTheory.functorProdFunctorEquivUnitIso._proof_2 | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u_2) [inst : CategoryTheory.Category.{u_4, u_2} A] (B : Type u_1)
[inst_1 : CategoryTheory.Category.{u_3, u_1} B] (C : Type u_5) [inst_2 : CategoryTheory.Category.{u_6, u_5} C]
{X Y : CategoryTheory.Functor A B × CategoryTheory.Functor A C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id (CategoryTheory.Functor A B × CategoryTheory.Functor A C)).map f)
((fun F => ((F.1.prod'CompFst F.2).prod (F.1.prod'CompSnd F.2) ≪≫ CategoryTheory.prod.etaIso F).symm) Y).hom =
CategoryTheory.CategoryStruct.comp
((fun F => ((F.1.prod'CompFst F.2).prod (F.1.prod'CompSnd F.2) ≪≫ CategoryTheory.prod.etaIso F).symm) X).hom
(((CategoryTheory.prodFunctorToFunctorProd A B C).comp (CategoryTheory.functorProdToProdFunctor A B C)).map f) | false |
Padic.padicNormE.mul | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℚ_[p]), ‖q * r‖ = ‖q‖ * ‖r‖ | true |
_private.Qq.Macro.0.Qq.Impl.unquoteLCtx.match_4 | Qq.Macro | (motive : Lean.Level → Sort u_1) →
(__discr : Lean.Level) → ((u : Lean.Level) → motive u.succ) → ((x : Lean.Level) → motive x) → motive __discr | false |
Filter.HasCountableBasis.countable | Mathlib.Order.Filter.CountablyGenerated | ∀ {α : Type u_1} {ι : Type u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasCountableBasis p s → (setOf p).Countable | true |
Multiset.toEnumFinset | Mathlib.Data.Multiset.Fintype | {α : Type u_1} → [DecidableEq α] → Multiset α → Finset (α × ℕ) | true |
_private.Lean.Meta.Tactic.Congr.0.Lean.MVarId.congrImplies?.match_1 | Lean.Meta.Tactic.Congr | (motive : List Lean.MVarId → Sort u_1) →
(__discr : List Lean.MVarId) →
((mvarId₁ mvarId₂ : Lean.MVarId) → (tail : List Lean.MVarId) → motive (mvarId₁ :: mvarId₂ :: tail)) →
((x : List Lean.MVarId) → motive x) → motive __discr | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_map'._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
_private.Mathlib.Analysis.Calculus.LHopital.0.HasDerivAt.lhopital_zero_nhdsGT._proof_1_4 | Mathlib.Analysis.Calculus.LHopital | ∀ {a : ℝ} {g' : ℝ → ℝ} (s₁ s₂ s₃ : Set ℝ),
(∀ y ∈ s₃, g' y ≠ 0) → ∀ (u : ℝ), Set.Ioo a u ⊆ s₁ ∩ s₂ ∩ s₃ → ∀ x ∈ Set.Ioo a u, ¬g' x = 0 | false |
ByteArray.utf8Decode?_utf8Encode_singleton_append | Init.Data.String.Basic | ∀ {l : ByteArray} {c : Char}, ([c].utf8Encode ++ l).utf8Decode? = Option.map (fun x => #[c] ++ x) l.utf8Decode? | true |
WeierstrassCurve.Affine.nonsingular_add | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Affine F} [inst_1 : DecidableEq F] {x₁ x₂ y₁ y₂ : F},
W.Nonsingular x₁ y₁ →
W.Nonsingular x₂ y₂ →
¬(x₁ = x₂ ∧ y₁ = W.negY x₂ y₂) →
W.Nonsingular (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) (W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂)) | true |
Polynomial.natDegree_lt_natDegree | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {p : Polynomial R} {q : Polynomial S},
p ≠ 0 → p.degree < q.degree → p.natDegree < q.natDegree | true |
ValuativeExtension.mapValueGroupWithZero_mk | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : ValuativeRel A]
[inst_3 : ValuativeRel B] [inst_4 : Algebra A B] [inst_5 : ValuativeExtension A B] (r : A)
(s : ↥(ValuativeRel.posSubmonoid A)),
(ValuativeExtension.mapValueGroupWithZero A B) (ValuativeRel.ValueGroupWithZero.mk r s) =
ValuativeRel.ValueGroupWithZero.mk ((algebraMap A B) r) ((ValuativeExtension.mapPosSubmonoid A B) s) | true |
Int.ceil_eq_self_iff_mem | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsStrictOrderedRing R] (a : R),
↑⌈a⌉ = a ↔ a ∈ Set.range Int.cast | true |
AlgHom.fieldRange | Mathlib.FieldTheory.IntermediateField.Basic | {K : Type u_1} →
{L : Type u_2} →
{L' : Type u_3} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Field L'] → [inst_3 : Algebra K L] → [inst_4 : Algebra K L'] → (L →ₐ[K] L') → IntermediateField K L' | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGTD_eq_getD_getEntryGT? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α fun x => β} {k : α} {fallback : α × β},
Std.DTreeMap.Internal.Impl.Const.getEntryGTD k t fallback =
(Std.DTreeMap.Internal.Impl.Const.getEntryGT? k t).getD fallback | true |
MonCat.toCat._proof_2 | Mathlib.CategoryTheory.SingleObj | ∀ {X Y Z : MonCat} (f : X ⟶ Y) (g : Y ⟶ Z),
((CategoryTheory.SingleObj.mapHom ↑X ↑Z) (MonCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g))).toCatHom =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.SingleObj.mapHom ↑X ↑Y) (MonCat.Hom.hom f)).toCatHom
((CategoryTheory.SingleObj.mapHom ↑Y ↑Z) (MonCat.Hom.hom g)).toCatHom | false |
LinearMap.ext_ring_op_iff | Mathlib.Algebra.Module.Equiv.Opposite | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M]
[inst_3 : Module S M] {σ : Rᵐᵒᵖ →+* S} {f g : R →ₛₗ[σ] M}, f = g ↔ f 1 = g 1 | true |
Std.ExtHashMap.instReflBEq | Std.Data.ExtHashMap.Basic | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
[inst_2 : BEq β] [ReflBEq β], ReflBEq (Std.ExtHashMap α β) | true |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.mk.injEq | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject.Augmented C}
(s' : X.right ⟶ X.left.obj (Opposite.op (SimplexCategory.mk 0)))
(s :
(n : ℕ) → X.left.obj (Opposite.op (SimplexCategory.mk n)) ⟶ X.left.obj (Opposite.op (SimplexCategory.mk (n + 1))))
(s'_comp_ε :
autoParam
(CategoryTheory.CategoryStruct.comp s' (X.hom.app (Opposite.op (SimplexCategory.mk 0))) =
CategoryTheory.CategoryStruct.id X.right)
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s'_comp_ε._autoParam)
(s₀_comp_δ₁ :
autoParam
(CategoryTheory.CategoryStruct.comp (s 0) (X.left.δ 1) =
CategoryTheory.CategoryStruct.comp (X.hom.app (Opposite.op (SimplexCategory.mk 0))) s')
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s₀_comp_δ₁._autoParam)
(s_comp_δ₀ :
autoParam
(∀ (n : ℕ),
CategoryTheory.CategoryStruct.comp (s n) (X.left.δ 0) =
CategoryTheory.CategoryStruct.id (X.left.obj (Opposite.op (SimplexCategory.mk n))))
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s_comp_δ₀._autoParam)
(s_comp_δ :
autoParam
(∀ (n : ℕ) (i : Fin (n + 2)),
CategoryTheory.CategoryStruct.comp (s (n + 1)) (X.left.δ i.succ) =
CategoryTheory.CategoryStruct.comp (X.left.δ i) (s n))
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s_comp_δ._autoParam)
(s_comp_σ :
autoParam
(∀ (n : ℕ) (i : Fin (n + 1)),
CategoryTheory.CategoryStruct.comp (s n) (X.left.σ i.succ) =
CategoryTheory.CategoryStruct.comp (X.left.σ i) (s (n + 1)))
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s_comp_σ._autoParam)
(s'_1 : X.right ⟶ X.left.obj (Opposite.op (SimplexCategory.mk 0)))
(s_1 :
(n : ℕ) → X.left.obj (Opposite.op (SimplexCategory.mk n)) ⟶ X.left.obj (Opposite.op (SimplexCategory.mk (n + 1))))
(s'_comp_ε_1 :
autoParam
(CategoryTheory.CategoryStruct.comp s'_1 (X.hom.app (Opposite.op (SimplexCategory.mk 0))) =
CategoryTheory.CategoryStruct.id X.right)
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s'_comp_ε._autoParam)
(s₀_comp_δ₁_1 :
autoParam
(CategoryTheory.CategoryStruct.comp (s_1 0) (X.left.δ 1) =
CategoryTheory.CategoryStruct.comp (X.hom.app (Opposite.op (SimplexCategory.mk 0))) s'_1)
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s₀_comp_δ₁._autoParam)
(s_comp_δ₀_1 :
autoParam
(∀ (n : ℕ),
CategoryTheory.CategoryStruct.comp (s_1 n) (X.left.δ 0) =
CategoryTheory.CategoryStruct.id (X.left.obj (Opposite.op (SimplexCategory.mk n))))
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s_comp_δ₀._autoParam)
(s_comp_δ_1 :
autoParam
(∀ (n : ℕ) (i : Fin (n + 2)),
CategoryTheory.CategoryStruct.comp (s_1 (n + 1)) (X.left.δ i.succ) =
CategoryTheory.CategoryStruct.comp (X.left.δ i) (s_1 n))
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s_comp_δ._autoParam)
(s_comp_σ_1 :
autoParam
(∀ (n : ℕ) (i : Fin (n + 1)),
CategoryTheory.CategoryStruct.comp (s_1 n) (X.left.σ i.succ) =
CategoryTheory.CategoryStruct.comp (X.left.σ i) (s_1 (n + 1)))
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s_comp_σ._autoParam),
({ s' := s', s := s, s'_comp_ε := s'_comp_ε, s₀_comp_δ₁ := s₀_comp_δ₁, s_comp_δ₀ := s_comp_δ₀, s_comp_δ := s_comp_δ,
s_comp_σ := s_comp_σ } =
{ s' := s'_1, s := s_1, s'_comp_ε := s'_comp_ε_1, s₀_comp_δ₁ := s₀_comp_δ₁_1, s_comp_δ₀ := s_comp_δ₀_1,
s_comp_δ := s_comp_δ_1, s_comp_σ := s_comp_σ_1 }) =
(s' = s'_1 ∧ s = s_1) | true |
FundamentalGroupoidFunctor.prodIso_inv | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | ∀ (A : TopCat) (B : TopCat),
(FundamentalGroupoidFunctor.prodIso A B).inv =
(FundamentalGroupoidFunctor.projLeft A B).prod' (FundamentalGroupoidFunctor.projRight A B) | true |
Lean.Server.Test.Runner.RunnerState.mk | Lean.Server.Test.Runner | Lean.Lsp.DocumentUri →
Bool → Option UInt64 → ℕ → ℕ → Lean.Lsp.Position → String → String → ℕ → ℕ → Lean.Server.Test.Runner.RunnerState | true |
CategoryTheory.Functor.IsCartesian.map_isHomLift | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p : CategoryTheory.Functor 𝒳 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [inst_2 : p.IsCartesian f φ] {a' : 𝒳}
(φ' : a' ⟶ b) [inst_3 : p.IsHomLift f φ'],
p.IsHomLift (CategoryTheory.CategoryStruct.id R) (CategoryTheory.Functor.IsCartesian.map p f φ φ') | true |
IsCyclic.monoidHomMulEquivRootsOfUnityOfGenerator._proof_7 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {G : Type u_2} [inst : CommGroup G] {g : G} (hg : ∀ (x : G), x ∈ Subgroup.zpowers g) (G' : Type u_1)
[inst_1 : CommGroup G'] (φ : ↥(rootsOfUnity (Nat.card G) G')),
↑((fun φ => ⟨⋯.unit, ⋯⟩) ((fun ζ => monoidHomOfForallMemZpowers hg ⋯) φ)) = ↑φ | false |
Function.locallyFinsuppWithin.posPart_add | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y]
[inst_2 : LinearOrder Y] [IsOrderedAddMonoid Y] (f₁ f₂ : Function.locallyFinsuppWithin U Y), (f₁ + f₂)⁺ ≤ f₁⁺ + f₂⁺ | true |
Set.preimage_const_add_Icc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => a + x) ⁻¹' Set.Icc b c = Set.Icc (b - a) (c - a) | true |
Std.ExtTreeSet.max?.congr_simp | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t t_1 : Std.ExtTreeSet α cmp),
t = t_1 → t.max? = t_1.max? | true |
Std.ExtTreeSet.filter_eq_self_iff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {f : α → Bool},
Std.ExtTreeSet.filter f t = t ↔ ∀ (k : α) (h : k ∈ t), f (t.get k h) = true | true |
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry._sizeOf_1 | Lean.Server.Logging | Lean.Server.Logging.LogEntry✝ → ℕ | false |
Std.DHashMap.Internal.Raw₀.getKey!_eq_of_equiv | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited α],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → ∀ {k : α}, m₁.getKey! k = m₂.getKey! k | true |
RingHom.etale_algebraMap | Mathlib.RingTheory.RingHom.Etale | ∀ {R : Type u_3} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(algebraMap R S).Etale ↔ Algebra.Etale R S | true |
CategoryTheory.Functor.PreservesEffectiveEpiFamilies.rec | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.PreservesEffectiveEpiFamilies → Sort u_3} →
((preserves :
∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → X a ⟶ B) [CategoryTheory.EffectiveEpiFamily X π],
CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)) →
motive ⋯) →
(t : F.PreservesEffectiveEpiFamilies) → motive t | false |
AlgebraicGeometry.Scheme.Opens.topIso | Mathlib.AlgebraicGeometry.Restrict | {X : AlgebraicGeometry.Scheme} → (U : X.Opens) → (↑U).presheaf.obj (Opposite.op ⊤) ≅ X.presheaf.obj (Opposite.op U) | true |
MvPowerSeries.eq_of_coeff_monomial_ne_zero | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {m n : σ →₀ ℕ} {a : R},
(MvPowerSeries.coeff m) ((MvPowerSeries.monomial n) a) ≠ 0 → m = n | true |
CategoryTheory.GrothendieckTopology.PreservesSheafification.recOn | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
{F : CategoryTheory.Functor A B} →
{motive : J.PreservesSheafification F → Sort u_3} →
(t : J.PreservesSheafification F) →
((le : J.W ≤ J.W.inverseImage ((CategoryTheory.Functor.whiskeringRight Cᵒᵖ A B).obj F)) →
motive ⋯) →
motive t | false |
_private.Mathlib.CategoryTheory.Comma.Over.Basic.0.CategoryTheory.Functor.essImage_overPost.match_1_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {X : T} {F : CategoryTheory.Functor T D}
{Y : CategoryTheory.Over (F.obj X)} (Z : T) (e : F.obj Z ≅ Y.left)
(motive : (∃ a, F.map a = CategoryTheory.CategoryStruct.comp e.hom Y.hom) → Prop)
(x : ∃ a, F.map a = CategoryTheory.CategoryStruct.comp e.hom Y.hom),
(∀ (f : Z ⟶ X) (hf : F.map f = CategoryTheory.CategoryStruct.comp e.hom Y.hom), motive ⋯) → motive x | false |
Nat.Linear.Expr.noConfusion | Init.Data.Nat.Linear | {P : Sort u} → {t t' : Nat.Linear.Expr} → t = t' → Nat.Linear.Expr.noConfusionType P t t' | false |
CategoryTheory.compEvaluation | Mathlib.CategoryTheory.Products.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor A (CategoryTheory.Functor B C)) →
(b : B) → F.comp ((CategoryTheory.evaluation B C).obj b) ≅ F.flip.obj b | true |
Lean.Meta.SynthInstance.Context.mk.inj | Lean.Meta.SynthInstance | ∀ {maxResultSize maxHeartbeats maxResultSize_1 maxHeartbeats_1 : ℕ},
{ maxResultSize := maxResultSize, maxHeartbeats := maxHeartbeats } =
{ maxResultSize := maxResultSize_1, maxHeartbeats := maxHeartbeats_1 } →
maxResultSize = maxResultSize_1 ∧ maxHeartbeats = maxHeartbeats_1 | true |
Std.DTreeMap.Raw.Equiv.minKey!_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.minKey! = t₂.minKey! | true |
Std.DTreeMap.minKey?_le_minKey?_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k km kme : α} (hkme : (t.erase k).minKey? = some kme), t.minKey?.get ⋯ = km → (cmp km kme).isLE = true | true |
SimplexCategory.len | Mathlib.AlgebraicTopology.SimplexCategory.Defs | SimplexCategory → ℕ | true |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.norm_le_interpStrip_of_mem_verticalStrip_zero._simp_1_3 | Mathlib.Analysis.Complex.Hadamard | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
Int.toArray_roo_succ_right_eq_push | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, m < n → (m<...n + 1).toArray = (m<...n).toArray.push n | true |
CategoryTheory.isZero_of_hasProjectiveDimensionLT_zero | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] (X : C)
[CategoryTheory.HasProjectiveDimensionLT X 0], CategoryTheory.Limits.IsZero X | true |
CategoryTheory.Functor.mapPresheaf._proof_2 | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (F : CategoryTheory.Functor C D)
(X : AlgebraicGeometry.PresheafedSpace C),
{ base := (CategoryTheory.CategoryStruct.id X).base,
c := CategoryTheory.Functor.whiskerRight (CategoryTheory.CategoryStruct.id X).c F } =
CategoryTheory.CategoryStruct.id { carrier := ↑X, presheaf := CategoryTheory.Functor.comp X.presheaf F } | false |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.mkBelowAppOfIdx | Lean.Meta.IndPredBelow | ℕ → Lean.Meta.IndPredBelow.Context✝ → Lean.Expr | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic.0.CategoryTheory.WithInitial.opEquiv.match_15.eq_1 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (x y : CategoryTheory.WithTerminal Cᵒᵖ) → (x ⟶ y) → Sort u_3) (x y : C)
(f : CategoryTheory.WithTerminal.of (Opposite.op x) ⟶ CategoryTheory.WithTerminal.of (Opposite.op y))
(h_1 :
(x y : C) →
(f : CategoryTheory.WithTerminal.of (Opposite.op x) ⟶ CategoryTheory.WithTerminal.of (Opposite.op y)) →
motive (CategoryTheory.WithTerminal.of (Opposite.op x)) (CategoryTheory.WithTerminal.of (Opposite.op y)) f)
(h_2 :
(unop : C) →
(x : CategoryTheory.WithTerminal.of (Opposite.op unop) ⟶ CategoryTheory.WithTerminal.star) →
motive (CategoryTheory.WithTerminal.of (Opposite.op unop)) CategoryTheory.WithTerminal.star x)
(h_3 :
(x : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.star) →
motive CategoryTheory.WithTerminal.star CategoryTheory.WithTerminal.star x),
(match CategoryTheory.WithTerminal.of (Opposite.op x), CategoryTheory.WithTerminal.of (Opposite.op y), f with
| CategoryTheory.WithTerminal.of (Opposite.op x), CategoryTheory.WithTerminal.of (Opposite.op y), f => h_1 x y f
| CategoryTheory.WithTerminal.of (Opposite.op unop), CategoryTheory.WithTerminal.star, x => h_2 unop x
| CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => h_3 x) =
h_1 x y f | true |
Rat.instIsTopologicalAddGroup | Mathlib.Topology.Instances.Rat | IsTopologicalAddGroup ℚ | true |
USize.toUInt16_or | Init.Data.UInt.Bitwise | ∀ (a b : USize), (a ||| b).toUInt16 = a.toUInt16 ||| b.toUInt16 | true |
Lean.Meta.SynthInstance.MkTableKey.State.lmap | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.MkTableKey.State → Std.HashMap Lean.LMVarId Lean.Level | true |
MulActionHom.toFun | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{φ : M → N} → {X : Type u_5} → [inst : SMul M X] → {Y : Type u_6} → [inst_1 : SMul N Y] → (X →ₑ[φ] Y) → X → Y | true |
Lean.PrefixTreeNode.brecOn_2.go | Lean.Data.PrefixTree | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1} →
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_4 : (Std.DTreeMap.Internal.Impl α fun x => Lean.PrefixTreeNode α β cmp) → Sort u_1} →
(t : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp) →
((t : Lean.PrefixTreeNode α β cmp) → t.below → motive_1 t) →
((t : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp) →
Lean.PrefixTreeNode.below_1 t → motive_2 t) →
((t : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp) →
Lean.PrefixTreeNode.below_2 t → motive_3 t) →
((t : Std.DTreeMap.Internal.Impl α fun x => Lean.PrefixTreeNode α β cmp) →
Lean.PrefixTreeNode.below_3 t → motive_4 t) →
motive_3 t ×' Lean.PrefixTreeNode.below_2 t | true |
_private.Init.Data.Vector.Lemmas.0.Vector.insertIdx_mk._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} {h : xs.size = n} {i : ℕ}, i ≤ n → ¬i ≤ xs.size → False | false |
congrArg | Init.Prelude | ∀ {α : Sort u} {β : Sort v} {a₁ a₂ : α} (f : α → β), a₁ = a₂ → f a₁ = f a₂ | true |
MulRingNormClass | Mathlib.Algebra.Order.Hom.Basic | (F : Type u_7) →
(α : outParam (Type u_8)) →
(β : outParam (Type u_9)) → [NonAssocRing α] → [Semiring β] → [PartialOrder β] → [FunLike F α β] → Prop | true |
Finite.bddAbove_range | Mathlib.Data.Fintype.Order | ∀ {α : Type u_1} {β : Type u_2} [Finite β] [Nonempty α] [inst : Preorder α] [IsDirectedOrder α] (f : β → α),
BddAbove (Set.range f) | true |
ciInf_set_le | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : β → α} {s : Set β},
BddBelow (f '' s) → ∀ {c : β}, c ∈ s → ⨅ i, f ↑i ≤ f c | true |
Sigma.preorder | Mathlib.Data.Sigma.Order | {ι : Type u_1} → {α : ι → Type u_2} → [(i : ι) → Preorder (α i)] → Preorder ((i : ι) × α i) | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv.0.Real.tendsto_abs_tan_of_cos_eq_zero._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.ArctanDeriv | ∀ (r : ℝ), |r| = ‖r‖ | false |
_private.Mathlib.Topology.Neighborhoods.0.Filter.Eventually.eventually_nhds.match_1_1 | Mathlib.Topology.Neighborhoods | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} {p : X → Prop}
(motive : (∃ t, (∀ y ∈ t, p y) ∧ IsOpen t ∧ x ∈ t) → Prop) (x_1 : ∃ t, (∀ y ∈ t, p y) ∧ IsOpen t ∧ x ∈ t),
(∀ (t : Set X) (htp : ∀ y ∈ t, p y) (hto : IsOpen t) (ha : x ∈ t), motive ⋯) → motive x_1 | false |
instDiscreteTopologyPEmpty | Mathlib.Topology.Order | DiscreteTopology PEmpty.{u_1 + 1} | true |
CochainComplex.mappingCone.liftCocycle.congr_simp | 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 ℤ}
{n m : ℤ} (α α_1 : CochainComplex.HomComplex.Cocycle K F m) (e_α : α = α_1)
(β β_1 : CochainComplex.HomComplex.Cochain K G n) (e_β : β = β_1) (h : n + 1 = m)
(eq : CochainComplex.HomComplex.δ n m β + (↑α).comp (CochainComplex.HomComplex.Cochain.ofHom φ) ⋯ = 0),
CochainComplex.mappingCone.liftCocycle φ α β h eq = CochainComplex.mappingCone.liftCocycle φ α_1 β_1 h ⋯ | true |
_private.Mathlib.CategoryTheory.Preadditive.Biproducts.0.CategoryTheory.Limits.preservesBiproduct_of_preservesCoproduct.match_1_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {J : Type u_1} (motive : Nonempty (Fintype J) → Prop) (x : Nonempty (Fintype J)),
(∀ (val : Fintype J), motive ⋯) → motive x | false |
Monoid.lcm_orderOf_eq_exponent | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : Monoid G] [inst_1 : Fintype G], Finset.univ.lcm orderOf = Monoid.exponent G | true |
ProbabilityTheory.condIndep_biSup_compl | Mathlib.Probability.Independence.ZeroOne | ∀ {Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω}
[inst : StandardBorelSpace Ω] (hm : m ≤ m0) [inst_1 : MeasureTheory.IsFiniteMeasure μ],
(∀ (n : ι), s n ≤ m0) →
ProbabilityTheory.iCondIndep m hm s μ →
∀ (t : Set ι), ProbabilityTheory.CondIndep m (⨆ n ∈ t, s n) (⨆ n ∈ tᶜ, s n) hm μ | true |
Set.insert_Icc_right_eq_Icc_succ | Mathlib.Order.Interval.Set.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α},
a ≤ Order.succ b → insert (Order.succ b) (Set.Icc a b) = Set.Icc a (Order.succ b) | true |
CochainComplex.mapBifunctorHomologicalComplexShift₂Iso_inv_f_f | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Preadditive C₂]
[inst_5 : CategoryTheory.Preadditive D] (K₁ : CochainComplex C₁ ℤ) (K₂ : CochainComplex C₂ ℤ)
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D)) [inst_6 : F.PreservesZeroMorphisms]
[inst_7 : ∀ (X₁ : C₁), (F.obj X₁).Additive] (y i i_1 : ℤ),
((K₁.mapBifunctorHomologicalComplexShift₂Iso K₂ F y).inv.f i).f i_1 =
CategoryTheory.CategoryStruct.id ((F.obj (K₁.X i)).obj (K₂.X (i_1 + y))) | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_insertRupUnits._proof_1_11 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n)
(units : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n))
(i : Fin (f.insertRupUnits units).1.rupUnits.size) (li : Std.Tactic.BVDecide.LRAT.Internal.PosFin n) (bi : Bool),
(f.insertRupUnits units).1.rupUnits[i] = (li, bi) →
∀ (k : Fin (f.insertRupUnits units).1.rupUnits.size),
(∀ (k_1 : Fin (f.insertRupUnits units).1.rupUnits.size),
¬k_1 = k → ¬↑(f.insertRupUnits units).1.rupUnits[k_1].1 = ↑li) →
¬i = k → False | false |
Equiv.Perm.SameCycle.toList_isRotated | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {f : Equiv.Perm α} {x y : α},
f.SameCycle x y → f.toList x ~r f.toList y | true |
CategoryTheory.SmallObject.SuccStruct.extendToSuccRestrictionLEIso | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{J : Type u} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
{j : J} →
(hj : ¬IsMax j) →
(F : CategoryTheory.Functor (↑(Set.Iic j)) C) →
{X : C} →
(τ : F.obj ⟨j, ⋯⟩ ⟶ X) →
CategoryTheory.SmallObject.restrictionLE (CategoryTheory.SmallObject.SuccStruct.extendToSucc hj F τ)
⋯ ≅
F | true |
Lean.Compiler.initFn._@.Lean.Compiler.Specialize.149776412._hygCtx._hyg.2 | Lean.Compiler.Specialize | IO (Lean.ParametricAttribute (Array ℕ)) | false |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.applyIteSimproc | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow | Lean.Meta.Simp.Simproc | true |
MvPolynomial.support_one | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [Nontrivial R], MvPolynomial.support 1 = {0} | true |
CategoryTheory.Limits.Fork.isoForkOfι | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → {f g : X ⟶ Y} → (c : CategoryTheory.Limits.Fork f g) → c ≅ CategoryTheory.Limits.Fork.ofι c.ι ⋯ | true |
isClopen_range_inl | Mathlib.Topology.Clopen | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], IsClopen (Set.range Sum.inl) | true |
_private.Mathlib.Topology.Algebra.Nonarchimedean.Basic.0.NonarchimedeanRing.mul_subset.match_1_1 | Mathlib.Topology.Algebra.Nonarchimedean.Basic | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : TopologicalSpace R] (U : OpenAddSubgroup R)
(motive : (∃ V, ↑V ×ˢ ↑V ⊆ (fun p => p.1 * p.2) ⁻¹' ↑U) → Prop) (x : ∃ V, ↑V ×ˢ ↑V ⊆ (fun p => p.1 * p.2) ⁻¹' ↑U),
(∀ (V : OpenAddSubgroup R) (H : ↑V ×ˢ ↑V ⊆ (fun p => p.1 * p.2) ⁻¹' ↑U), motive ⋯) → motive x | false |
_private.Batteries.Tactic.Lint.Basic.0.Batteries.Tactic.Lint.nolintAttr.match_1 | Batteries.Tactic.Lint.Basic | (motive : Option (Array (Lean.TSyntax `ident)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `ident))) →
((ids : Array (Lean.TSyntax `ident)) → motive (some ids)) → (Unit → motive none) → motive x | false |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.thickening_thickening_subset._simp_1_1 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} (s : Set α), (∅ ⊆ s) = True | false |
TopCat.instCommRingHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier._proof_4 | Mathlib.Topology.Sheaves.CommRingCat | ∀ (X : TopCat) (R : TopCommRingCat) (x x_1 : X ⟶ (CategoryTheory.forget₂ TopCommRingCat TopCat).obj R),
CategoryTheory.ConcreteCategory.hom (x + x_1) = CategoryTheory.ConcreteCategory.hom (x + x_1) | false |
NonUnitalCommRing.toNonUnitalCommSemiring._proof_1 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [s : NonUnitalCommRing α] (a b : α), a + b = b + a | false |
Lean.Compiler.LCNF.TrivialStructureInfo.rec | Lean.Compiler.LCNF.Irrelevant | {motive : Lean.Compiler.LCNF.TrivialStructureInfo → Sort u} →
((ctorName : Lean.Name) →
(numParams fieldIdx : ℕ) → motive { ctorName := ctorName, numParams := numParams, fieldIdx := fieldIdx }) →
(t : Lean.Compiler.LCNF.TrivialStructureInfo) → motive t | false |
_private.Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral.0._aux_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral___unexpand_Submodule_span_1 | Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral | Lean.PrettyPrinter.Unexpander | false |
Std.DTreeMap.Raw.Const.getD_union | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
m₁.WF →
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Raw.Const.getD (m₁ ∪ m₂) k fallback =
Std.DTreeMap.Raw.Const.getD m₂ k (Std.DTreeMap.Raw.Const.getD m₁ k fallback) | true |
LibraryNote.lower_cancel_priority | Mathlib.Algebra.Group.Defs | Batteries.Util.LibraryNote | true |
Lean.Meta.getMatcherInfo? | Lean.Meta.Match.MatcherInfo | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → Lean.Name → m (Option Lean.Meta.MatcherInfo) | true |
Nat.bertrand | Mathlib.NumberTheory.Bertrand | ∀ (n : ℕ), n ≠ 0 → ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n | true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.ae_withDensity_iff'._simp_1_1 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
_private.Mathlib.Algebra.BigOperators.Finsupp.Basic.0.Finsupp.support_sum.match_1_1 | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_4} {M : Type u_2} {N : Type u_3} [inst : Zero M] [inst_1 : AddCommMonoid N] {f : α →₀ M}
{g : α → M → β →₀ N} (a₁ : β) (motive : (∃ a ∈ f.support, (fun a b => (g a b) a₁) a (f a) ≠ 0) → Prop)
(x : ∃ a ∈ f.support, (fun a b => (g a b) a₁) a (f a) ≠ 0),
(∀ (a : α) (ha : a ∈ f.support) (ne : (fun a b => (g a b) a₁) a (f a) ≠ 0), motive ⋯) → motive x | false |
Std.TreeSet.not_mem_emptyc | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {k : α}, k ∉ ∅ | true |
MulAction.fst_mem_orbit_of_mem_orbit | Mathlib.GroupTheory.GroupAction.Basic | ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] {β : Type u_1} [inst_2 : MulAction M β]
{x y : α × β}, x ∈ MulAction.orbit M y → x.1 ∈ MulAction.orbit M y.1 | true |
Module.Basis.sumCoords._proof_1 | Mathlib.LinearAlgebra.Basis.Defs | ∀ {R : Type u_1} [inst : Semiring R], SMulCommClass R ℕ R | false |
Std.DHashMap.Raw.mem_insert_self._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, (k ∈ m.insert k v) = True | false |
IsWellFounded.recOn | Mathlib.Order.RelClasses | {α : Type u} →
{r : α → α → Prop} →
{motive : IsWellFounded α r → Sort u_1} → (t : IsWellFounded α r) → ((wf : WellFounded r) → motive ⋯) → motive t | false |
continuousSubmonoid.eq_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (β : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : MulOneClass β]
[inst_3 : ContinuousMul β], continuousSubmonoid α β = { carrier := {f | Continuous f}, mul_mem' := ⋯, one_mem' := ⋯ } | true |
CategoryTheory.Limits.MulticospanIndex.multicospan._proof_10 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) {X Y Z : CategoryTheory.Limits.WalkingMulticospan J} (f : X ⟶ Y)
(g : Y ⟶ Z),
(match X, Z, CategoryTheory.CategoryStruct.comp f g with
| x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) =>
CategoryTheory.CategoryStruct.id
(match x with
| CategoryTheory.Limits.WalkingMulticospan.left a => I.left a
| CategoryTheory.Limits.WalkingMulticospan.right b => I.right b)
| .(CategoryTheory.Limits.WalkingMulticospan.left (J.fst b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
CategoryTheory.Limits.WalkingMulticospan.Hom.fst b => I.fst b
| .(CategoryTheory.Limits.WalkingMulticospan.left (J.snd b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
CategoryTheory.Limits.WalkingMulticospan.Hom.snd b => I.snd b) =
CategoryTheory.CategoryStruct.comp
(match X, Y, f with
| x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) =>
CategoryTheory.CategoryStruct.id
(match x with
| CategoryTheory.Limits.WalkingMulticospan.left a => I.left a
| CategoryTheory.Limits.WalkingMulticospan.right b => I.right b)
| .(CategoryTheory.Limits.WalkingMulticospan.left (J.fst b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
CategoryTheory.Limits.WalkingMulticospan.Hom.fst b => I.fst b
| .(CategoryTheory.Limits.WalkingMulticospan.left (J.snd b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
CategoryTheory.Limits.WalkingMulticospan.Hom.snd b => I.snd b)
(match Y, Z, g with
| x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) =>
CategoryTheory.CategoryStruct.id
(match x with
| CategoryTheory.Limits.WalkingMulticospan.left a => I.left a
| CategoryTheory.Limits.WalkingMulticospan.right b => I.right b)
| .(CategoryTheory.Limits.WalkingMulticospan.left (J.fst b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
CategoryTheory.Limits.WalkingMulticospan.Hom.fst b => I.fst b
| .(CategoryTheory.Limits.WalkingMulticospan.left (J.snd b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
CategoryTheory.Limits.WalkingMulticospan.Hom.snd b => I.snd b) | false |
QuotientAddGroup.map.eq_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] (N : AddSubgroup G) [nN : N.Normal]
(M : AddSubgroup H) [inst_2 : M.Normal] (f : G →+ H) (h : N ≤ AddSubgroup.comap f M),
QuotientAddGroup.map N M f h = QuotientAddGroup.lift N ((QuotientAddGroup.mk' M).comp f) ⋯ | true |
Polynomial.monomial_mem_lifts | Mathlib.Algebra.Polynomial.Lifts | ∀ {R : Type u} [inst : Semiring R] {S : Type v} [inst_1 : Semiring S] {f : R →+* S} {s : S} (n : ℕ),
s ∈ Set.range ⇑f → (Polynomial.monomial n) s ∈ Polynomial.lifts f | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.