name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
MultilinearMap.currySumEquiv._proof_2 | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type u_1} {ι : Type u_2} {ι' : Type u_3} {M₂ : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : Module R M₂] {N : ι ⊕ ι' → Type u_4} [inst_3 : (i : ι ⊕ ι') → AddCommMonoid (N i)]
[inst_4 : (i : ι ⊕ ι') → Module R (N i)] (x y : MultilinearMap R N M₂), (x + y).currySum = x.currySum + y.currySum |
Polynomial.homogenize_eq_zero_iff | Mathlib.Algebra.Polynomial.Homogenize | ∀ {R : Type u_1} [inst : CommSemiring R] {p : Polynomial R} {n : ℕ}, p.natDegree ≤ n → (p.homogenize n = 0 ↔ p = 0) |
Polynomial.opRingEquiv.eq_1 | Mathlib.RingTheory.Polynomial.Opposites | ∀ (R : Type u_2) [inst : Semiring R],
Polynomial.opRingEquiv R =
((RingEquiv.op (Polynomial.toFinsuppIso R)).trans
(AddMonoidAlgebra.opRingEquiv.trans
(AddMonoidAlgebra.mapDomainRingEquiv Rᵐᵒᵖ AddOpposite.opAddEquiv.symm))).trans
(Polynomial.toFinsuppIso Rᵐᵒᵖ).symm |
Vector.getElem_eraseIdx_of_lt | Init.Data.Vector.Erase | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} (w : i < n) {j : ℕ} (h : j < n - 1) (h' : j < i),
(xs.eraseIdx i w)[j] = xs[j] |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Poly.0.Lean.Grind.CommRing.Mon.coprime.eq_def | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | ∀ (x x_1 : Lean.Grind.CommRing.Mon),
x.coprime x_1 =
match x, x_1 with
| Lean.Grind.CommRing.Mon.unit, x => true
| x, Lean.Grind.CommRing.Mon.unit => true
| Lean.Grind.CommRing.Mon.mult pw₁ m₁, Lean.Grind.CommRing.Mon.mult pw₂ m₂ =>
match compare pw₁.x pw₂.x with
| Ordering.eq => false
| Ordering.lt => m₁.coprime (Lean.Grind.CommRing.Mon.mult pw₂ m₂)
| Ordering.gt => (Lean.Grind.CommRing.Mon.mult pw₁ m₁).coprime m₂ |
CategoryTheory.Limits.HasZeroObject.uniqueTo._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C),
Nonempty (Unique (0 ⟶ X)) |
Std.ExtTreeMap.getKey!_maxKeyD | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α], t ≠ ∅ → ∀ {fallback : α}, t.getKey! (t.maxKeyD fallback) = t.maxKeyD fallback |
SheafOfModules.Presentation.mapRelations._proof_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] {C' : Type u_3}
[inst_4 : CategoryTheory.Category.{u_5, u_3} C'] {J' : CategoryTheory.GrothendieckTopology C'}
{S : CategoryTheory.Sheaf J' RingCat} {M : SheafOfModules R} (P : M.Presentation)
(F : CategoryTheory.Functor (SheafOfModules R) (SheafOfModules S))
[CategoryTheory.Limits.PreservesColimitsOfSize.{u_1, u_1, max u_1 u_2, max u_1 u_3, max (max (u_1 + 1) u_2) u_4,
max (max (u_1 + 1) u_3) u_5}
F],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete P.relations.I) F |
ZFSet.rank_sUnion_le | Mathlib.SetTheory.ZFC.Rank | ∀ (x : ZFSet.{u_1}), x.sUnion.rank ≤ x.rank |
List.pairwise_mergeSort | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool},
(∀ (a b c : α), le a b = true → le b c = true → le a c = true) →
(∀ (a b : α), (le a b || le b a) = true) → ∀ (l : List α), List.Pairwise (fun a b => le a b = true) (l.mergeSort le) |
HasDerivAt.eventually_notMem | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜},
HasDerivAt f f' x →
f' ≠ 0 → ∀ (t : Set F), ¬AccPt (f x) (Filter.principal t) → ∀ᶠ (z : 𝕜) in nhdsWithin x {x}ᶜ, f z ∉ t |
Lean.FileMap.lspRangeToUtf8Range | Lean.Data.Lsp.Utf16 | Lean.FileMap → Lean.Lsp.Range → Lean.Syntax.Range |
CategoryTheory.ComposableArrows.Exact.cokerIsoKer_hom_fac._proof_4 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ), autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.cokerIsoKer_hom_fac._auto_1 → k + 1 ≤ n + 3 |
CategoryTheory.Limits.limitCompWhiskeringLeftIsoCompLimit.eq_1 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{J : Type u₁} [inst_2 : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂}
[inst_3 : CategoryTheory.Category.{v₂, u₂} K] (F : CategoryTheory.Functor J (CategoryTheory.Functor K C))
(G : CategoryTheory.Functor D K) [inst_4 : CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.limitCompWhiskeringLeftIsoCompLimit F G =
CategoryTheory.NatIso.ofComponents
(fun j =>
CategoryTheory.Limits.limitObjIsoLimitCompEvaluation
(F.comp ((CategoryTheory.Functor.whiskeringLeft D K C).obj G)) j ≪≫
CategoryTheory.Limits.HasLimit.isoOfNatIso
(F.isoWhiskerLeft (CategoryTheory.whiskeringLeftCompEvaluation G j)) ≪≫
(CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F (G.obj j)).symm)
⋯ |
_private.Lean.Meta.Tactic.Grind.Arith.ModelUtil.0.Lean.Meta.Grind.Arith.pickUnusedValue.go | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Meta.Grind.Goal → Std.HashMap Lean.Expr ℚ → Lean.Expr → Std.HashSet ℤ → ℤ → ℤ |
separableClosureOperator | Mathlib.FieldTheory.SeparableClosure | (F : Type u) →
(E : Type v) →
[inst : Field F] → [inst_1 : Field E] → [inst_2 : Algebra F E] → ClosureOperator (IntermediateField F E) |
abs_mul_sign | Mathlib.Data.Sign.Basic | ∀ {α : Type u} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (x : α), |x| * ↑(SignType.sign x) = x |
PUnit.instAdd_mathlib.eq_1 | Mathlib.Algebra.Group.PUnit | PUnit.instAdd_mathlib = { add := fun x x_1 => PUnit.unit } |
TopologicalSpace.Opens.openPartialHomeomorphSubtypeCoe_target | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : TopologicalSpace.Opens X) (hs : Nonempty ↥s),
(s.openPartialHomeomorphSubtypeCoe hs).target = ↑s |
String.Pos.Raw.isValid_ofList | Init.Data.String.Basic | ∀ {l : List Char} {p : String.Pos.Raw},
String.Pos.Raw.IsValid (String.ofList l) p ↔ ∃ i, p.byteIdx = (String.ofList (List.take i l)).utf8ByteSize |
MeasureTheory.lintegral_edist_lt_top | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f g : α → β}, MeasureTheory.Integrable f μ → MeasureTheory.Integrable g μ → ∫⁻ (a : α), edist (f a) (g a) ∂μ < ⊤ |
_private.Lean.Data.Name.0.Lean.Name.quickCmpImpl.unsafe_1 | Lean.Data.Name | Lean.Name → Lean.Name → Bool |
_private.Lean.Meta.Tactic.Symm.0.Lean.Meta.Symm.initFn._sparseCasesOn_1._@.Lean.Meta.Tactic.Symm.3447505512._hygCtx._hyg.2 | Lean.Meta.Tactic.Symm | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t |
frattini_nongenerating | Mathlib.GroupTheory.Frattini | ∀ {G : Type u_1} [inst : Group G] [IsCoatomic (Subgroup G)] {K : Subgroup G}, K ⊔ frattini G = ⊤ → K = ⊤ |
Std.DHashMap.Raw.Const.getKeyD_modify | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k k' fallback : α} {f : β → β},
m.WF →
(Std.DHashMap.Raw.Const.modify m k f).getKeyD k' fallback =
if (k == k') = true then if k ∈ m then k else fallback else m.getKeyD k' fallback |
CategoryTheory.Limits.PreservesLimit₂.mk | Mathlib.CategoryTheory.Limits.Preserves.Bifunctor | ∀ {J₁ : Type u_1} {J₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} J₂] {C₁ : Type u_3} {C₂ : Type u_4} {C : Type u_5}
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₁] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₂]
[inst_4 : CategoryTheory.Category.{v_5, u_5} C] {K₁ : CategoryTheory.Functor J₁ C₁}
{K₂ : CategoryTheory.Functor J₂ C₂} {G : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C)},
(∀ {c₁ : CategoryTheory.Limits.Cone K₁} (hc₁ : CategoryTheory.Limits.IsLimit c₁) {c₂ : CategoryTheory.Limits.Cone K₂}
(hc₂ : CategoryTheory.Limits.IsLimit c₂), Nonempty (CategoryTheory.Limits.IsLimit (G.mapCone₂ c₁ c₂))) →
CategoryTheory.Limits.PreservesLimit₂ K₁ K₂ G |
Lean.LOption.ctorIdx | Lean.Data.LOption | {α : Type u} → Lean.LOption α → ℕ |
MeasureTheory.isMulLeftInvariant_smul_nnreal | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Mul G] {μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant]
(c : NNReal), (c • μ).IsMulLeftInvariant |
CategoryTheory.Adjunction.natIsoOfRightAdjointNatIso | Mathlib.CategoryTheory.Adjunction.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F F' : CategoryTheory.Functor C D} →
{G G' : CategoryTheory.Functor D C} → (F ⊣ G) → (F' ⊣ G') → (G ≅ G') → (F ≅ F') |
_private.Init.Data.Nat.Basic.0.Nat.zero_lt_of_ne_zero.match_1_1 | Init.Data.Nat.Basic | ∀ (motive : (a : ℕ) → a ≠ 0 → Prop) (a : ℕ) (h : a ≠ 0),
(∀ (h : 0 ≠ 0), motive 0 h) → (∀ (a : ℕ) (h : a + 1 ≠ 0), motive a.succ h) → motive a h |
AnalyticAt.rexp' | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E},
AnalyticAt ℝ f x → AnalyticAt ℝ (fun z => Real.exp (f z)) x |
List.Vector.mem_cons_self | Mathlib.Data.Vector.Mem | ∀ {α : Type u_1} {n : ℕ} (a : α) (v : List.Vector α n), a ∈ (a ::ᵥ v).toList |
_private.Std.Data.ExtHashMap.Basic.0.Std.ExtHashMap.instLawfulBEq.match_3 | Std.Data.ExtHashMap.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] [inst_1 : BEq β]
(inner : Std.ExtDHashMap α fun x => β) (motive : (b : Std.ExtHashMap α β) → ({ inner := inner } == b) = true → Prop)
(b : Std.ExtHashMap α β) (hyp : ({ inner := inner } == b) = true),
(∀ (inner_1 : Std.ExtDHashMap α fun x => β) (hyp : ({ inner := inner } == { inner := inner_1 }) = true),
motive { inner := inner_1 } hyp) →
motive b hyp |
RootPairing.chainBotCoeff.eq_1 | Mathlib.LinearAlgebra.RootSystem.Chain | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Finite ι] [inst_1 : CommRing R]
[inst_2 : CharZero R] [inst_3 : IsDomain R] [inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : AddCommGroup N]
[inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsCrystallographic] (i j : ι),
RootPairing.chainBotCoeff i j = if h : LinearIndependent R ![P.root i, P.root j] then (-⋯.choose).toNat else 0 |
Bundle.Pretrivialization.preimage_symm_proj_baseSet | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
(e : Bundle.Pretrivialization F proj), ↑e.symm ⁻¹' (proj ⁻¹' e.baseSet) ∩ e.target = e.target |
NonnegSpectrumClass.rec | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | {𝕜 : Type u_3} →
{A : Type u_4} →
[inst : CommSemiring 𝕜] →
[inst_1 : PartialOrder 𝕜] →
[inst_2 : NonUnitalRing A] →
[inst_3 : PartialOrder A] →
[inst_4 : Module 𝕜 A] →
{motive : NonnegSpectrumClass 𝕜 A → Sort u} →
((quasispectrum_nonneg_of_nonneg : ∀ (a : A), 0 ≤ a → ∀ x ∈ quasispectrum 𝕜 a, 0 ≤ x) → motive ⋯) →
(t : NonnegSpectrumClass 𝕜 A) → motive t |
_private.Mathlib.Geometry.Manifold.LocalInvariantProperties.0.OpenPartialHomeomorph.isLocalStructomorphWithinAt_source_iff._simp_1_1 | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True |
Real.arccos_le_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ (x : ℝ), Real.arccos x ≤ Real.pi |
_private.Mathlib.Algebra.Order.CauSeq.Basic.0.CauSeq.mul_pos.match_1_3 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {f g : CauSeq α abs}
(w w_1 : α) (motive : (∃ i, ∀ j ≥ i, w ≤ ↑f j ∧ w_1 ≤ ↑g j) → Prop) (x : ∃ i, ∀ j ≥ i, w ≤ ↑f j ∧ w_1 ≤ ↑g j),
(∀ (i : ℕ) (h : ∀ j ≥ i, w ≤ ↑f j ∧ w_1 ≤ ↑g j), motive ⋯) → motive x |
UInt64.add_left_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt64), -a + a = 0 |
Lean.Lsp.LeanClientCapabilities.noConfusionType | Lean.Data.Lsp.Capabilities | Sort u → Lean.Lsp.LeanClientCapabilities → Lean.Lsp.LeanClientCapabilities → Sort u |
sum_bernoulli' | Mathlib.NumberTheory.Bernoulli | ∀ (n : ℕ), ∑ k ∈ Finset.range n, ↑(n.choose k) * bernoulli' k = ↑n |
_private.Mathlib.Data.List.Chain.0.List.isChain_attachWith._proof_1_9 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {p : α → Prop} (head : α) (tail : List α),
(∀ x ∈ head :: tail, p x) → ∀ (a_1 : α), tail = [a_1] → ∀ a ∈ [a_1], p a |
Lean.MVarId.setFVarKind | Lean.MetavarContext | {m : Type → Type} → [Lean.MonadMCtx m] → Lean.MVarId → Lean.FVarId → Lean.LocalDeclKind → m Unit |
Mathlib.Meta.FunProp.Mor.instInhabitedArg.default | Mathlib.Tactic.FunProp.Mor | Mathlib.Meta.FunProp.Mor.Arg |
NumberField.ComplexEmbedding.unmixedEmbeddingsOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | {K : Type u_3} → (L : Type u_4) → [inst : Field K] → [inst_1 : Field L] → (K →+* ℂ) → [Algebra K L] → Set (L →+* ℂ) |
Fin.finsetImage_addNat_uIcc | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n),
Finset.image (fun x => x.addNat m) (Finset.uIcc i j) = Finset.uIcc (i.addNat m) (j.addNat m) |
IsSemisimpleModule.casesOn | Mathlib.RingTheory.SimpleModule.Basic | {R : Type u_2} →
[inst : Ring R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsSemisimpleModule R M → Sort u} →
(t : IsSemisimpleModule R M) →
([toComplementedLattice : ComplementedLattice (Submodule R M)] → motive ⋯) → motive t |
Lean.Elab.Do.ControlStack.mkContinue | Lean.Elab.Do.Control | Lean.Elab.Do.ControlStack → Lean.Elab.Do.DoElabM Lean.Expr |
_private.Mathlib.Algebra.Category.CoalgCat.Basic.0.CoalgCat.Hom.toCoalgHom_injective.match_1_1 | Mathlib.Algebra.Category.CoalgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] (V W : CoalgCat R) (f : ↑V.toModuleCat →ₗc[R] ↑W.toModuleCat)
(motive : (x : V.Hom W) → { toCoalgHom' := f }.toCoalgHom' = x.toCoalgHom' → Prop) (x : V.Hom W)
(x_1 : { toCoalgHom' := f }.toCoalgHom' = x.toCoalgHom'),
(∀ (g : ↑V.toModuleCat →ₗc[R] ↑W.toModuleCat)
(x : { toCoalgHom' := f }.toCoalgHom' = { toCoalgHom' := g }.toCoalgHom'), motive { toCoalgHom' := g } x) →
motive x x_1 |
CategoryTheory.Functor.mapMonFunctor._proof_2 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(D : Type u_2) [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{X Y : CategoryTheory.LaxMonoidalFunctor C D} (α : X ⟶ Y) (A : CategoryTheory.Mon C),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one (α.hom.app A.X) = CategoryTheory.MonObj.one |
Positive.instDistribSubtypeLtOfNat._proof_3 | Mathlib.Algebra.Order.Positive.Ring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R]
(a b c : { x // 0 < x }), (a + b) * c = a * c + b * c |
CategoryTheory.Limits.ker | Mathlib.CategoryTheory.Limits.Shapes.Kernels | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[CategoryTheory.Limits.HasKernels C] → CategoryTheory.Functor (CategoryTheory.Arrow C) C |
CategoryTheory.Idempotents.FunctorExtension₁.map._proof_2 | Mathlib.CategoryTheory.Idempotents.FunctorExtension | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D]
{F G : CategoryTheory.Functor C (CategoryTheory.Idempotents.Karoubi D)} (φ : F ⟶ G)
(x x_1 : CategoryTheory.Idempotents.Karoubi C) (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Idempotents.FunctorExtension₁.obj F).map f)
{ f := CategoryTheory.CategoryStruct.comp (F.map x_1.p).f (φ.app x_1.X).f, comm := ⋯ } =
CategoryTheory.CategoryStruct.comp
{ f := CategoryTheory.CategoryStruct.comp (F.map x.p).f (φ.app x.X).f, comm := ⋯ }
((CategoryTheory.Idempotents.FunctorExtension₁.obj G).map f) |
Stream'.Seq.nil | Mathlib.Data.Seq.Defs | {α : Type u} → Stream'.Seq α |
HahnSeries.instAdd | Mathlib.RingTheory.HahnSeries.Addition | {Γ : Type u_1} → {R : Type u_3} → [inst : PartialOrder Γ] → [inst_1 : AddMonoid R] → Add (HahnSeries Γ R) |
NumberField.ComplexEmbedding.IsConj | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | {K : Type u_1} →
[inst : Field K] → {k : Type u_2} → [inst_1 : Field k] → [inst_2 : Algebra k K] → (K →+* ℂ) → Gal(K/k) → Prop |
Tactic.ComputeAsymptotics.Seq.FriendlyOperationClass.mk | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} {γ : Type u_3} {F : γ → Stream'.Seq α → Stream'.Seq α},
(∀ (c : γ), Tactic.ComputeAsymptotics.Seq.FriendlyOperation (F c)) →
Tactic.ComputeAsymptotics.Seq.FriendlyOperationClass F |
Ordinal.right_eq_zero_of_add_eq_zero | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {a b : Ordinal.{u_4}}, a + b = 0 → b = 0 |
NNReal.range_coe | Mathlib.Data.NNReal.Basic | Set.range NNReal.toReal = Set.Ici 0 |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.finitelyAtomistic | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[LieAlgebra.IsSemisimple R L] (s : Finset (LieIdeal R L)), ↑s ⊆ {I | IsAtom I} → ∀ I ≤ s.sup id, ∃ t ⊆ s, I = t.sup id |
Array.some_getElem_eq_getElem?_iff | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (xs : Array α) (i : ℕ) (h : i < xs.size), some xs[i] = xs[i]? ↔ True |
_private.Mathlib.Data.ENat.Basic.0.ENat.top_ne_coe.match_1_1 | Mathlib.Data.ENat.Basic | ∀ (a : ℕ) (motive : ⊤ = ↑a → Prop) (a : ⊤ = ↑a), motive a |
Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight.go_get._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | ∀ {w : ℕ} (distance curr idx : ℕ), idx < w - distance % w → distance % w + idx < w |
TopCat.Presheaf.pushforwardToOfIso.eq_1 | Mathlib.Topology.Sheaves.Presheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : TopCat.Presheaf C Y}
{𝒢 : TopCat.Presheaf C X} (H₂ : ℱ ⟶ (TopCat.Presheaf.pushforward C H₁.hom).obj 𝒢),
TopCat.Presheaf.pushforwardToOfIso H₁ H₂ =
((TopCat.Presheaf.presheafEquivOfIso C H₁.symm).toAdjunction.homEquiv ℱ 𝒢).symm H₂ |
Std.TransCmp.mk | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [toOrientedCmp : Std.OrientedCmp cmp],
(∀ {a b c : α}, (cmp a b).isLE = true → (cmp b c).isLE = true → (cmp a c).isLE = true) → Std.TransCmp cmp |
CStarMatrix.instModule | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} →
{n : Type u_2} →
{R : Type u_3} →
{A : Type u_5} → [inst : Semiring R] → [inst_1 : AddCommMonoid A] → [Module R A] → Module R (CStarMatrix m n A) |
Bundle.Trivialization.prod._proof_1 | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u_1} [inst : TopologicalSpace B] {F₁ : Type u_5} [inst_1 : TopologicalSpace F₁] {E₁ : B → Type u_2}
[inst_2 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [inst_3 : TopologicalSpace F₂]
{E₂ : B → Type u_3} [inst_4 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
(e₁ : Bundle.Trivialization F₁ Bundle.TotalSpace.proj) (e₂ : Bundle.Trivialization F₂ Bundle.TotalSpace.proj),
IsOpen (Bundle.TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) |
CategoryTheory.MorphismProperty.IsStableUnderBaseChange.monomorphisms | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C],
(CategoryTheory.MorphismProperty.monomorphisms C).IsStableUnderBaseChange |
ne_of_ne_of_eq' | Mathlib.Tactic.Positivity.Core | ∀ {α : Sort u_1} {a c b : α}, a ≠ c → a = b → b ≠ c |
UInt8.lt_of_lt_of_le | Init.Data.UInt.Lemmas | ∀ {a b c : UInt8}, a < b → b ≤ c → a < c |
_private.Init.Data.Rat.Lemmas.0.Rat.le_iff_lt_or_eq._simp_1_1 | Init.Data.Rat.Lemmas | ∀ (a b : ℚ), (a ≤ b) = (a.num * ↑b.den ≤ b.num * ↑a.den) |
Std.Do.ExceptConds.imp | Std.Do.PostCond | {ps : Std.Do.PostShape} → Std.Do.ExceptConds ps → Std.Do.ExceptConds ps → Std.Do.ExceptConds ps |
T5Space | Mathlib.Topology.Separation.Regular | (X : Type u) → [TopologicalSpace X] → Prop |
NumberField.InfinitePlace.embedding_of_isReal._proof_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] {w : NumberField.InfinitePlace K},
w.IsReal → NumberField.ComplexEmbedding.IsReal w.embedding |
Submodule.Quotient.module'._proof_5 | Mathlib.LinearAlgebra.Quotient.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {S : Type u_3}
[inst_3 : Semiring S] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M] (P : Submodule R M)
(x : M ⧸ P), 0 • x = 0 |
EMetric.tendsto_nhds | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] {f : Filter β} {u : β → α} {a : α},
Filter.Tendsto u f (nhds a) ↔ ∀ ε > 0, ∀ᶠ (x : β) in f, edist (u x) a < ε |
IsCompact.isClosed_image_restrict | Mathlib.Topology.IsClosedRestrict | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ((i : ι) → α i)} [inst : (i : ι) → TopologicalSpace (α i)] (S : Set ι),
IsCompact s → IsClosed s → IsClosed (S.restrict '' s) |
IsCompact.elim_directed_cover | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} {ι : Type v} [hι : Nonempty ι],
IsCompact s →
∀ (U : ι → Set X), (∀ (i : ι), IsOpen (U i)) → s ⊆ ⋃ i, U i → Directed (fun x1 x2 => x1 ⊆ x2) U → ∃ i, s ⊆ U i |
UpperSet.compl_map | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) (s : UpperSet α),
((UpperSet.map f) s).compl = (LowerSet.map f) s.compl |
BooleanAlgebra.himp_eq._autoParam | Mathlib.Order.BooleanAlgebra.Defs | Lean.Syntax |
SimpleGraph.isClique_map_iff_of_nontrivial | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {f : α ↪ β} {t : Set β},
t.Nontrivial → ((SimpleGraph.map (⇑f) G).IsClique t ↔ ∃ s, G.IsClique s ∧ ⇑f '' s = t) |
CategoryTheory.Grothendieck.preEquivalence._simp_1 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) |
List.bidirectionalRec.eq_2 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} {motive : List α → Sort u_2} (nil : motive []) (singleton : (a : α) → motive [a])
(cons_append : (a : α) → (l : List α) → (b : α) → motive l → motive (a :: (l ++ [b]))) (a : α),
List.bidirectionalRec nil singleton cons_append [a] = singleton a |
DihedralGroup.oddCommuteEquiv.match_7 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (motive : ZMod n ⊕ ZMod n ⊕ ZMod n ⊕ ZMod n × ZMod n → Prop) (x : ZMod n ⊕ ZMod n ⊕ ZMod n ⊕ ZMod n × ZMod n),
(∀ (val : ZMod n), motive (Sum.inl val)) →
(∀ (val : ZMod n), motive (Sum.inr (Sum.inl val))) →
(∀ (k : ZMod n), motive (Sum.inr (Sum.inr (Sum.inl k)))) →
(∀ (fst snd : ZMod n), motive (Sum.inr (Sum.inr (Sum.inr (fst, snd))))) → motive x |
Finsupp.subset_mapRange_neLocus | Mathlib.Data.Finsupp.NeLocus | ∀ {α : Type u_1} {M : Type u_2} {N : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq N] [inst_2 : Zero N]
[inst_3 : DecidableEq M] [inst_4 : Zero M] (f g : α →₀ N) {F : N → M} (F0 : F 0 = 0),
(Finsupp.mapRange F F0 f).neLocus (Finsupp.mapRange F F0 g) ⊆ f.neLocus g |
CategoryTheory.ShortComplex.ShortExact.injective_f | Mathlib.Algebra.Homology.ShortComplex.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[inst_3 : CategoryTheory.HasForget₂ C Ab] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : (CategoryTheory.forget₂ C Ab).Additive] [(CategoryTheory.forget₂ C Ab).PreservesHomology]
{S : CategoryTheory.ShortComplex C} [CategoryTheory.Limits.HasZeroObject C],
S.ShortExact → Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.forget₂ C Ab).map S.f)) |
List.span.loop._sunfold | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → List α → List α × List α |
Units.instRepr.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] [inst_1 : Repr α], Units.instRepr = { reprPrec := reprPrec ∘ Units.val } |
Real.exists_int_int_abs_mul_sub_le | Mathlib.NumberTheory.DiophantineApproximation.Basic | ∀ (ξ : ℝ) {n : ℕ}, 0 < n → ∃ j k, 0 < k ∧ k ≤ ↑n ∧ |↑k * ξ - ↑j| ≤ 1 / (↑n + 1) |
Complex.circleIntegral_sub_center_inv_smul_of_differentiable_on_off_countable | Mathlib.Analysis.Complex.CauchyIntegral | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [CompleteSpace E] {R : ℝ},
0 < R →
∀ {f : ℂ → E} {c : ℂ} {s : Set ℂ},
s.Countable →
ContinuousOn f (Metric.closedBall c R) →
(∀ z ∈ Metric.ball c R \ s, DifferentiableAt ℂ f z) →
∮ (z : ℂ) in C(c, R), (z - c)⁻¹ • f z = (2 * ↑Real.pi * Complex.I) • f c |
CochainComplex.Plus._proof_1 | Mathlib.Algebra.Homology.CochainComplexPlus | IsRightCancelAdd ℤ |
Lean.Meta.Grind.PreInstance.mk.injEq | Lean.Meta.Tactic.Grind.Types | ∀ (proof : Lean.Expr) (assignment : Array Lean.Expr) (proof_1 : Lean.Expr) (assignment_1 : Array Lean.Expr),
({ proof := proof, assignment := assignment } = { proof := proof_1, assignment := assignment_1 }) =
(proof = proof_1 ∧ assignment = assignment_1) |
Multiset.sum_zero | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {M : Type u_3} [inst : AddCommMonoid M], Multiset.sum 0 = 0 |
LinearMap.map_dfinsuppSumAddHom | Mathlib.LinearAlgebra.DFinsupp | ∀ {R : Type u_7} {R₂ : Type u_8} {M : Type u_9} {M₂ : Type u_10} {ι : Type u_11} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {σ₁₂ : R →+* R₂} [inst_4 : Module R M]
[inst_5 : Module R₂ M₂] {γ : ι → Type u_12} [inst_6 : DecidableEq ι] [inst_7 : (i : ι) → AddZeroClass (γ i)]
(f : M →ₛₗ[σ₁₂] M₂) {t : Π₀ (i : ι), γ i} {g : (i : ι) → γ i →+ M},
f ((DFinsupp.sumAddHom g) t) = (DFinsupp.sumAddHom fun i => f.toAddMonoidHom.comp (g i)) t |
MeasureTheory.isSetAlgebra_generateSetAlgebra | Mathlib.MeasureTheory.SetAlgebra | ∀ {α : Type u_1} {𝒜 : Set (Set α)}, MeasureTheory.IsSetAlgebra (MeasureTheory.generateSetAlgebra 𝒜) |
Lean.Grind.CommRing.Expr.denoteSAsRing | Init.Grind.Ring.CommSemiringAdapter | {α : Type u_1} →
[inst : Lean.Grind.Semiring α] →
Lean.Grind.CommRing.Context α → Lean.Grind.CommRing.Expr → Lean.Grind.Ring.OfSemiring.Q α |
NonarchAddGroupNorm.coe_le_coe._simp_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p q : NonarchAddGroupNorm E}, (⇑p ≤ ⇑q) = (p ≤ q) |
Homeomorph.mulRight.congr_simp | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : SeparatelyContinuousMul G] (a a_1 : G),
a = a_1 → Homeomorph.mulRight a = Homeomorph.mulRight a_1 |
Lean.Parser.Command.whereStructInst.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.