name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.SplitEpi.ext_iff | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {X Y : C} {f : X ⟶ Y} {x y : CategoryTheory.SplitEpi f},
x = y ↔ x.section_ = y.section_ | null | true |
Pi.mulSingle_inv | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} [inst : DecidableEq I] [inst_1 : (i : I) → Group (f i)] (i : I) (x : f i),
Pi.mulSingle i x⁻¹ = (Pi.mulSingle i x)⁻¹ | null | true |
_private.Init.Data.List.Lemmas.0.List.singleton_eq_append_iff._simp_1_1 | Init.Data.List.Lemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Set.mulAction._proof_2 | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Monoid α] [inst_1 : MulAction α β] (x x_1 : Set α) (x_2 : Set β),
Set.image2 (fun x1 x2 => x1 • x2) (Set.image2 (fun x1 x2 => x1 * x2) x x_1) x_2 =
Set.image2 (fun x1 x2 => x1 • x2) x (Set.image2 (fun x1 x2 => x1 • x2) x_1 x_2) | null | false |
_private.Mathlib.Order.Interval.Set.WithBotTop.0.WithTop.preimage_coe_Ico._simp_1_1 | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico a b = Set.Ici a ∩ Set.Iio b | null | false |
String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.mk.noConfusion | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
{s : String.Slice} →
{P : Sort u} →
{currPos currPos' : s.Pos} → { currPos := currPos } = { currPos := currPos' } → (currPos ≍ currPos' → P) → P | null | false |
Real.isFiniteMeasure_restrict_Ioc | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ (x y : ℝ), MeasureTheory.IsFiniteMeasure (MeasureTheory.volume.restrict (Set.Ioc x y)) | null | true |
NatPow.noConfusionType | Init.Prelude | Sort u_1 → {α : Type u} → NatPow α → {α' : Type u} → NatPow α' → Sort u_1 | null | false |
NonUnitalSubsemiring.mem_inf | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {p p' : NonUnitalSubsemiring R} {x : R}, x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' | null | true |
HasSubset.mk._flat_ctor | Init.Core | {α : Type u} → (α → α → Prop) → HasSubset α | null | false |
AddEquiv.withZeroCongr_symm | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} [inst : Add α] [inst_1 : Add β] (e : α ≃+ β), e.withZeroCongr.symm = e.symm.withZeroCongr | null | true |
Submonoid.map_inl | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {N : Type u_2} [inst : MulOneClass N] {M : Type u_5} [inst_1 : MulOneClass M] (s : Submonoid M),
Submonoid.map (MonoidHom.inl M N) s = s.prod ⊥ | null | true |
Std.Async.Async.raceAll | Std.Async.Basic | {c : Type u_1} →
{α : Type} →
[ForM Std.Async.Async c (Std.Async.Async α)] → c → optParam Task.Priority Task.Priority.default → Std.Async.Async α | Runs all computations concurrently and returns the result of the first one to finish.
All other results are lost, and the tasks are not cancelled, so they'll continue their execution
until the end.
| true |
_private.Lean.Compiler.IR.ToIR.0.Lean.IR.ToIR.lowerAlt.match_1 | Lean.Compiler.IR.ToIR | (motive : Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.impure → Sort u_1) →
(a : Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.impure) →
((info : Lean.Compiler.LCNF.CtorInfo) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.Alt.ctorAlt info k ⋯... | null | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.ofZeros._proof_2 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {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₂) (hf₁ : S₁.f = 0) (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0)
(hg₂ : S₂.g = 0),
CategoryTheory.CategoryStruct.comp φ.τ₂ (CategoryTheory.ShortComplex.LeftHom... | null | false |
List.rec | Init.Prelude | {α : Type u} →
{motive : List α → Sort u_1} →
motive [] → ((head : α) → (tail : List α) → motive tail → motive (head :: tail)) → (t : List α) → motive t | null | false |
CartanMatrix.Realisation.eq_iff_forall_pairing_sRoot_eq | Mathlib.LinearAlgebra.Matrix.Cartan.Realisation | ∀ {n : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype n] [inst_1 : DecidableEq n]
[inst_2 : CommRing R] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N] [inst_6 : Module R N]
(rl : CartanMatrix.Realisation n R M N) [CharZero R] [IsDomain R] {y₁ y₂ : N},
y₁ - y₂ ∈ S... | null | true |
Lean.Lsp.instFromJsonMessageActionItem.fromJson | Lean.Data.Lsp.Window | Lean.Json → Except String Lean.Lsp.MessageActionItem | null | true |
AddEquiv.withBotCongr_toAddHom | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} {β : Type v} [inst : Add α] [inst_1 : Add β] (e : α ≃+ β), ↑e.withBotCongr = (↑e).withBotMap | null | true |
Algebra.PreSubmersivePresentation.ofAlgEquiv_toPresentation | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.PreSubmersivePresentation R S ι σ) {T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T]
(e : S ≃ₐ[R] T), (P.ofAlgEquiv e).toPresentation = P.ofAlgEquiv e | null | true |
Array.toListRev_iterM | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} [LawfulMonad m] {array : Array β},
(array.iterM m).toListRev = pure array.toListRev | null | true |
Choose.choose_modEq_prod_range_choose_nat | Mathlib.Data.Nat.Choose.Lucas | ∀ {n k p : ℕ} [Fact (Nat.Prime p)] {a : ℕ},
n < p ^ a → k < p ^ a → n.choose k ≡ ∏ i ∈ Finset.range a, (n / p ^ i % p).choose (k / p ^ i % p) [MOD p] | **Lucas's Theorem**: For primes `p`, `choose n k` is congruent to the product of
`choose (⌊n / p ^ i⌋ % p) (⌊k / p ^ i⌋ % p)` over `i` modulo `p`. | true |
Metric.cthickening_eq_iInter_cthickening' | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ},
∀ s ⊆ Set.Ioi δ,
(∀ (ε : ℝ), δ < ε → (s ∩ Set.Ioc δ ε).Nonempty) →
∀ (E : Set α), Metric.cthickening δ E = ⋂ ε ∈ s, Metric.cthickening ε E | null | true |
_private.Init.Grind.Ordered.Linarith.0.Lean.Grind.Linarith.le_norm._simp_1_2 | Init.Grind.Ordered.Linarith | ∀ {M : Type u} [self : Lean.Grind.AddCommGroup M] (a b : M), a + -b = a - b | null | false |
FractionalIdeal.coeIdeal_ne_one | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_3} [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
{I : Ideal R}, ↑I ≠ 1 ↔ I ≠ 1 | null | true |
mul_inv_le_iff₀' | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {G₀ : Type u_3} [inst : CommGroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a b c : G₀},
0 < c → (b * c⁻¹ ≤ a ↔ b ≤ c * a) | See `mul_inv_le_iff₀` for a version with multiplication on the other side. | true |
SheafOfModules.IsQuasicoherent.nonempty_quasicoherentData._autoParam | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | Lean.Syntax | null | false |
Prod.instAddCommGroupWithOne._proof_4 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : AddCommGroupWithOne R] [inst_1 : AddCommGroupWithOne S] (n : ℕ) (a : R × S),
Int.negSucc n • a = -(↑n.succ • a) | null | false |
Module.Baer.instSemilatticeInfExtensionOf | Mathlib.Algebra.Module.Injective | {R : Type u} →
[inst : Ring R] →
{Q : Type v} →
[inst_1 : AddCommGroup Q] →
[inst_2 : Module R Q] →
{M : Type u_1} →
{N : Type u_2} →
[inst_3 : AddCommGroup M] →
[inst_4 : AddCommGroup N] →
[inst_5 : Module R M] →
... | null | true |
Prod.instMeasurableSingletonClass | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} [MeasurableSingletonClass α]
[MeasurableSingletonClass β], MeasurableSingletonClass (α × β) | null | true |
Quaternion.imI_smul | Mathlib.Algebra.Quaternion | ∀ {S : Type u_1} {R : Type u_3} [inst : CommRing R] (a : Quaternion R) [inst_1 : SMul S R] (s : S),
(s • a).imI = s • a.imI | null | true |
Function.nontrivial | Mathlib.Basic.Nontrivial.Basic | ∀ {α : Type u_1} {β : Type u_2} [h : Nonempty α] [Nontrivial β], Nontrivial (α → β) | null | true |
_private.Init.Data.List.Lex.0.List.lex_trans.match_1_3 | Init.Data.List.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {b : α} {l₂ : List α} (motive : (l₃ : List α) → List.Lex r (b :: l₂) l₃ → Prop)
(l₃ : List α) (h₂ : List.Lex r (b :: l₂) l₃),
(∀ (a₂ : α) (l₂_1 : List α) (bc : r b a₂), motive (a₂ :: l₂_1) ⋯) →
(∀ (l₂_1 : List α) (ih : List.Lex r l₂ l₂_1), motive (b :: l₂_1) ⋯) → motive l₃ h₂ | null | false |
FirstOrder.Field.FieldAxiom | Mathlib.ModelTheory.Algebra.Field.Basic | Type | An indexing type to name each of the field axioms. The theory
of fields is defined as the range of a function `FieldAxiom ->
Language.ring.Sentence` | true |
_private.Mathlib.Data.Finset.SDiff.0.Finset.instGeneralizedBooleanAlgebra._proof_6 | Mathlib.Data.Finset.SDiff | ∀ {α : Type u_1} [inst : DecidableEq α] (a_1 b_1 : Finset α), a_1 ⊓ b_1 ⊓ a_1 \ b_1 = ⊥ | null | false |
IsFreeGroup.Generators | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | (G : Type u_1) → [inst : Group G] → [IsFreeGroup G] → Type u_1 | A set of generators of a free group, chosen arbitrarily | true |
Lean.Grind.CommRing.Stepwise.inv | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) (p₁ p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Stepwise.mul_cert p₁ (-1) p = true →
Lean.Grind.CommRing.Poly.denote ctx p₁ = 0 → Lean.Grind.CommRing.Poly.denote ctx p = 0 | null | true |
_private.Mathlib.LinearAlgebra.Span.Basic.0.Submodule.prod_sup_prod._simp_1_3 | Mathlib.LinearAlgebra.Span.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
Stream'.Seq.notMem_nil._simp_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (a : α), (a ∈ Stream'.Seq.nil) = False | null | false |
IsDiscreteValuationRing.quotient.eq_1 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_2} [inst : CommRing R] (x y : R),
IsDiscreteValuationRing.quotient x y = if y = 0 then 0 else if h : y ∣ x then Exists.choose h else 0 | null | true |
HahnModule.instZero._aux_1 | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_2} → {V : Type u_3} → [inst : PartialOrder Γ] → [inst_1 : SMul R V] → [inst_2 : Zero V] → HahnModule Γ R V | null | false |
RingCat.ringObj._aux_13 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J RingCat) → (j : J) → One ((F.comp (CategoryTheory.forget RingCat)).obj j) | null | false |
HomogeneousLocalization.awayMap | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
[inst_3 : AddCommMonoid ι] →
[inst_4 : DecidableEq ι] →
(𝒜 : ι → σ) →
[inst_5 : GradedRing 𝒜] →
... | Given `x = f * g` with `g` homogeneous of positive degree,
this is the map `A_{(f)} → A_{(x)}` taking `a/f^i` to `ag^i/(fg)^i`. | true |
Function.Injective.distribSMul | Mathlib.Algebra.GroupWithZero.Action.Defs | {M : Type u_1} →
{A : Type u_7} →
{B : Type u_9} →
[inst : AddZeroClass A] →
[inst_1 : DistribSMul M A] →
[inst_2 : AddZeroClass B] →
[inst_3 : SMul M B] →
(f : B →+ A) → Function.Injective ⇑f → (∀ (c : M) (x : B), f (c • x) = c • f x) → DistribSMul M B | Pullback a distributive scalar multiplication along an injective additive monoid
homomorphism.
See note [reducible non-instances]. | true |
CommRingCat.pushoutCoconeIsColimit._proof_5 | Mathlib.Algebra.Category.Ring.Constructions | ∀ (R A B : Type u_1) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B] [inst_3 : Algebra R A]
[inst_4 : Algebra R B]
(s : CategoryTheory.Limits.PushoutCocone (CommRingCat.ofHom (algebraMap R A)) (CommRingCat.ofHom (algebraMap R B))),
CategoryTheory.CategoryStruct.comp (CommRingCat.pushoutCocone R A ... | null | false |
PiTensorProduct.isEmptyEquiv._proof_5 | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ (ι : Type u_1) {R : Type u_2} [inst : CommSemiring R] {s : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] [inst_3 : IsEmpty ι] (c : R) (x : PiTensorProduct R fun i => s i),
(PiTensorProduct.lift (MultilinearMap.constOfIsEmpty R s 1)) (c • x) =
c • (PiTensorProduct.l... | null | false |
ContinuousMap.instMetrizableSpace | Mathlib.Topology.Metrizable.ContinuousMap | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [WeaklyLocallyCompactSpace X] [SigmaCompactSpace X]
[inst_3 : TopologicalSpace Y] [TopologicalSpace.MetrizableSpace Y], TopologicalSpace.MetrizableSpace C(X, Y) | null | true |
AlgebraicGeometry.instLocallyQuasiFiniteMorphismRestrict | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (V : Y.Opens) [AlgebraicGeometry.LocallyQuasiFinite f],
AlgebraicGeometry.LocallyQuasiFinite (f ∣_ V) | null | true |
CategoryTheory.Functor.lanCompIsoOfPreserves | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | {A : Type u_1} →
{B : Type u_2} →
{C : Type u_3} →
{D : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] ... | Commuting a functor that preserves left Kan extensions with the `lan` functor. | true |
_private.Mathlib.Topology.Category.Profinite.Nobeling.Successor.0.Profinite.NobelingProof.C0_projOrd._simp_1_2 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
ProbabilityTheory.Kernel.zero_prod | Mathlib.Probability.Kernel.Composition.Prod | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} (η : ProbabilityTheory.Kernel α γ), ProbabilityTheory.Kernel.prod 0 η = 0 | null | true |
Matrix.emptyRows_isTotallyUnimodular | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular | ∀ {m : Type u_1} {n : Type u_3} {R : Type u_5} [inst : CommRing R] [IsEmpty m] (A : Matrix m n R), A.IsTotallyUnimodular | If `A` has no rows, then it is totally unimodular. | true |
Complex.abs_arg_lt_pi_div_two_iff | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {z : ℂ}, |z.arg| < Real.pi / 2 ↔ 0 < z.re ∨ z = 0 | null | true |
Real.rpow_sub_intCast | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x : ℝ}, x ≠ 0 → ∀ (y : ℝ) (n : ℤ), x ^ (y - ↑n) = x ^ y / x ^ n | null | true |
Lean.Lsp.InlayHintTooltip.plaintext.injEq | Lean.Data.Lsp.LanguageFeatures | ∀ (text text_1 : String),
(Lean.Lsp.InlayHintTooltip.plaintext text = Lean.Lsp.InlayHintTooltip.plaintext text_1) = (text = text_1) | null | true |
CategoryTheory.GrothendieckTopology.MayerVietorisSquare.shortComplex | Mathlib.CategoryTheory.Sites.MayerVietorisSquare | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
[inst_1 : CategoryTheory.HasWeakSheafify J (Type v)] →
[CategoryTheory.HasSheafify J AddCommGrpCat] →
J.MayerVietorisSquare → CategoryTheory.ShortComplex (CategoryTheory.Sheaf J AddComm... | The short complex of abelian sheaves
`ℤ[S.X₁] ⟶ ℤ[S.X₂] ⊞ ℤ[S.X₃] ⟶ ℤ[S.X₄]`
where the left map is a difference and the right map a sum. | true |
Int.rec | Init.Data.Int.Basic | {motive : ℤ → Sort u} → ((a : ℕ) → motive (Int.ofNat a)) → ((a : ℕ) → motive (Int.negSucc a)) → (t : ℤ) → motive t | null | false |
BddDistLat.Iso.mk._proof_7 | Mathlib.Order.Category.BddDistLat | ∀ {α β : BddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat), e ⊤ = ⊤ | null | false |
HomotopicalAlgebra.instWeakEquivalenceMapOfIsWeakFactorizationSystemTrivialCofibrationsFibrations | Mathlib.AlgebraicTopology.ModelCategory.Instances | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[inst_2 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C]
{J : Type u_1} {X Y : J → C} (f : (i : J) → X i ⟶ Y i) [inst_4 : CategoryTheory.Limits... | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone.0.NumberField.mixedEmbedding.fundamentalCone.mem_idealSet._simp_1_8 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{I : FractionalIdeal S P} {x : P}, (x ∈ ↑I) = (x ∈ I) | null | false |
Sym2.mem_iff_mem._simp_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {x : α} {z : Sym2 α}, Sym2.Mem x z = (x ∈ z) | null | false |
Matrix.linfty_opNorm_eq_opNorm | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : NontriviallyNormedField α] [NormedAlgebra ℝ α] (A : Matrix m n α),
‖A‖ = ‖{ toLinearMap := A.mulVecLin, cont := ⋯ }‖ | null | true |
CategoryTheory.Equivalence.congrRight._proof_4 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_1, u_3} E]
(e : C ≌ D) {X Y : CategoryTheory.Functor E D} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((((CategoryTheory.Funct... | null | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_rco_eq_cons_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Lean.mkLitEx | Lean.Expr | Lean.Literal → Lean.Expr | null | true |
Topology.IsEmbedding.comapMetricSpace._proof_1 | Mathlib.Topology.MetricSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [m : MetricSpace β] (f : α → β),
Topology.IsEmbedding f → Function.Injective f | null | false |
MeasureTheory.VectorMeasure.transpose.eq_1 | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] (μ : MeasureTheory.VectorMeasure X F) (B : E →L[ℝ] F →... | null | true |
Lean.Parser.Tactic.MCasesPat.parse.goAlts | Std.Tactic.Do.Syntax | Lean.TSyntax `Lean.Parser.Tactic.mcasesPatAlts → Option Lean.Parser.Tactic.MCasesPat | null | true |
Subgroup.QuotientDiff._proof_4 | Mathlib.GroupTheory.SchurZassenhaus | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [inst_1 : IsMulCommutative ↥H] [inst_2 : H.FiniteIndex],
Equivalence fun α β => Subgroup.leftTransversals.diff (MonoidHom.id ↥H) α β = 1 | null | false |
PointwiseConvergenceCLM.seminorm._proof_4 | Mathlib.Analysis.LocallyConvex.PointwiseConvergence | ∀ {𝕜₁ : Type u_3} {𝕜₂ : Type u_4} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_2}
{F : Type u_1} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜₂ F] (x : E) (r : 𝕜₂) (A : E →SLₚₜ[σ] F),
... | null | false |
BoundedVariationOn.eVariationOn_Iic_eq_Iio_add_edist | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {M : Type u_3} [inst_1 : PseudoEMetricSpace M] [CompleteSpace M]
[DenselyOrdered α] {f : α → M} {a : α},
BoundedVariationOn f Set.univ →
eVariationOn f (Set.Iic a) = eVariationOn f (Set.Iio a) + edist (f a) (Function.leftLim f a) | null | true |
CategoryTheory.Presheaf.isLimitOfIsSheaf | Mathlib.CategoryTheory.Sites.Sheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{A : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] →
(J : CategoryTheory.GrothendieckTopology C) →
(P : CategoryTheory.Functor Cᵒᵖ A) →
{X : C} →
(S : J.Cover X) → CategoryTheory.Presheaf.IsS... | When `P` is a sheaf and `S` is a cover, the associated multifork is a limit. | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_roo_add_right_eq_map._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m : ℕ} (a : ℕ), ¬a + (m + 1) = a + m + 1 → False | null | false |
QuotientGroup.congr_mk' | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] (G' : Subgroup G) (H' : Subgroup H)
[inst_2 : G'.Normal] [inst_3 : H'.Normal] (e : G ≃* H) (he : Subgroup.map (↑e) G' = H') (x : G),
(QuotientGroup.congr G' H' e he) ((QuotientGroup.mk' G') x) = (QuotientGroup.mk' H') (e x) | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.psi_sub_theta_bounds._proof_1_6 | Mathlib.NumberTheory.Chebyshev | ∀ (N₁ N₂ N₃ N₅ N₇ : ℕ), N₂ ≤ 3 * (N₁ + N₂ + N₃ + N₅ + N₇) | null | false |
Complex.UnitDisc.instMulActionCircle._aux_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | Circle → Complex.UnitDisc → Complex.UnitDisc | null | false |
Turing.TM1to1.trNormal.eq_5 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {n : ℕ} (dec : List.Vector Bool n → Γ) (l : Γ → σ → Λ),
Turing.TM1to1.trNormal dec (Turing.TM1.Stmt.goto l) =
Turing.TM1to1.read dec fun a => Turing.TM1.Stmt.goto fun x s => Turing.TM1to1.Λ'.normal (l a s) | null | true |
AlgebraicGeometry.Scheme.Opens.ι.eq_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens), U.ι = X.ofRestrict ⋯ | null | true |
_private.Mathlib.Algebra.Group.Pointwise.Set.Card.0.Set.natCard_mul_le._simp_1_2 | Mathlib.Algebra.Group.Pointwise.Set.Card | ∀ {a b : Cardinal.{u_1}}, (a * b < Cardinal.aleph0) = (a = 0 ∨ b = 0 ∨ a < Cardinal.aleph0 ∧ b < Cardinal.aleph0) | null | false |
RBTree.RBMap.values | Batteries.Recycling.RBTree.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → RBTree.RBMap α β cmp → RBTree.RBMap.Values α β cmp | The "keys" of the map. This is an `O(1)` wrapper operation, which
can be used in `for` loops or converted to an array or list.
| true |
ContMDiffConstVAdd.mk._flat_ctor | Mathlib.Geometry.Manifold.Algebra.SMul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞}
{Γ : Type u_4} {M : Type u_5} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.good_vertices_triangle_card._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
_private.Mathlib.Data.Set.NAry.0.Set.image2_subset_iff_right._simp_1_2 | Mathlib.Data.Set.NAry | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
SSet.coherentIso.invStructHom | Mathlib.AlgebraicTopology.SimplicialSet.CoherentIso | SSet.coherentIso.hom.InvStruct | The forwards edge of `coherentIso` has an inverse. | true |
CategoryTheory.LaxFunctor.mapId' | Mathlib.CategoryTheory.Bicategory.Functor.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
(F : CategoryTheory.LaxFunctor B C) →
{b : B} →
(f : b ⟶ b) →
autoParam (f = CategoryTheory.CategoryStruct.id b) CategoryTheory.LaxFunctor.mapId'._auto_... | More flexible variant of `mapId`. (See the file `Bicategory.Functor.Strict`
for applications to strict bicategories.) | true |
CategoryTheory.Precoverage.small_subsheafify_of_small | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {K : CategoryTheory.Precoverage C}
{F : CategoryTheory.Functor Cᵒᵖ (Type w)},
(∀ ⦃X : C⦄, ∀ R ∈ K.coverings X, CategoryTheory.Presieve.IsSheafFor F R) →
∀ (𝒮 : (Z : C) → Set (F.obj (Opposite.op Z))),
(∀ (Z : C), Small.{max u v, w} ↑(𝒮 Z)) →
... | If `𝒮 Z` is `max u v`-small for every `Z`, then the subsheaf generated by `𝒮 Z` has
`max u v`-small sections. | true |
FundamentalGroupoid.map._proof_2 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y))
(x : FundamentalGroupoid X),
Path.Homotopic.Quotient.map (CategoryTheory.CategoryStruct.id x) f =
Path.Homotopic.Quotient.map (CategoryTheory.CategoryStruct.id x) f | null | false |
Matrix.mul_apply' | Mathlib.Data.Matrix.Mul | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {α : Type v} [inst : Fintype m] [inst_1 : Mul α]
[inst_2 : AddCommMonoid α] {M : Matrix l m α} {N : Matrix m n α} {i : l} {k : n}, (M * N) i k = M i ⬝ᵥ fun j => N j k | null | true |
Std.DHashMap.Internal.Raw₀.Const.get.congr_simp | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (m m_1 : Std.DHashMap.Internal.Raw₀ α fun x => β)
(e_m : m = m_1) (a a_1 : α) (e_a : a = a_1) (hma : m.contains a = true),
Std.DHashMap.Internal.Raw₀.Const.get m a hma = Std.DHashMap.Internal.Raw₀.Const.get m_1 a_1 ⋯ | null | true |
_private.Lean.Meta.Tactic.UnifyEq.0.Lean.Meta.toOffset?.match_1 | Lean.Meta.Tactic.UnifyEq | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) → ((k : ℕ) → motive (some k)) → (Unit → motive none) → motive __do_lift | null | false |
Function.RightInverse.comp | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β} {g : β → α} {h : β → γ} {i : γ → β},
Function.RightInverse f g → Function.RightInverse h i → Function.RightInverse (h ∘ f) (g ∘ i) | null | true |
CategoryTheory.Functor.Elements.Hom._sizeOf_inst | Mathlib.CategoryTheory.Elements | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C (Type w)} → (x y : F.Elements) → [SizeOf C] → SizeOf (x.Hom y) | null | false |
PrimeSpectrum.piLocalizationToMaximalEquiv._proof_1 | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {R : Type u_1} [inst : CommSemiring R] (h : ∀ (I : Ideal R), I.IsPrime → I.IsMaximal),
Function.LeftInverse
(⇑(RingHom.pi fun I => Pi.evalRingHom (fun i => Localization.AtPrime i.asIdeal) { asIdeal := I.1, isMaximal := ⋯ }))
(↑↑(PrimeSpectrum.piLocalizationToMaximal R).toRingHom).toFun | null | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic.0.AlgebraicGeometry.Proj.fromOfGlobalSections_preimage_basicOpen._simp_1_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
Lean.Meta.Grind.Params.config | Lean.Meta.Tactic.Grind.Main | Lean.Meta.Grind.Params → Lean.Grind.Config | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.ctorIdx | Batteries.Data.MLList.Basic | {m : Type u → Type u} → MLList.Spec✝ m → ℕ | null | false |
CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._aux_1 | Mathlib.CategoryTheory.Sites.Monoidal | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_4, u_1} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u_3) →
[inst_1 : CategoryTheory.Category.{u_2, u_3} A] →
[inst_2 : CategoryTheory.MonoidalCategory A] →
[inst_3 : J.W.IsMonoidal] →
[inst_4 : C... | null | false |
QuaternionAlgebra.equivTuple_symm_apply | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} (c₁ c₂ c₃ : R) (a : Fin 4 → R),
(QuaternionAlgebra.equivTuple c₁ c₂ c₃).symm a = { re := a 0, imI := a 1, imJ := a 2, imK := a 3 } | null | true |
Representation.linearizeTrivial_def | Mathlib.RepresentationTheory.Action | ∀ {k : Type u} {G : Type v} [inst : Monoid G] [inst_1 : Semiring k] (X : Type w) (g : G),
(Representation.linearize k G (Action.trivial G X)) g = LinearMap.id | null | true |
CategoryTheory.Localization.Construction.NatTransExtension.app_eq | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C} {D : Type uD}
[inst_1 : CategoryTheory.Category.{uD', uD} D] {F₁ F₂ : CategoryTheory.Functor W.Localization D}
(τ : W.Q.comp F₁ ⟶ W.Q.comp F₂) (X : C),
CategoryTheory.Localization.Construction.NatTransExtension.ap... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.