name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.send | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Bounded✝ α → α → BaseIO (Task (Except Std.CloseableChannel.Error Unit)) |
TopologicalSpace.IrreducibleCloseds.equivSubtype'._proof_1 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_1} [inst : TopologicalSpace α],
Function.LeftInverse (fun a => { carrier := ↑a, isIrreducible' := ⋯, isClosed' := ⋯ }) fun a => ⟨a.carrier, ⋯⟩ |
YoungDiagram.equivListRowLens._proof_3 | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (x : { w // w.SortedGE ∧ ∀ x ∈ w, 0 < x }),
(YoungDiagram.ofRowLens ↑x ⋯).rowLens.SortedGE ∧ ∀ x_1 ∈ (YoungDiagram.ofRowLens ↑x ⋯).rowLens, 0 < x_1 |
LieAlgebra.ofTwoCocycle._sizeOf_inst | Mathlib.Algebra.Lie.Extension | {R : Type u_5} →
{L : Type u_6} →
{M : Type u_7} →
{inst : CommRing R} →
{inst_1 : LieRing L} →
{inst_2 : LieAlgebra R L} →
{inst_3 : AddCommGroup M} →
{inst_4 : Module R M} →
{inst_5 : LieRingModule L M} →
{inst_6 : LieModule R L M} →
(c : ↥(LieModule.Cohomology.twoCocycle R L M)) →
[SizeOf R] → [SizeOf L] → [SizeOf M] → SizeOf (LieAlgebra.ofTwoCocycle c) |
AffineMap.nonempty | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2]
[inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2], Nonempty (P1 →ᵃ[k] P2) |
_private.Mathlib.Algebra.Order.Archimedean.Submonoid.0.SubmonoidClass.instMulArchimedean._simp_1 | Mathlib.Algebra.Order.Archimedean.Submonoid | ∀ {α : Type u_2} [inst : LT α] {p : α → Prop} {x y : Subtype p}, (x < y) = (↑x < ↑y) |
Submodule.span_prod_le | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_8}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (s : Set M) (t : Set M'),
Submodule.span R (s ×ˢ t) ≤ (Submodule.span R s).prod (Submodule.span R t) |
EReal.zero_mul | Mathlib.Data.EReal.Basic | ∀ (x : EReal), 0 * x = 0 |
Subfield.instSMulWithZeroSubtypeMem | Mathlib.Algebra.Field.Subfield.Basic | {K : Type u} →
[inst : DivisionRing K] →
{X : Type u_1} → [inst_1 : Zero X] → [SMulWithZero K X] → (F : Subfield K) → SMulWithZero (↥F) X |
_private.Mathlib.RingTheory.Invariant.Basic.0.Algebra.IsInvariant.orbit_eq_primesOver.match_1_1 | Mathlib.RingTheory.Invariant.Basic | ∀ (B : Type u_1) (G : Type u_2) [inst : CommRing B] [inst_1 : Group G] [inst_2 : MulSemiringAction G B] (Q R : Ideal B)
(motive : R ∈ MulAction.orbit G Q → Prop) (x : R ∈ MulAction.orbit G Q),
(∀ (g : G) (hg : (fun m => m • Q) g = R), motive ⋯) → motive x |
HasFDerivAtFilter.finCons | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : ℕ} {F' : Fin n.succ → Type u_6}
[inst_3 : (i : Fin n.succ) → NormedAddCommGroup (F' i)] [inst_4 : (i : Fin n.succ) → NormedSpace 𝕜 (F' i)]
{φ : E → F' 0} {φs : E → (i : Fin n) → F' i.succ} {φ' : E →L[𝕜] F' 0} {φs' : E →L[𝕜] (i : Fin n) → F' i.succ}
{l : Filter (E × E)},
HasFDerivAtFilter φ φ' l →
HasFDerivAtFilter φs φs' l → HasFDerivAtFilter (fun x => Fin.cons (φ x) (φs x)) (φ'.finCons φs') l |
_private.Lean.Server.FileWorker.SignatureHelp.0.Lean.Server.FileWorker.SignatureHelp.findSignatureHelp?.match_1 | Lean.Server.FileWorker.SignatureHelp | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((range : Lean.Syntax.Range) → motive (some range)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x |
SSet.spine_vertex | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ (X : SSet) (n : ℕ) (Δ : X.obj (Opposite.op (SimplexCategory.mk n))) (i : Fin (n + 1)),
(X.spine n Δ).vertex i = X.map ((SimplexCategory.mk 0).const (SimplexCategory.mk n) i).op Δ |
AlgebraicGeometry.Scheme.IdealSheafData.mkOfMemSupportIff | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | {X : AlgebraicGeometry.Scheme} →
(ideal : (U : ↑X.affineOpens) → Ideal ↑(X.presheaf.obj (Opposite.op ↑U))) →
(∀ (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) (ideal U) =
ideal (X.affineBasicOpen f)) →
(supportSet : Set ↥X) →
(∀ (U : ↑X.affineOpens), ∀ x ∈ ↑U, x ∈ supportSet ↔ x ∈ X.zeroLocus ↑(ideal U)) → X.IdealSheafData |
IsPrecomplete.rec | Mathlib.RingTheory.AdicCompletion.Basic | {R : Type u_1} →
[inst : CommRing R] →
{I : Ideal R} →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsPrecomplete I M → Sort u} →
((prec' :
∀ (f : ℕ → M),
(∀ {m n : ℕ}, m ≤ n → f m ≡ f n [SMOD I ^ m • ⊤]) → ∃ L, ∀ (n : ℕ), f n ≡ L [SMOD I ^ n • ⊤]) →
motive ⋯) →
(t : IsPrecomplete I M) → motive t |
MeasureTheory.setLIntegral_subtype | Mathlib.MeasureTheory.Integral.Lebesgue.Map | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s →
∀ (t : Set ↑s) (f : α → ENNReal),
∫⁻ (x : ↑s) in t, f ↑x ∂MeasureTheory.Measure.comap Subtype.val μ = ∫⁻ (x : α) in Subtype.val '' t, f x ∂μ |
HomologicalComplex.doubleXIso₁._proof_1 | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X₀ X₁ : C} (f : X₀ ⟶ X₁) {ι : Type u_3} {c : ComplexShape ι}
{i₀ i₁ : ι} (hi₀₁ : c.Rel i₀ i₁), i₀ ≠ i₁ → (HomologicalComplex.double f hi₀₁).X i₁ = X₁ |
MeasureTheory.IsAddFundamentalDomain.setLIntegral_eq_tsum' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α] [MeasureTheory.VAddInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsAddFundamentalDomain G s μ →
∀ (f : α → ENNReal) (t : Set α), ∫⁻ (x : α) in t, f x ∂μ = ∑' (g : G), ∫⁻ (x : α) in (g +ᵥ t) ∩ s, f (-g +ᵥ x) ∂μ |
pseudoEMetricSpacePi._proof_1 | Mathlib.Topology.EMetricSpace.Pi | ∀ {β : Type u_1} {X : β → Type u_2} [inst : Fintype β] [inst_1 : (b : β) → PseudoEMetricSpace (X b)]
(f : (b : β) → X b), ∀ b ∈ Finset.univ, edist (f b) (f b) ≤ ⊥ |
Lean.Widget.RpcEncodablePacket.mk.sizeOf_spec._@.Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | ∀ (type exprExplicit doc : Lean.Json),
sizeOf { type := type, exprExplicit := exprExplicit, doc := doc } = 1 + sizeOf type + sizeOf exprExplicit + sizeOf doc |
conj_zpow | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} [inst : Group α] {i : ℤ} {a b : α}, (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ |
Nat.cast_le_pow_sub_div_sub | Mathlib.Algebra.Order.Field.Power | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a : α},
1 < a → ∀ (n : ℕ), ↑n ≤ (a ^ n - 1) / (a - 1) |
WType.Listα.cons.noConfusion | Mathlib.Data.W.Constructions | {γ : Type u} → {P : Sort u_1} → {a a' : γ} → WType.Listα.cons a = WType.Listα.cons a' → (a ≍ a' → P) → P |
SchwartzMap.norm_fourier_Lp_top_leq_toLp_one | Mathlib.Analysis.Distribution.SchwartzSpace.Fourier | ∀ {V : Type u_3} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : FiniteDimensional ℝ V]
[inst_3 : MeasurableSpace V] [inst_4 : BorelSpace V] {F : Type u_4} [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace ℂ F] (f : SchwartzMap V F),
‖(FourierTransform.fourier f).toLp ⊤ MeasureTheory.volume‖ ≤ ‖f.toLp 1 MeasureTheory.volume‖ |
SubMulAction.instSMulSubtypeMem.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] (p : SubMulAction R M),
p.instSMulSubtypeMem = { smul := fun c x => ⟨c • ↑x, ⋯⟩ } |
derivationToSquareZeroOfLift._proof_5 | Mathlib.RingTheory.Derivation.ToSquareZero | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (I : Ideal B) [inst_5 : Algebra A B] [inst_6 : IsScalarTower R A B],
I ^ 2 = ⊥ →
∀ (f : A →ₐ[R] B) (e : (Ideal.Quotient.mkₐ R I).comp f = IsScalarTower.toAlgHom R A (B ⧸ I)) (x y : A),
(diffToIdealOfQuotientCompEq I f (IsScalarTower.toAlgHom R A B) ⋯) (x * y) =
x • (diffToIdealOfQuotientCompEq I f (IsScalarTower.toAlgHom R A B) ⋯) y +
y • (diffToIdealOfQuotientCompEq I f (IsScalarTower.toAlgHom R A B) ⋯) x |
AddUnits.neg_val | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (self : AddUnits α), self.neg + ↑self = 0 |
USize.shiftLeft_zero | Init.Data.UInt.Bitwise | ∀ {a : USize}, a <<< 0 = a |
CategoryTheory.Grp.mkIso._auto_3 | Mathlib.CategoryTheory.Monoidal.Grp_ | Lean.Syntax |
CategoryTheory.Functor.PullbackObjObj.mk.injEq | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₃ Y₃ : C₃}
{f₃ : X₃ ⟶ Y₃} (pt : C₂) (fst : pt ⟶ (G.obj (Opposite.op X₁)).obj X₃) (snd : pt ⟶ (G.obj (Opposite.op Y₁)).obj Y₃)
(isPullback : CategoryTheory.IsPullback fst snd ((G.obj (Opposite.op X₁)).map f₃) ((G.map f₁.op).app Y₃)) (pt_1 : C₂)
(fst_1 : pt_1 ⟶ (G.obj (Opposite.op X₁)).obj X₃) (snd_1 : pt_1 ⟶ (G.obj (Opposite.op Y₁)).obj Y₃)
(isPullback_1 : CategoryTheory.IsPullback fst_1 snd_1 ((G.obj (Opposite.op X₁)).map f₃) ((G.map f₁.op).app Y₃)),
({ pt := pt, fst := fst, snd := snd, isPullback := isPullback } =
{ pt := pt_1, fst := fst_1, snd := snd_1, isPullback := isPullback_1 }) =
(pt = pt_1 ∧ fst ≍ fst_1 ∧ snd ≍ snd_1) |
IsOrderedMonoid.mk._flat_ctor | Mathlib.Algebra.Order.Monoid.Defs | ∀ {α : Type u_2} [inst : CommMonoid α] [inst_1 : Preorder α],
(∀ (a b : α), a ≤ b → ∀ (c : α), a * c ≤ b * c) → (∀ (a b : α), a ≤ b → ∀ (c : α), c * a ≤ c * b) → IsOrderedMonoid α |
MeasureTheory.SimpleFunc.coe_neg._simp_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Neg β] (f : MeasureTheory.SimpleFunc α β),
-⇑f = ⇑(-f) |
AddSubmonoid.map_equiv_eq_comap_symm | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {N : Type u_2} [inst : AddZeroClass N] {M : Type u_5} [inst_1 : AddZeroClass M] (f : M ≃+ N) (K : AddSubmonoid M),
AddSubmonoid.map f K = AddSubmonoid.comap f.symm K |
MeasureTheory.SignedMeasure.toMeasureOfZeroLE._proof_1 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} (s : MeasureTheory.SignedMeasure α) (i : Set α),
MeasurableSet i →
∀ (hi₂ : MeasureTheory.VectorMeasure.restrict 0 i ≤ MeasureTheory.VectorMeasure.restrict s i),
s.toMeasureOfZeroLE' i hi₂ ∅ ⋯ = 0 |
PartOrdEmb.hom_id | Mathlib.Order.Category.PartOrdEmb | ∀ {X : PartOrdEmb}, PartOrdEmb.Hom.hom (CategoryTheory.CategoryStruct.id X) = RelEmbedding.refl fun x1 x2 => x1 ≤ x2 |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.isAlreadyNorm? | Lean.Meta.Tactic.Grind.Intro | Lean.Expr → Option Lean.Expr |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.Topology.IsClosedEmbedding.weaklyLocallyCompactSpace.match_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace Y] {f : X → Y} (x : X)
(motive : (∃ s, IsCompact s ∧ s ∈ nhds (f x)) → Prop) (x_1 : ∃ s, IsCompact s ∧ s ∈ nhds (f x)),
(∀ (K : Set Y) (hK : IsCompact K) (hKx : K ∈ nhds (f x)), motive ⋯) → motive x_1 |
_private.Mathlib.Computability.RegularExpressions.0.RegularExpression.matches'.match_1.eq_1 | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (motive : RegularExpression α → Sort u_2) (h_1 : Unit → motive RegularExpression.zero)
(h_2 : Unit → motive RegularExpression.epsilon) (h_3 : (a : α) → motive (RegularExpression.char a))
(h_4 : (P Q : RegularExpression α) → motive (P.plus Q)) (h_5 : (P Q : RegularExpression α) → motive (P.comp Q))
(h_6 : (P : RegularExpression α) → motive P.star),
(match RegularExpression.zero with
| RegularExpression.zero => h_1 ()
| RegularExpression.epsilon => h_2 ()
| RegularExpression.char a => h_3 a
| P.plus Q => h_4 P Q
| P.comp Q => h_5 P Q
| P.star => h_6 P) =
h_1 () |
_private.Lean.Util.Trace.0.Lean.printTraces.match_1 | Lean.Util.Trace | (motive : Lean.TraceElem → Sort u_1) →
(x : Lean.TraceElem) → ((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive { ref := ref, msg := msg }) → motive x |
Nat.modCore_lt | Init.Prelude | ∀ {x y : ℕ}, 0 < y → x.modCore y < y |
Fin2.insertPerm | Mathlib.Data.Fin.Fin2 | {n : ℕ} → Fin2 n → Fin2 n → Fin2 n |
IntervalIntegrable.sub | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ} {f g : ℝ → E},
IntervalIntegrable f μ a b → IntervalIntegrable g μ a b → IntervalIntegrable (fun x => f x - g x) μ a b |
ProofWidgets.InteractiveExprProps._sizeOf_1 | ProofWidgets.Component.Basic | ProofWidgets.InteractiveExprProps → ℕ |
CategoryTheory.MorphismProperty.instIsStableUnderBaseChangeFunctorFunctorCategoryOfHasPullbacks | Mathlib.CategoryTheory.MorphismProperty.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
[W.IsStableUnderBaseChange] (J : Type u'') [inst_2 : CategoryTheory.Category.{v'', u''} J]
[CategoryTheory.Limits.HasPullbacks C], (W.functorCategory J).IsStableUnderBaseChange |
Lean.Lsp.instToJsonMarkupKind | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.MarkupKind |
CategoryTheory.Sheaf.locallySurjective | Mathlib.CategoryTheory.Sites.EpiMono | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u') →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
{FA : A → A → Type u_1} →
{CA : A → Type w} →
[inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] →
[CategoryTheory.ConcreteCategory A FA] → CategoryTheory.MorphismProperty (CategoryTheory.Sheaf J A) |
CategoryTheory.Bicategory.LeftLift.whisker_unit | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(t : CategoryTheory.Bicategory.LeftLift f g) {x : B} (h : x ⟶ c),
(t.whisker h).unit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft h t.unit)
(CategoryTheory.Bicategory.associator h t.lift f).inv |
CategoryTheory.FreeBicategory.Rel.below.triangle | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B]
{motive :
{a b : CategoryTheory.FreeBicategory B} →
{f g : a ⟶ b} →
(a_1 a_2 : CategoryTheory.FreeBicategory.Hom₂ f g) → CategoryTheory.FreeBicategory.Rel a_1 a_2 → Prop}
{a b c : B} (f : CategoryTheory.FreeBicategory.Hom a b) (g : CategoryTheory.FreeBicategory.Hom b c),
CategoryTheory.FreeBicategory.Rel.below ⋯ |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_176 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] 0 + 1 ≤ (List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] 0 < (List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
Lean.Meta.Grind.Arith.Cutsat.UnsatProof.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.Cutsat.UnsatProof} →
t = t' → Lean.Meta.Grind.Arith.Cutsat.UnsatProof.noConfusionType P t t' |
IsRightCancelMul.mulRightReflectLE_of_mulRightReflectLT | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ (N : Type u_2) [inst : Mul N] [IsRightCancelMul N] [inst_2 : PartialOrder N] [MulRightReflectLT N],
MulRightReflectLE N |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valuation.isNontrivial_iff_not_a_field._simp_1_4 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono._proof_3 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [CategoryTheory.Epi φ.τ₁],
CategoryTheory.Mono (CategoryTheory.ShortComplex.opMap φ).τ₃ |
PFunctor.M.Agree'.below.casesOn | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {motive : (a : ℕ) → (a_1 a_2 : F.M) → PFunctor.M.Agree' a a_1 a_2 → Prop}
{motive_1 : {a : ℕ} → {a_1 a_2 : F.M} → (t : PFunctor.M.Agree' a a_1 a_2) → PFunctor.M.Agree'.below t → Prop} {a : ℕ}
{a_1 a_2 : F.M} {t : PFunctor.M.Agree' a a_1 a_2} (t_1 : PFunctor.M.Agree'.below t),
(∀ (x y : F.M), motive_1 ⋯ ⋯) →
(∀ {n : ℕ} {a : F.A} (x y : F.B a → F.M) {x' y' : F.M} (a_3 : x' = PFunctor.M.mk ⟨a, x⟩)
(a_4 : y' = PFunctor.M.mk ⟨a, y⟩) (a_5 : ∀ (i : F.B a), PFunctor.M.Agree' n (x i) (y i))
(ih : ∀ (i : F.B a), PFunctor.M.Agree'.below ⋯) (a_ih : ∀ (i : F.B a), motive n (x i) (y i) ⋯), motive_1 ⋯ ⋯) →
motive_1 t t_1 |
AffineSubspace.parallel_bot_iff_eq_bot._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P}, s.Parallel ⊥ = (s = ⊥) |
CategoryTheory.PreGaloisCategory.functorToAction_comp_forget₂_eq | Mathlib.CategoryTheory.Galois.Action | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (F : CategoryTheory.Functor C FintypeCat),
(CategoryTheory.PreGaloisCategory.functorToAction F).comp
(CategoryTheory.forget₂ (Action FintypeCat (CategoryTheory.Aut F)) FintypeCat) =
F |
GradedRing.mem_support_iff | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜]
[inst_6 : (i : ι) → (x : ↥(𝒜 i)) → Decidable (x ≠ 0)] (r : A) (i : ι),
i ∈ DFinsupp.support ((DirectSum.decompose 𝒜) r) ↔ (GradedRing.proj 𝒜 i) r ≠ 0 |
Std.TransCmp.isLE_trans | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [self : Std.TransCmp cmp] {a b c : α},
(cmp a b).isLE = true → (cmp b c).isLE = true → (cmp a c).isLE = true |
MonadSatisfying.instEStateM._proof_4 | Batteries.Classes.SatisfiesM | ∀ {ε σ α : Type u_1} {p : α → Prop} {x : EStateM ε σ α} (h : SatisfiesM p x),
(Subtype.val <$>
have h' := ⋯;
fun s =>
match w : x.run s with
| EStateM.Result.ok a s' => EStateM.Result.ok ⟨a, ⋯⟩ s'
| EStateM.Result.error e s' => EStateM.Result.error e s') =
x |
coverPreserving_opens_map | Mathlib.Topology.Sheaves.SheafCondition.Sites | ∀ {X Y : TopCat} (f : X ⟶ Y),
CategoryTheory.CoverPreserving (Opens.grothendieckTopology ↑Y) (Opens.grothendieckTopology ↑X)
(TopologicalSpace.Opens.map f) |
DiffeologicalSpace.CorePlotsOn.mk.sizeOf_spec | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} [inst : SizeOf X]
(isPlotOn : {n : ℕ} → {u : Set (EuclideanSpace ℝ (Fin n))} → IsOpen u → (EuclideanSpace ℝ (Fin n) → X) → Prop)
(isPlotOn_congr :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p q : EuclideanSpace ℝ (Fin n) → X},
Set.EqOn p q u → (isPlotOn hu p ↔ isPlotOn hu q))
(isPlot : {n : ℕ} → (EuclideanSpace ℝ (Fin n) → X) → Prop)
(isPlotOn_univ :
autoParam (∀ {n : ℕ} {p : EuclideanSpace ℝ (Fin n) → X}, isPlotOn ⋯ p ↔ isPlot p)
DiffeologicalSpace.CorePlotsOn.isPlotOn_univ._autoParam)
(isPlot_const : ∀ {n : ℕ} (x : X), isPlot fun x_1 => x)
(isPlotOn_reparam :
∀ {n m : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} {v : Set (EuclideanSpace ℝ (Fin m))} {hu : IsOpen u}
(hv : IsOpen v) {p : EuclideanSpace ℝ (Fin n) → X} {f : EuclideanSpace ℝ (Fin m) → EuclideanSpace ℝ (Fin n)},
Set.MapsTo f v u → isPlotOn hu p → ContDiffOn ℝ (↑⊤) f v → isPlotOn hv (p ∘ f))
(locality :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p : EuclideanSpace ℝ (Fin n) → X},
(∀ x ∈ u, ∃ v, ∃ (hv : IsOpen v), x ∈ v ∧ isPlotOn hv p) → isPlotOn hu p)
(dTopology : TopologicalSpace X)
(isOpen_iff_preimages_plots :
autoParam
(∀ {u : Set X},
TopologicalSpace.IsOpen u ↔ ∀ {n : ℕ} (p : EuclideanSpace ℝ (Fin n) → X), isPlot p → IsOpen (p ⁻¹' u))
DiffeologicalSpace.CorePlotsOn.isOpen_iff_preimages_plots._autoParam),
sizeOf
{ isPlotOn := isPlotOn, isPlotOn_congr := isPlotOn_congr, isPlot := isPlot, isPlotOn_univ := isPlotOn_univ,
isPlot_const := isPlot_const, isPlotOn_reparam := isPlotOn_reparam, locality := locality,
dTopology := dTopology, isOpen_iff_preimages_plots := isOpen_iff_preimages_plots } =
1 + sizeOf dTopology |
Lean.Meta.PProdN.reduceProjs | Lean.Meta.PProdN | Lean.Expr → Lean.MetaM Lean.Expr |
nsmul_iterate | Mathlib.Algebra.Group.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] (k n : ℕ), (fun x => k • x)^[n] = fun x => k ^ n • x |
CategoryTheory.EnrichedFunctor.hom_ext | Mathlib.CategoryTheory.Enriched.Basic | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₂} [inst_3 : CategoryTheory.EnrichedCategory V D]
{F G : CategoryTheory.EnrichedFunctor V C D} {α β : F ⟶ G}, (∀ (X : C), α.out.app X = β.out.app X) → α = β |
_private.Mathlib.NumberTheory.TsumDivisorsAntidiagonal.0.tsum_pow_div_one_sub_eq_tsum_sigma._simp_1_1 | Mathlib.NumberTheory.TsumDivisorsAntidiagonal | ∀ {ι : Type u_1} {α : Type u_3} {L : SummationFilter ι} [inst : DivisionSemiring α] [inst_1 : TopologicalSpace α]
[IsTopologicalSemiring α] {f : ι → α} {a : α} [T2Space α], a * ∑'[L] (x : ι), f x = ∑'[L] (x : ι), a * f x |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.Lean.Meta.Grind.AC.propagateEqs.match_3 | Lean.Meta.Tactic.Grind.AC.Eq | (motive : Unit × Bool × Lean.Meta.Grind.AC.PropagateEqMap → Sort u_1) →
(__discr : Unit × Bool × Lean.Meta.Grind.AC.PropagateEqMap) →
((fst : Unit) → (propagated : Bool) → (snd : Lean.Meta.Grind.AC.PropagateEqMap) → motive (fst, propagated, snd)) →
motive __discr |
UniformFun.ofFun_toFun | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} (f : UniformFun α β), UniformFun.ofFun (UniformFun.toFun f) = f |
UniformSpace.metricSpace | Mathlib.Topology.Metrizable.Uniformity | (X : Type u_2) → [inst : UniformSpace X] → [(uniformity X).IsCountablyGenerated] → [T0Space X] → MetricSpace X |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.State.mk.sizeOf_spec | Lean.Meta.Match.SimpH | ∀ (mvarId : Lean.MVarId) (xs eqs eqsNew : List Lean.FVarId),
sizeOf { mvarId := mvarId, xs := xs, eqs := eqs, eqsNew := eqsNew } =
1 + sizeOf mvarId + sizeOf xs + sizeOf eqs + sizeOf eqsNew |
AddEquiv.mulOp_symm_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_3} {β : Type u_4} [inst : Add α] [inst_1 : Add β] (f : αᵐᵒᵖ ≃+ βᵐᵒᵖ),
AddEquiv.mulOp.symm f = MulOpposite.opAddEquiv.trans (f.trans MulOpposite.opAddEquiv.symm) |
Lean.Data.AC.eval.eq_2 | Init.Data.AC | ∀ {α : Sort u_1} (β : Sort u) [inst : Lean.Data.AC.EvalInformation α β] (ctx : α) (l r : Lean.Data.AC.Expr),
Lean.Data.AC.eval β ctx (l.op r) =
Lean.Data.AC.EvalInformation.evalOp ctx (Lean.Data.AC.eval β ctx l) (Lean.Data.AC.eval β ctx r) |
_aux_Mathlib_Data_PFun___unexpand_PFun_1 | Mathlib.Data.PFun | Lean.PrettyPrinter.Unexpander |
FreeGroup.IsCyclicallyReduced.nil | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u}, FreeGroup.IsCyclicallyReduced [] |
CategoryTheory.Functor.homObjFunctor_map_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F G : CategoryTheory.Functor C D) {A A' : (CategoryTheory.Functor C (Type w))ᵒᵖ} (f : A ⟶ A')
(x : F.HomObj G (Opposite.unop A)) (X : C) (a : (Opposite.unop A').obj X),
((F.homObjFunctor G).map f x).app X a = x.app X (f.unop.app X a) |
AlgebraicGeometry.tilde.instModuleCarrierCarrierStalkAbPresheaf | Mathlib.AlgebraicGeometry.Modules.Tilde | {R : CommRingCat} →
(M : ModuleCat ↑R) →
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top ↑R)) → Module ↑R ↑((AlgebraicGeometry.tilde M).presheaf.stalk x) |
BitVec.instMod | Init.Data.BitVec.Basic | {n : ℕ} → Mod (BitVec n) |
Lean.Elab.Command.InductiveElabStep2.collectUsedFVars | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep2 → StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit |
Lean.Meta.Grind.Arith.Cutsat.isSupportedType | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | Lean.Expr → Lean.Meta.Grind.GoalM Bool |
UInt64.neg_one_shiftLeft_and_shiftLeft | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (-1) <<< b &&& a <<< b = a <<< b |
_private.Mathlib.CategoryTheory.Limits.Types.Pullbacks.0.CategoryTheory.Limits.Types.isPullback_iff._proof_1_4 | Mathlib.CategoryTheory.Limits.Types.Pullbacks | ∀ {X₁ X₂ X₃ X₄ : Type u_1} (t : X₁ ⟶ X₂) (r : X₂ ⟶ X₄) (l : X₁ ⟶ X₃) (b : X₃ ⟶ X₄)
(w : CategoryTheory.CategoryStruct.comp t r = CategoryTheory.CategoryStruct.comp l b),
(∀ (x₁ y₁ : X₁), t x₁ = t y₁ ∧ l x₁ = l y₁ → x₁ = y₁) →
(∀ (x₂ : X₂) (x₃ : X₃), r x₂ = b x₃ → ∃ x₁, t x₁ = x₂ ∧ l x₁ = x₃) → Function.Bijective fun x₁ => ⟨(t x₁, l x₁), ⋯⟩ |
List.zipWithM.match_1.congr_eq_1 | Init.Data.List.Monadic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (motive : List α → List β → Array γ → Sort u_4) (x : List α)
(x_1 : List β) (x_2 : Array γ)
(h_1 : (a : α) → (as : List α) → (b : β) → (bs : List β) → (acc : Array γ) → motive (a :: as) (b :: bs) acc)
(h_2 : (x : List α) → (x_3 : List β) → (acc : Array γ) → motive x x_3 acc) (a : α) (as : List α) (b : β) (bs : List β)
(acc : Array γ),
x = a :: as →
x_1 = b :: bs →
x_2 = acc →
(match x, x_1, x_2 with
| a :: as, b :: bs, acc => h_1 a as b bs acc
| x, x_3, acc => h_2 x x_3 acc) ≍
h_1 a as b bs acc |
intervalIntegral.integral_hasStrictDerivAt_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
ContinuousAt f b → HasStrictDerivAt (fun u => ∫ (x : ℝ) in a..u, f x) (f b) b |
CategoryTheory.CreatesLimitsOfSize.CreatesLimitsOfShape._autoParam | Mathlib.CategoryTheory.Limits.Creates | Lean.Syntax |
LinearMap.instLieRingModule._proof_1 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u_4} {L : Type u_2} {M : Type u_3} {N : Type u_1} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] [inst_7 : LieRingModule L N] (x : L) (f : M →ₗ[R] N) (m n : M),
⁅x, f (m + n)⁆ - f ⁅x, m + n⁆ = ⁅x, f m⁆ - f ⁅x, m⁆ + (⁅x, f n⁆ - f ⁅x, n⁆) |
CategoryTheory.FreeMonoidalCategory.Hom.recOn | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : (a a_1 : CategoryTheory.FreeMonoidalCategory C) → a.Hom a_1 → Sort u_1} →
{a a_1 : CategoryTheory.FreeMonoidalCategory C} →
(t : a.Hom a_1) →
((X : CategoryTheory.FreeMonoidalCategory C) → motive X X (CategoryTheory.FreeMonoidalCategory.Hom.id X)) →
((X Y Z : CategoryTheory.FreeMonoidalCategory C) →
motive ((X.tensor Y).tensor Z) (X.tensor (Y.tensor Z))
(CategoryTheory.FreeMonoidalCategory.Hom.α_hom X Y Z)) →
((X Y Z : CategoryTheory.FreeMonoidalCategory C) →
motive (X.tensor (Y.tensor Z)) ((X.tensor Y).tensor Z)
(CategoryTheory.FreeMonoidalCategory.Hom.α_inv X Y Z)) →
((X : CategoryTheory.FreeMonoidalCategory C) →
motive (CategoryTheory.FreeMonoidalCategory.unit.tensor X) X
(CategoryTheory.FreeMonoidalCategory.Hom.l_hom X)) →
((X : CategoryTheory.FreeMonoidalCategory C) →
motive X (CategoryTheory.FreeMonoidalCategory.unit.tensor X)
(CategoryTheory.FreeMonoidalCategory.Hom.l_inv X)) →
((X : CategoryTheory.FreeMonoidalCategory C) →
motive (X.tensor CategoryTheory.FreeMonoidalCategory.unit) X
(CategoryTheory.FreeMonoidalCategory.Hom.ρ_hom X)) →
((X : CategoryTheory.FreeMonoidalCategory C) →
motive X (X.tensor CategoryTheory.FreeMonoidalCategory.unit)
(CategoryTheory.FreeMonoidalCategory.Hom.ρ_inv X)) →
({X Y Z : CategoryTheory.FreeMonoidalCategory C} →
(f : X.Hom Y) → (g : Y.Hom Z) → motive X Y f → motive Y Z g → motive X Z (f.comp g)) →
((X : CategoryTheory.FreeMonoidalCategory C) →
{Y₁ Y₂ : CategoryTheory.FreeMonoidalCategory C} →
(f : Y₁.Hom Y₂) →
motive Y₁ Y₂ f →
motive (X.tensor Y₁) (X.tensor Y₂)
(CategoryTheory.FreeMonoidalCategory.Hom.whiskerLeft X f)) →
({X₁ X₂ : CategoryTheory.FreeMonoidalCategory C} →
(f : X₁.Hom X₂) →
(Y : CategoryTheory.FreeMonoidalCategory C) →
motive X₁ X₂ f → motive (X₁.tensor Y) (X₂.tensor Y) (f.whiskerRight Y)) →
({W X Y Z : CategoryTheory.FreeMonoidalCategory C} →
(f : W.Hom Y) →
(g : X.Hom Z) →
motive W Y f → motive X Z g → motive (W.tensor X) (Y.tensor Z) (f.tensor g)) →
motive a a_1 t |
_private.Init.Data.List.Impl.0.List.eraseIdxTR.go | Init.Data.List.Impl | {α : Type u_1} → List α → List α → ℕ → Array α → List α |
CategoryTheory.Cat.Hom.instCategory._proof_1 | Mathlib.CategoryTheory.Category.Cat | ∀ {X Y : CategoryTheory.Cat} {X_1 Y_1 : X ⟶ Y} (η : X_1 ⟶ Y_1),
CategoryTheory.NatTrans.toCatHom₂
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.NatTrans.toCatHom₂ (CategoryTheory.CategoryStruct.id X_1.toFunctor)).toNatTrans η.toNatTrans) =
CategoryTheory.NatTrans.toCatHom₂ η.toNatTrans |
BitVec.getElem_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {n start len : ℕ} {x : BitVec n} {i : ℕ} (h : i < len), (BitVec.extractLsb' start len x)[i] = x.getLsbD (start + i) |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd'_hom_app_hom₃ | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (a b n : ℤ)
(h : a + b = n) (X : CategoryTheory.Pretriangulated.Triangle C),
((CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd' C a b n h).hom.app X).hom₃ =
(CategoryTheory.shiftFunctorAdd' C a b n h).hom.app X.obj₃ |
Lean.Meta.mkSimpAttr | Lean.Meta.Tactic.Simp.Attr | Lean.Name → String → Lean.Meta.SimpExtension → autoParam Lean.Name Lean.Meta.mkSimpAttr._auto_1 → IO Unit |
Polynomial.lifts_and_degree_eq_and_monic | Mathlib.Algebra.Polynomial.Lifts | ∀ {R : Type u} [inst : Semiring R] {S : Type v} [inst_1 : Semiring S] {f : R →+* S} [Nontrivial S] {p : Polynomial S},
p ∈ Polynomial.lifts f → p.Monic → ∃ q, Polynomial.map f q = p ∧ q.degree = p.degree ∧ q.Monic |
AddSubmonoid.map._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_3}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid M), ∃ a ∈ ↑S, f a = 0 |
_private.Init.Data.List.Find.0.List.finIdxOf?_eq_pmap_idxOf?._simp_1_5 | Init.Data.List.Find | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) |
instCompactlyGeneratedSpaceSigma | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {ι : Type u} {X : ι → Type v} [inst : (i : ι) → TopologicalSpace (X i)] [∀ (i : ι), CompactlyGeneratedSpace (X i)],
CompactlyGeneratedSpace ((i : ι) × X i) |
Algebra.Etale.formallyEtale._autoParam | Mathlib.RingTheory.Etale.Basic | Lean.Syntax |
CategoryTheory.Over.iteratedSliceEquivOverMapIso._proof_6 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {X : T} {f g : CategoryTheory.Over X} (p : f ⟶ g)
{X_1 Y : CategoryTheory.Over f} (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp
((f.iteratedSliceForward.comp ((CategoryTheory.Over.map p.left).comp g.iteratedSliceBackward)).map f_1)
((fun h =>
CategoryTheory.Over.isoMk
(CategoryTheory.Over.isoMk
(CategoryTheory.Iso.refl
((f.iteratedSliceForward.comp ((CategoryTheory.Over.map p.left).comp g.iteratedSliceBackward)).obj
h).left.left)
⋯)
⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun h =>
CategoryTheory.Over.isoMk
(CategoryTheory.Over.isoMk
(CategoryTheory.Iso.refl
((f.iteratedSliceForward.comp ((CategoryTheory.Over.map p.left).comp g.iteratedSliceBackward)).obj
h).left.left)
⋯)
⋯)
X_1).hom
((CategoryTheory.Over.map p).map f_1) |
ZFSet.Insert.match_3 | Mathlib.SetTheory.ZFC.Basic | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (motive : Option (PSet.mk α A).Type → Prop) (o : Option (PSet.mk α A).Type),
(∀ (a : (PSet.mk α A).Type), motive (some a)) → (∀ (a : Unit), motive none) → motive o |
pNilradical | Mathlib.FieldTheory.IsPerfectClosure | (R : Type u_1) → [inst : CommSemiring R] → ℕ → Ideal R |
Finset.monoid._proof_2 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Monoid α] (s t : Finset α), ↑(s * t) = ↑s * ↑t |
Group.ofLeftAxioms._proof_2 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Mul G] [inst_1 : One G] (assoc : ∀ (a b c : G), a * b * c = a * (b * c)) (x : G),
npowRecAuto 0 x = 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.