name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ModuleCat.FilteredColimits.colimitModule | Mathlib.Algebra.Category.ModuleCat.FilteredColimits | {R : Type u} →
[inst : Ring R] →
{J : Type v} →
[inst_1 : CategoryTheory.SmallCategory J] →
[inst_2 : CategoryTheory.IsFiltered J] →
(F : CategoryTheory.Functor J (ModuleCat R)) → Module R ↑(ModuleCat.FilteredColimits.M F) |
CategoryTheory.Functor.RightExtension.precomp_obj_left | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {C' : Type u_2} {H : Type u_3} {D : Type u_4} [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} H]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H)
(G : CategoryTheory.Functor C' C)
(X : CategoryTheory.Comma ((CategoryTheory.Functor.whiskeringLeft C D H).obj L) (CategoryTheory.Functor.fromPUnit F)),
((CategoryTheory.Functor.RightExtension.precomp L F G).obj X).left = X.left |
AddMonCat.HasLimits.limitConeIsLimit._proof_9 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections]
(s : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget AddMonCat).map
(AddMonCat.ofHom
{
toFun := fun v =>
EquivLike.coe (equivShrink ↑(F.comp (CategoryTheory.forget AddMonCat)).sections)
⟨fun j => ((CategoryTheory.forget AddMonCat).mapCone s).π.app j v, ⋯⟩,
map_zero' := ⋯, map_add' := ⋯ }) =
(CategoryTheory.forget AddMonCat).map
(AddMonCat.ofHom
{
toFun := fun v =>
EquivLike.coe (equivShrink ↑(F.comp (CategoryTheory.forget AddMonCat)).sections)
⟨fun j => ((CategoryTheory.forget AddMonCat).mapCone s).π.app j v, ⋯⟩,
map_zero' := ⋯, map_add' := ⋯ }) |
AddSubmonoid.centralizer._proof_1 | Mathlib.GroupTheory.Submonoid.Centralizer | ∀ {M : Type u_1} (S : Set M) [inst : AddMonoid M] {a b : M},
a ∈ S.addCentralizer → b ∈ S.addCentralizer → a + b ∈ S.addCentralizer |
CategoryTheory.Discrete.sumEquiv | Mathlib.CategoryTheory.Discrete.SumsProducts | {J : Type u_1} →
{K : Type u_2} → CategoryTheory.Discrete (J ⊕ K) ≌ CategoryTheory.Discrete J ⊕ CategoryTheory.Discrete K |
volume_set_coe_def | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} [inst : MeasureTheory.MeasureSpace α] (s : Set α),
MeasureTheory.volume = MeasureTheory.Measure.comap Subtype.val MeasureTheory.volume |
_private.Std.Sync.Barrier.0.Std.BarrierState.generationId | Std.Sync.Barrier | Std.BarrierState✝ → ℕ |
Lean.Omega.IntList.smul_nil | Init.Omega.IntList | ∀ {i : ℤ}, i * [] = [] |
LieAlgebra.HasCentralRadical.mk | Mathlib.Algebra.Lie.Semisimple.Defs | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.radical R L = LieAlgebra.center R L → LieAlgebra.HasCentralRadical R L |
Ordnode.insert._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.H1ToTensorOfIsTrivial_H1π_single._simp_1_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {p : Submodule R M}
(x : M), Submodule.Quotient.mk x = ↑x |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.unusedVariablesIgnoreFnsExt.match_3 | Lean.Linter.UnusedVariables | (motive : List Lean.Name × Array Lean.Linter.IgnoreFunction → Sort u_1) →
(x : List Lean.Name × Array Lean.Linter.IgnoreFunction) →
((entries : List Lean.Name) → (s : Array Lean.Linter.IgnoreFunction) → motive (entries, s)) → motive x |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.withBRecOnArgs.go.go2._unsafe_rec | Lean.Meta.IndPredBelow | Lean.Meta.IndPredBelow.Context✝ →
Array Lean.Expr → Lean.Name → Array Lean.Expr → ℕ → Array Lean.Expr → Array Lean.Expr → Lean.MetaM Lean.Expr |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_eq_pullHom | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{obj obj' : (i : ι) → ↑(F.obj { as := Opposite.op (X i) })}
(hom :
(i j : ι) →
(F.map (sq i j).p₁.op.toLoc).toFunctor.obj (obj i) ⟶ (F.map (sq i j).p₂.op.toLoc).toFunctor.obj (obj' j))
⦃Y : C⦄ (q : Y ⟶ S) ⦃i₁ i₂ : ι⦄ (f₁ : Y ⟶ X i₁) (f₂ : Y ⟶ X i₂) (p : Y ⟶ (sq i₁ i₂).pullback)
(hf₁ :
autoParam (CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q)
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_eq_pullHom._auto_1)
(hf₂ :
autoParam (CategoryTheory.CategoryStruct.comp f₂ (f i₂) = q)
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_eq_pullHom._auto_3)
(hp₁ :
autoParam (CategoryTheory.CategoryStruct.comp p (sq i₁ i₂).p₁ = f₁)
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_eq_pullHom._auto_5)
(hp₂ :
autoParam (CategoryTheory.CategoryStruct.comp p (sq i₁ i₂).p₂ = f₂)
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_eq_pullHom._auto_7),
CategoryTheory.Pseudofunctor.DescentData'.pullHom' hom q f₁ f₂ hf₁ hf₂ =
CategoryTheory.Pseudofunctor.LocallyDiscreteOpToCat.pullHom (hom i₁ i₂) p f₁ f₂ ⋯ ⋯ |
LinearIndependent.of_isLocalizedModule | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} (Rₛ : Type u_2) [inst : CommSemiring R] (S : Submonoid R) [inst_1 : CommSemiring Rₛ]
[inst_2 : Algebra R Rₛ] [IsLocalization S Rₛ] {M : Type u_3} {Mₛ : Type u_4} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid Mₛ] [inst_7 : Module R Mₛ] [inst_8 : Module Rₛ Mₛ]
[IsScalarTower R Rₛ Mₛ] (f : M →ₗ[R] Mₛ) [IsLocalizedModule S f] {ι : Type u_5} {v : ι → M},
LinearIndependent R v → LinearIndependent Rₛ (⇑f ∘ v) |
_private.Mathlib.Topology.Algebra.Module.LocallyConvex.0.LinearOrderedSemiring.toLocallyConvexSpace._simp_5 | Mathlib.Topology.Algebra.Module.LocallyConvex | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderClosedTopology α] {a b x : α},
a < x → x < b → (Set.Ioo a b ∈ nhds x) = True |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.mapZ_comp | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {X Y X' Y' : C} {f : X ⟶ Y} {g : X' ⟶ Y'}
(φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) {X'' Y'' : C} {h : X'' ⟶ Y''}
(ψ : CategoryTheory.Arrow.mk g ⟶ CategoryTheory.Arrow.mk h),
data.mapZ (CategoryTheory.CategoryStruct.comp φ ψ) = CategoryTheory.CategoryStruct.comp (data.mapZ φ) (data.mapZ ψ) |
Polynomial.Monic.natDegree_pow | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → ∀ (n : ℕ), (p ^ n).natDegree = n * p.natDegree |
Encodable.encodek₂ | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} [inst : Encodable α] (a : α), Encodable.decode₂ α (Encodable.encode a) = some a |
_private.Lean.Meta.Tactic.LibrarySearch.0.Lean.Meta.LibrarySearch.isVar | Lean.Meta.Tactic.LibrarySearch | Lean.Expr → Bool |
CategoryTheory.ShortComplex.rightHomologyιNatTrans | Mathlib.Algebra.Homology.ShortComplex.RightHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasKernels C] →
[inst_3 : CategoryTheory.Limits.HasCokernels C] →
CategoryTheory.ShortComplex.rightHomologyFunctor C ⟶ CategoryTheory.ShortComplex.opcyclesFunctor C |
CategoryTheory.Quiv.hom_map_inv_map_of_iso | Mathlib.CategoryTheory.Category.Quiv | ∀ {V W : CategoryTheory.Quiv} (e : V ≅ W) {X Y : ↑W} (f : X ⟶ Y), e.hom.map (e.inv.map f) = Quiver.homOfEq f ⋯ ⋯ |
SSet.Truncated.Edge.tgt_eq | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | ∀ {X : SSet.Truncated 2}
{x₀ x₁ : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge._proof_1 })}
(self : SSet.Truncated.Edge x₀ x₁),
X.map (SimplexCategory.Truncated.δ₂ 0 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op self.edge = x₁ |
Aesop.IndexMatchResult.instOrd | Aesop.Index.Basic | {α : Type} → [Ord α] → Ord (Aesop.IndexMatchResult α) |
Finset.local_lubell_yamamoto_meshalkin_inequality_mul | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {𝒜 : Finset (Finset α)} {r : ℕ},
Set.Sized r ↑𝒜 → 𝒜.card * r ≤ 𝒜.shadow.card * (Fintype.card α - r + 1) |
_private.Mathlib.SetTheory.Cardinal.Cofinality.0.Ordinal.cof_lsub_le_lift.match_1_3 | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {ι : Type u_1} (f : ι → Ordinal.{max u_1 u_2}) (x : Ordinal.{max u_1 u_2})
(motive : (x ∈ Set.range fun i => f i.down) → Prop) (x_1 : x ∈ Set.range fun i => f i.down),
(∀ (i : ULift.{u_2, u_1} ι) (hi : (fun i => f i.down) i = x), motive ⋯) → motive x_1 |
CategoryTheory.Sieve.sieveOfSubfunctor._proof_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {R : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
(f : R ⟶ CategoryTheory.yoneda.obj X) {Y Z : C} {f_1 : Y ⟶ X},
(∃ t, f.app (Opposite.op Y) t = f_1) →
∀ (g : Z ⟶ Y), ∃ t, f.app (Opposite.op Z) t = CategoryTheory.CategoryStruct.comp g f_1 |
BoxIntegral.Box.nonempty_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι), (↑I).Nonempty |
MLList.append | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α : Type u_1} → [Monad m] → MLList m α → (Unit → MLList m α) → MLList m α |
ArithmeticFunction.prod_eq_iff_prod_pow_moebius_eq_on_of_nonzero | Mathlib.NumberTheory.ArithmeticFunction.Moebius | ∀ {R : Type u_1} [inst : CommGroupWithZero R] (s : Set ℕ),
(∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s) →
∀ {f g : ℕ → R},
(∀ n > 0, f n ≠ 0) →
(∀ n > 0, g n ≠ 0) →
((∀ n > 0, n ∈ s → ∏ i ∈ n.divisors, f i = g n) ↔
∀ n > 0, n ∈ s → ∏ x ∈ n.divisorsAntidiagonal, g x.2 ^ ArithmeticFunction.moebius x.1 = f n) |
FreeMonoid.map.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → β),
FreeMonoid.map f =
{ toFun := fun l => FreeMonoid.ofList (List.map f (FreeMonoid.toList l)), map_one' := ⋯, map_mul' := ⋯ } |
Nat.dvd_left_iff_eq | Mathlib.Data.Nat.Init | ∀ {m n : ℕ}, (∀ (a : ℕ), a ∣ m ↔ a ∣ n) ↔ m = n |
Array.foldrM_empty | Init.Data.Array.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] {f : α → β → m β} {init : β}
{start stop : ℕ}, Array.foldrM f init #[] start stop = pure init |
_private.Mathlib.MeasureTheory.Constructions.Cylinders.0.MeasureTheory.generateFrom_measurableCylinders._simp_1_5 | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
WithLp.prodContinuousLinearEquiv_apply | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : Semiring 𝕜] [inst_3 : AddCommGroup α] [inst_4 : AddCommGroup β] [inst_5 : Module 𝕜 α] [inst_6 : Module 𝕜 β]
(a : WithLp p (α × β)), (WithLp.prodContinuousLinearEquiv p 𝕜 α β) a = a.ofLp |
IsSemisimpleModule.exists_end_ringEquiv_pi_matrix_end | Mathlib.RingTheory.SimpleModule.WedderburnArtin | ∀ (R : Type u) [inst : Ring R] (M : Type v) [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSemisimpleModule R M]
[Module.Finite R M],
∃ n S d,
(∀ (i : Fin n), IsSimpleModule R ↥(S i)) ∧
(∀ (i : Fin n), NeZero (d i)) ∧
Nonempty (Module.End R M ≃+* ((i : Fin n) → Matrix (Fin (d i)) (Fin (d i)) (Module.End R ↥(S i)))) |
Std.DTreeMap.Internal.Impl.Const.get_alter!_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} {f : Option β → Option β} {hc : k ∈ Std.DTreeMap.Internal.Impl.Const.alter! k f t},
Std.DTreeMap.Internal.Impl.Const.get (Std.DTreeMap.Internal.Impl.Const.alter! k f t) k hc =
(f (Std.DTreeMap.Internal.Impl.Const.get? t k)).get ⋯ |
ZFSet.pair.eq_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x y : ZFSet.{u}), x.pair y = {{x}, {x, y}} |
Pi.vsub_def | Mathlib.Algebra.AddTorsor.Basic | ∀ {I : Type u} {fg : I → Type v} [inst : (i : I) → AddGroup (fg i)] {fp : I → Type w}
[inst_1 : (i : I) → AddTorsor (fg i) (fp i)] (p q : (i : I) → fp i), p -ᵥ q = fun i => p i -ᵥ q i |
_private.Mathlib.LinearAlgebra.FreeProduct.Basic.0.LinearAlgebra.FreeProduct.rel.match_1.eq_1 | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ (motive : Fin 2 → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()) =
h_1 () |
Lean.MessageData.instCoeLevel | Lean.Message | Coe Lean.Level Lean.MessageData |
NoMaxOrder.infinite | Mathlib.Order.Interval.Set.Infinite | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α] [NoMaxOrder α], Infinite α |
Stream'.Seq.corec_eq | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {β : Type v} (f : β → Option (α × β)) (b : β),
(Stream'.Seq.corec f b).destruct = Stream'.Seq.omap (Stream'.Seq.corec f) (f b) |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_slope_of_ne | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} [inst_1 : DecidableEq F] {P Q : Fin 3 → F},
P 2 ≠ 0 →
Q 2 ≠ 0 →
P 0 * Q 2 ≠ Q 0 * P 2 →
W.toAffine.slope (P 0 / P 2) (Q 0 / Q 2) (P 1 / P 2) (Q 1 / Q 2) =
(P 1 * Q 2 - Q 1 * P 2) / (P 0 * Q 2 - Q 0 * P 2) |
Lean.Parser.Term.forInMacro'.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter |
Lean.Elab.Info.ofTacticInfo.inj | Lean.Elab.InfoTree.Types | ∀ {i i_1 : Lean.Elab.TacticInfo}, Lean.Elab.Info.ofTacticInfo i = Lean.Elab.Info.ofTacticInfo i_1 → i = i_1 |
Encodable.decodeList._proof_1 | Mathlib.Logic.Equiv.List | ∀ (v v₂ : ℕ), v₂ < v.succ → InvImage (fun x1 x2 => x1 < x2) (fun x => x) v₂ v.succ |
TopHom._sizeOf_1 | Mathlib.Order.Hom.Bounded | {α : Type u_6} → {β : Type u_7} → {inst : Top α} → {inst_1 : Top β} → [SizeOf α] → [SizeOf β] → TopHom α β → ℕ |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.erase_getElem._proof_1_3 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} (a : α) (l : List α) (i : ℕ), i + 2 ≤ (a :: l).length → i + 1 < (a :: l).length |
Lean.Elab.Tactic.Omega.Justification.tidy? | Lean.Elab.Tactic.Omega.Core | {s : Lean.Omega.Constraint} →
{c : Lean.Omega.Coeffs} →
Lean.Elab.Tactic.Omega.Justification s c →
Option ((s' : Lean.Omega.Constraint) × (c' : Lean.Omega.Coeffs) × Lean.Elab.Tactic.Omega.Justification s' c') |
Lean.Meta.Tactic.TryThis.TryThisInfo.mk.inj | Lean.Meta.TryThis | ∀ {edit : Lean.Lsp.TextEdit} {codeActionTitle : String} {suggestion : Lean.Meta.Tactic.TryThis.Suggestion}
{edit_1 : Lean.Lsp.TextEdit} {codeActionTitle_1 : String} {suggestion_1 : Lean.Meta.Tactic.TryThis.Suggestion},
{ edit := edit, codeActionTitle := codeActionTitle, suggestion := suggestion } =
{ edit := edit_1, codeActionTitle := codeActionTitle_1, suggestion := suggestion_1 } →
edit = edit_1 ∧ codeActionTitle = codeActionTitle_1 ∧ suggestion = suggestion_1 |
Function.support_subset_iff | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {s : Set ι},
Function.support f ⊆ s ↔ ∀ (x : ι), f x ≠ 0 → x ∈ s |
_private.Lean.Util.Recognizers.0.Lean.Expr.name?.match_1 | Lean.Util.Recognizers | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((us : List Lean.Level) → motive (Lean.Expr.const `Lean.Name.anonymous us)) →
((us : List Lean.Level) →
(n : Lean.Expr) →
(s : String) →
motive (((Lean.Expr.const `Lean.Name.str us).app n).app (Lean.Expr.lit (Lean.Literal.strVal s)))) →
((us : List Lean.Level) → (n i : Lean.Expr) → motive (((Lean.Expr.const `Lean.Name.num us).app n).app i)) →
((us : List Lean.Level) →
(a : String) →
motive ((Lean.Expr.const `Lean.Name.mkStr1 us).app (Lean.Expr.lit (Lean.Literal.strVal a)))) →
((us : List Lean.Level) →
(a1 a2 : String) →
motive
(((Lean.Expr.const `Lean.Name.mkStr2 us).app (Lean.Expr.lit (Lean.Literal.strVal a1))).app
(Lean.Expr.lit (Lean.Literal.strVal a2)))) →
((us : List Lean.Level) →
(a1 a2 a3 : String) →
motive
((((Lean.Expr.const `Lean.Name.mkStr3 us).app (Lean.Expr.lit (Lean.Literal.strVal a1))).app
(Lean.Expr.lit (Lean.Literal.strVal a2))).app
(Lean.Expr.lit (Lean.Literal.strVal a3)))) →
((us : List Lean.Level) →
(a1 a2 a3 a4 : String) →
motive
(((((Lean.Expr.const `Lean.Name.mkStr4 us).app (Lean.Expr.lit (Lean.Literal.strVal a1))).app
(Lean.Expr.lit (Lean.Literal.strVal a2))).app
(Lean.Expr.lit (Lean.Literal.strVal a3))).app
(Lean.Expr.lit (Lean.Literal.strVal a4)))) →
((us : List Lean.Level) →
(a1 a2 a3 a4 a5 : String) →
motive
((((((Lean.Expr.const `Lean.Name.mkStr5 us).app (Lean.Expr.lit (Lean.Literal.strVal a1))).app
(Lean.Expr.lit (Lean.Literal.strVal a2))).app
(Lean.Expr.lit (Lean.Literal.strVal a3))).app
(Lean.Expr.lit (Lean.Literal.strVal a4))).app
(Lean.Expr.lit (Lean.Literal.strVal a5)))) →
((us : List Lean.Level) →
(a1 a2 a3 a4 a5 a6 : String) →
motive
(((((((Lean.Expr.const `Lean.Name.mkStr6 us).app
(Lean.Expr.lit (Lean.Literal.strVal a1))).app
(Lean.Expr.lit (Lean.Literal.strVal a2))).app
(Lean.Expr.lit (Lean.Literal.strVal a3))).app
(Lean.Expr.lit (Lean.Literal.strVal a4))).app
(Lean.Expr.lit (Lean.Literal.strVal a5))).app
(Lean.Expr.lit (Lean.Literal.strVal a6)))) →
((us : List Lean.Level) →
(a1 a2 a3 a4 a5 a6 a7 : String) →
motive
((((((((Lean.Expr.const `Lean.Name.mkStr7 us).app
(Lean.Expr.lit (Lean.Literal.strVal a1))).app
(Lean.Expr.lit (Lean.Literal.strVal a2))).app
(Lean.Expr.lit (Lean.Literal.strVal a3))).app
(Lean.Expr.lit (Lean.Literal.strVal a4))).app
(Lean.Expr.lit (Lean.Literal.strVal a5))).app
(Lean.Expr.lit (Lean.Literal.strVal a6))).app
(Lean.Expr.lit (Lean.Literal.strVal a7)))) →
((us : List Lean.Level) →
(a1 a2 a3 a4 a5 a6 a7 a8 : String) →
motive
(((((((((Lean.Expr.const `Lean.Name.mkStr8 us).app
(Lean.Expr.lit (Lean.Literal.strVal a1))).app
(Lean.Expr.lit (Lean.Literal.strVal a2))).app
(Lean.Expr.lit (Lean.Literal.strVal a3))).app
(Lean.Expr.lit (Lean.Literal.strVal a4))).app
(Lean.Expr.lit (Lean.Literal.strVal a5))).app
(Lean.Expr.lit (Lean.Literal.strVal a6))).app
(Lean.Expr.lit (Lean.Literal.strVal a7))).app
(Lean.Expr.lit (Lean.Literal.strVal a8)))) →
((x : Lean.Expr) → motive x) → motive x |
CategoryTheory.PresheafOfGroups.OneCochain.instGroup._proof_10 | Mathlib.CategoryTheory.Sites.NonabelianCohomology.H1 | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {G : CategoryTheory.Functor Cᵒᵖ GrpCat} {I : Type u_4}
{U : I → C} (x : CategoryTheory.PresheafOfGroups.OneCochain G U), x⁻¹ * x = 1 |
List.kextract_eq_dlookup_kerase | Mathlib.Data.List.Sigma | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (l : List (Sigma β)),
List.kextract a l = (List.dlookup a l, List.kerase a l) |
Vector.eraseIdx_set_eq | Init.Data.Vector.Erase | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {a : α} {h : i < n}, (xs.set i a h).eraseIdx i h = xs.eraseIdx i h |
Finset.untrop_sum | Mathlib.Algebra.Tropical.BigOperators | ∀ {R : Type u_1} {S : Type u_2} [inst : ConditionallyCompleteLinearOrder R] (s : Finset S)
(f : S → Tropical (WithTop R)), Tropical.untrop (∑ i ∈ s, f i) = ⨅ i, Tropical.untrop (f ↑i) |
SimpleGraph.TripartiteFromTriangles.Graph.in₁₂_iff | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)} {b : β} {c : γ},
(SimpleGraph.TripartiteFromTriangles.graph t).Adj (Sum3.in₁ b) (Sum3.in₂ c) ↔ ∃ a, (a, b, c) ∈ t |
MeasureTheory.SimpleFunc.measurable | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
(f : MeasureTheory.SimpleFunc α β), Measurable ⇑f |
ProbabilityTheory.memLp_id_gaussianReal' | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (p : ENNReal), p ≠ ⊤ → MeasureTheory.MemLp id p (ProbabilityTheory.gaussianReal μ v) |
IsBoundedBilinearMap.smul_right | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : Semiring 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 F] [inst_5 : SeminormedAddCommGroup G]
[inst_6 : Module 𝕜 G] {f : E × F → G},
IsBoundedBilinearMap 𝕜 f → ∀ (c : 𝕜) (x : E) (y : F), f (x, c • y) = c • f (x, y) |
Lean.Elab.Term.Do.Code.brecOn_4.eq | Lean.Elab.Do.Legacy | ∀ {motive_1 : Lean.Elab.Term.Do.Code → Sort u}
{motive_2 : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u}
{motive_3 : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Sort u}
{motive_4 : List (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u}
{motive_5 : List (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Sort u}
{motive_6 : Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code → Sort u}
{motive_7 : Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code → Sort u}
(t : List (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code))
(F_1 : (t : Lean.Elab.Term.Do.Code) → t.below → motive_1 t)
(F_2 : (t : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code)) → Lean.Elab.Term.Do.Code.below_1 t → motive_2 t)
(F_3 : (t : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)) → Lean.Elab.Term.Do.Code.below_2 t → motive_3 t)
(F_4 : (t : List (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code)) → Lean.Elab.Term.Do.Code.below_3 t → motive_4 t)
(F_5 : (t : List (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)) → Lean.Elab.Term.Do.Code.below_4 t → motive_5 t)
(F_6 : (t : Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Lean.Elab.Term.Do.Code.below_5 t → motive_6 t)
(F_7 : (t : Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Lean.Elab.Term.Do.Code.below_6 t → motive_7 t),
Lean.Elab.Term.Do.Code.brecOn_4 t F_1 F_2 F_3 F_4 F_5 F_6 F_7 =
F_5 t (Lean.Elab.Term.Do.Code.brecOn_4.go t F_1 F_2 F_3 F_4 F_5 F_6 F_7).2 |
Algebra.Extension.Hom.noConfusionType | Mathlib.RingTheory.Extension.Basic | Sort u_4 →
{R : Type u} →
{S : Type v} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{P : Algebra.Extension R S} →
{R' : Type u_1} →
{S' : Type u_2} →
[inst_3 : CommRing R'] →
[inst_4 : CommRing S'] →
[inst_5 : Algebra R' S'] →
{P' : Algebra.Extension R' S'} →
[inst_6 : Algebra R R'] →
[inst_7 : Algebra S S'] →
P.Hom P' →
{R' : Type u} →
{S' : Type v} →
[inst' : CommRing R'] →
[inst'_1 : CommRing S'] →
[inst'_2 : Algebra R' S'] →
{P' : Algebra.Extension R' S'} →
{R'' : Type u_1} →
{S'' : Type u_2} →
[inst'_3 : CommRing R''] →
[inst'_4 : CommRing S''] →
[inst'_5 : Algebra R'' S''] →
{P'' : Algebra.Extension R'' S''} →
[inst'_6 : Algebra R' R''] →
[inst'_7 : Algebra S' S''] → P'.Hom P'' → Sort u_4 |
CategoryTheory.Limits.MonoCoprod.mono_map'_of_injective | Mathlib.CategoryTheory.Limits.MonoCoprod | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Limits.MonoCoprod C] {I : Type u_2}
{J : Type u_3} (X : I → C) (ι : J → I),
Function.Injective ι →
∀ [inst_2 : CategoryTheory.Limits.HasCoproduct (X ∘ ι)] [inst_3 : CategoryTheory.Limits.HasCoproduct X]
[CategoryTheory.Limits.HasCoproduct fun k => X ↑k],
CategoryTheory.Mono (CategoryTheory.Limits.Sigma.map' ι fun j => CategoryTheory.CategoryStruct.id ((X ∘ ι) j)) |
instPowInt32Nat | Init.Data.SInt.Basic | Pow Int32 ℕ |
continuous_ofDual | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X], Continuous ⇑OrderDual.ofDual |
Lean.Lsp.LeanFileProgressProcessingInfo.ctorIdx | Lean.Data.Lsp.Extra | Lean.Lsp.LeanFileProgressProcessingInfo → ℕ |
CategoryTheory.Regular.hasCoequalizer_of_isKernelPair | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Regular C] {X Y Z : C} {f : X ⟶ Y}
{g₁ g₂ : Z ⟶ X}, CategoryTheory.IsKernelPair f g₁ g₂ → CategoryTheory.Limits.HasCoequalizer g₁ g₂ |
NumberField.InfinitePlace.mkReal._proof_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] (φ : { φ // NumberField.ComplexEmbedding.IsReal φ }),
∃ φ_1, NumberField.ComplexEmbedding.IsReal φ_1 ∧ NumberField.InfinitePlace.mk φ_1 = NumberField.InfinitePlace.mk ↑φ |
Poly.instAddCommGroup._proof_4 | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} (x : Poly α), x + 0 = x |
Lean.Doc.Parser.instInhabitedInlineCtxt.default | Lean.DocString.Parser | Lean.Doc.Parser.InlineCtxt |
Lean.Meta.Sym.AlphaShareCommon.State.mk.injEq | Lean.Meta.Sym.AlphaShareCommon | ∀ (set set_1 : Lean.PHashSet Lean.Meta.Sym.AlphaKey), ({ set := set } = { set := set_1 }) = (set = set_1) |
List.decidableBEx._proof_2 | Init.Data.List.Basic | ∀ {α : Type u_1} (p : α → Prop) (x : α) (xs : List α), p x → ∃ x_1 ∈ x :: xs, p x_1 |
Lean.Meta.ExtractLets.LocalDecl'.mk.inj | Lean.Meta.Tactic.Lets | ∀ {decl : Lean.LocalDecl} {isLet : Bool} {decl_1 : Lean.LocalDecl} {isLet_1 : Bool},
{ decl := decl, isLet := isLet } = { decl := decl_1, isLet := isLet_1 } → decl = decl_1 ∧ isLet = isLet_1 |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.JoinPoints.3948291228._hygCtx._hyg.2 | Lean.Compiler.LCNF.JoinPoints | IO Unit |
CategoryTheory.Limits.hasCokernel_comp_iso | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.IsIso g],
CategoryTheory.Limits.HasCokernel (CategoryTheory.CategoryStruct.comp f g) |
Polynomial.toFinsupp_mul | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a b : Polynomial R), (a * b).toFinsupp = a.toFinsupp * b.toFinsupp |
codisjoint_top_right._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, Codisjoint a ⊤ = True |
Std.DTreeMap.Internal.Impl.entryAtIdxD.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (x : ℕ) (x_1 : (a : α) × β a) (size : ℕ) (k : α) (v : β k)
(l r : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k v l r).entryAtIdxD x x_1 =
match compare x l.size with
| Ordering.lt => l.entryAtIdxD x x_1
| Ordering.eq => ⟨k, v⟩
| Ordering.gt => r.entryAtIdxD (x - l.size - 1) x_1 |
TotallyDisconnectedSpace.continuousMapEquivOfConnectedSpace._proof_3 | Mathlib.Topology.Connected.TotallyDisconnected | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [TotallyDisconnectedSpace Y]
[inst_3 : ConnectedSpace X] (f : C(X, Y)), { toFun := fun x => f (Classical.arbitrary X), continuous_toFun := ⋯ } = f |
_private.Mathlib.Computability.Halting.0.Partrec.merge'._simp_1_8 | Mathlib.Computability.Halting | ∀ {α : Type u_1} (a : α), (Part.some a).1 = True |
Lean.Server.Watchdog.LogMsg.ctorIdx | Lean.Server.Watchdog | Lean.Server.Watchdog.LogMsg → ℕ |
Std.HashMap.getKey?_eq_some_getKeyD | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α}, a ∈ m → m.getKey? a = some (m.getKeyD a fallback) |
_private.Lean.Parser.Module.0.Lean.Parser.Module.updateTokens.match_1 | Lean.Parser.Module | (motive : Except String Lean.Parser.TokenTable → Sort u_1) →
(x : Except String Lean.Parser.TokenTable) →
((tables : Lean.Parser.TokenTable) → motive (Except.ok tables)) →
((a : String) → motive (Except.error a)) → motive x |
Std.Irrefl.recOn | Init.Core | {α : Sort u} →
{r : α → α → Prop} →
{motive : Std.Irrefl r → Sort u_1} → (t : Std.Irrefl r) → ((irrefl : ∀ (a : α), ¬r a a) → motive ⋯) → motive t |
SemiNormedGrp.Hom.neg | Mathlib.Analysis.Normed.Group.SemiNormedGrp | {M N : SemiNormedGrp} → Neg (M ⟶ N) |
CategoryTheory.Functor.coconeTypesEquiv._proof_3 | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J (Type u_1))
(x : F.CoconeTypes),
{ pt := { pt := x.pt, ι := { app := fun j => x.ι j, naturality := ⋯ } }.pt,
ι := fun j => { pt := x.pt, ι := { app := fun j => x.ι j, naturality := ⋯ } }.ι.app j, ι_naturality := ⋯ } =
{ pt := { pt := x.pt, ι := { app := fun j => x.ι j, naturality := ⋯ } }.pt,
ι := fun j => { pt := x.pt, ι := { app := fun j => x.ι j, naturality := ⋯ } }.ι.app j, ι_naturality := ⋯ } |
CategoryTheory.Limits.isLimitConeOfCoconeUnop_lift | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) {c : CategoryTheory.Limits.Cocone F.unop}
(hc : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cone F),
(CategoryTheory.Limits.isLimitConeOfCoconeUnop F hc).lift s = (hc.desc (CategoryTheory.Limits.coconeUnopOfCone s)).op |
IsDedekindDomain.HeightOneSpectrum._sizeOf_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | {R : Type u_1} → {inst : CommRing R} → [SizeOf R] → IsDedekindDomain.HeightOneSpectrum R → ℕ |
Finsupp.instAddMonoid._proof_1 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_2} [inst : AddMonoid M], Function.Injective fun f => ⇑f |
CategoryTheory.evaluationAdjunctionLeft_unit_app_app | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (X : CategoryTheory.Functor C D)
(x : C),
((CategoryTheory.evaluationAdjunctionLeft D c).unit.app X).app x = CategoryTheory.Limits.Pi.lift fun g => X.map g |
Language.leftQuotient_append | Mathlib.Computability.MyhillNerode | ∀ {α : Type u} (L : Language α) (x y : List α), L.leftQuotient (x ++ y) = (L.leftQuotient x).leftQuotient y |
ContinuousMap.Homotopic.comp | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} {Z : Type w} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {g₀ g₁ : C(Y, Z)} {f₀ f₁ : C(X, Y)},
g₀.Homotopic g₁ → f₀.Homotopic f₁ → (g₀.comp f₀).Homotopic (g₁.comp f₁) |
exteriorPower.map_injective | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {n : ℕ} {M : Type u_1} {N : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f : M →ₗ[R] N} (g : N →ₗ[R] M),
g ∘ₗ f = LinearMap.id → Function.Injective ⇑(exteriorPower.map n f) |
Ordinal.isEquivalent.match_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ {x y : WellOrder}
(motive :
(match x with
| { α := α, r := r, wo := wo } =>
match y with
| { α := α_1, r := s, wo := wo } => Nonempty (r ≃r s)) →
Prop)
(x_1 :
match x with
| { α := α, r := r, wo := wo } =>
match y with
| { α := α_1, r := s, wo := wo } => Nonempty (r ≃r s)),
(∀ (e : x.r ≃r y.r), motive ⋯) → motive x_1 |
_private.Mathlib.Data.EReal.Operations.0.EReal.mul_pos_iff._simp_1_1 | Mathlib.Data.EReal.Operations | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) |
ConvexCone.coe_iInf._simp_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : SMul R M] {ι : Sort u_7} (f : ι → ConvexCone R M), ⋂ i, ↑(f i) = ↑(iInf f) |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_rev._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (i : Fin w), ¬w - (w - (↑i + 1) + 1) = ↑i → False |
PiTensorProduct.mapL_pow | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {ι : Type uι} [inst : Fintype ι] {𝕜 : Type u𝕜} [inst_1 : NontriviallyNormedField 𝕜] {E : ι → Type uE}
[inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)]
(f : (i : ι) → E i →L[𝕜] E i) (n : ℕ), PiTensorProduct.mapL (f ^ n) = PiTensorProduct.mapL f ^ n |
CategoryTheory.ShortComplex.RightHomologyMapData.id_φH | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData),
(CategoryTheory.ShortComplex.RightHomologyMapData.id h).φH = CategoryTheory.CategoryStruct.id h.H |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.