name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.SplitEpi.mk.congr_simp | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y} (section_ section__1 : Y ⟶ X)
(e_section_ : section_ = section__1)
(id : CategoryTheory.CategoryStruct.comp section_ f = CategoryTheory.CategoryStruct.id Y),
{ section_ := section_, id := id } = { section_ := section__1, id := ⋯ } | null | true |
UniformFun.instPseudoMetricSpaceOfBoundedSpace._proof_1 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace β] (x x_1 : UniformFun α β),
0 ≤ ⨆ i, dist (UniformFun.toFun x i) (UniformFun.toFun x_1 i) | null | false |
instCoeTCSpectralMapOfSpectralMapClass | Mathlib.Topology.Spectral.Hom | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : FunLike F α β] → [SpectralMapClass F α β] → CoeTC F (SpectralMap α β) | null | true |
Lean.instInhabitedLiteral.default | Lean.Expr | Lean.Literal | null | true |
MonoidHom.toMulEquiv_symm_apply | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) (g : N →* M)
(h₁ : g.comp f = MonoidHom.id M) (h₂ : f.comp g = MonoidHom.id N), ⇑(f.toMulEquiv g h₁ h₂).symm = ⇑g | null | true |
eq_rec_inj | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {a a' : α} (h : a = a') {C : α → Type u_3} (x y : C a), h ▸ x = h ▸ y ↔ x = y | null | true |
equicontinuousWithinAt_finite | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] [Finite ι]
{F : ι → X → α} {S : Set X} {x₀ : X}, EquicontinuousWithinAt F S x₀ ↔ ∀ (i : ι), ContinuousWithinAt (F i) S x₀ | null | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.MatcherKey.mk.sizeOf_spec | Lean.Meta.Match.Match | ∀ (value : Lean.Expr) (compile isPrivate : Bool),
sizeOf { value := value, compile := compile, isPrivate := isPrivate } =
1 + sizeOf value + sizeOf compile + sizeOf isPrivate | null | true |
ContinuousMap.starMul._proof_1 | Mathlib.Topology.ContinuousMap.Star | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Mul β]
[inst_3 : ContinuousMul β] [inst_4 : StarMul β] [inst_5 : ContinuousStar β] (x x_1 : C(α, β)),
star (x * x_1) = star x_1 * star x | null | false |
SimpleGraph.Walk.getLast_support | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {a b : V} (p : G.Walk a b), p.support.getLast ⋯ = b | null | true |
CategoryTheory.Limits.BinaryBicone.IsBilimit.isColimit | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q : C} →
{b : CategoryTheory.Limits.BinaryBicone P Q} → b.IsBilimit → CategoryTheory.Limits.IsColimit b.toCocone | Structure witnessing that a binary bicone is a limit cone and a limit cocone. | true |
Filter.comk._proof_3 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (p : Set α → Prop),
(∀ (t : Set α), p t → ∀ s ⊆ t, p s) → ∀ {x y : Set α}, x ∈ {t | p tᶜ} → x ⊆ y → p yᶜ | null | false |
TrivSqZeroExt.instL1NormedRing._proof_3 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : NormedRing R] [inst_1 : NormedAddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [inst_4 : IsBoundedSMul R M] [inst_5 : IsBoundedSMul Rᵐᵒᵖ M]
[inst_6 : SMulCommClass R Rᵐᵒᵖ M] (a b : TrivSqZeroExt R M), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
String.isEmpty_sliceFrom._simp_1 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String} {p : s.Pos}, ((s.sliceFrom p).isEmpty = true) = (p = s.endPos) | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorHom.match_1.eq_5 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (motive : (x₁ y₁ x₂ y₂ : AugmentedSimplexCategory) → (x₁ ⟶ y₁) → (x₂ ⟶ y₂) → Sort u_1) (a a_1 : SimplexCategory)
(f₁ : CategoryTheory.WithInitial.of a ⟶ CategoryTheory.WithInitial.of a_1)
(x : CategoryTheory.WithInitial.star ⟶ CategoryTheory.WithInitial.star)
(h_1 :
(a a_2 a_3 a_4 : SimplexCategory) →
... | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.isOffsetPattern?.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.Expr → Sort u_1) →
(k : Lean.Expr) → ((k : ℕ) → motive (Lean.Expr.lit (Lean.Literal.natVal k))) → ((x : Lean.Expr) → motive x) → motive k | null | false |
USize.lt_irrefl | Init.Data.UInt.Lemmas | ∀ (a : USize), ¬a < a | null | true |
_private.Std.Http.Protocol.H1.Parser.0.Std.Http.Protocol.H1.sp | Std.Http.Protocol.H1.Parser | Std.Internal.Parsec.ByteArray.Parser Unit | Parses a single space (SP, 0x20).
| true |
CommRingCat.tensorProd._proof_2 | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ (R S : CommRingCat) [inst : Algebra ↑R ↑S] (X : CategoryTheory.Under R),
(Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (CommRingCat.toAlgHom (CategoryTheory.CategoryStruct.id X))).toUnder =
CategoryTheory.CategoryStruct.id (S.mkUnder (TensorProduct ↑R ↑S ↑X.right)) | null | false |
MulOpposite.instGroup._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Group α] (x : αᵐᵒᵖ), x⁻¹ * x = 1 | null | false |
CategoryTheory.GrothendieckTopology.yonedaEquiv_symm_naturality_right | Mathlib.CategoryTheory.Sites.Subcanonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical] (X : C) {F F' : CategoryTheory.Sheaf J (Type v)} (f : F ⟶ F')
(x : F.obj.obj (Opposite.op X)),
CategoryTheory.CategoryStruct.comp (J.yonedaEquiv.symm x) f =
J.yonedaEquiv.symm ((Categ... | null | true |
Polynomial.quo_add_sum_rem_mul_pow_inverse_unique | Mathlib.Algebra.Polynomial.PartialFractions | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : CommRing K] [inst_2 : Algebra (Polynomial R) K]
[FaithfulSMul (Polynomial R) K] {ι : Type u_3} {s : Finset ι} {g : ι → Polynomial R},
(∀ i ∈ s, (g i).Monic) →
((↑s).Pairwise fun i j => IsCoprime (g i) (g j)) →
∀ {n : ι → ℕ} {gi : ι → K},
... | Let `R` be a commutative ring and `f : R[X]`. Let `s` be a finite index set.
Let `g i` be a collection of monic and pairwise coprime polynomials indexed by `s`,
and for each `g i` let `n i` be a natural number.
Let `K` be an algebra over `R[X]` containing inverses `gi i` for each `g i`.
Then a fraction of the form `f *... | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify.0.Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr.of.go.match_6 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify | (motive : Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr → Sort u_1) →
(__x : Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr) →
((rhs : Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr) → motive (some rhs)) →
((x : Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr) → motive x) → moti... | null | false |
MeasureTheory.Measure.ae_sum_eq | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} [Countable ι] (μ : ι → MeasureTheory.Measure α),
MeasureTheory.ae (MeasureTheory.Measure.sum μ) = ⨆ i, MeasureTheory.ae (μ i) | null | true |
CategoryTheory.Functor.isContinuous_id | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C),
(CategoryTheory.Functor.id C).IsContinuous J J | null | true |
_private.Mathlib.Analysis.Seminorm.0.Seminorm.preimage_metric_ball._simp_1_3 | Mathlib.Analysis.Seminorm | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.ball 0 r) = (‖a‖ < r) | null | false |
RootPairing.GeckConstruction.equivRootSystem._proof_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | (3 + 1).AtLeastTwo | null | false |
SimpleGraph.eq_singletonSubgraph_iff_verts_eq | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (H : G.Subgraph) {v : V}, H = G.singletonSubgraph v ↔ H.verts = {v} | null | true |
WithTop.preimage_coe_Ioi | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithTop.some ⁻¹' Set.Ioi ↑a = Set.Ioi a | null | true |
CategoryTheory.MorphismProperty.Comma.mapLeftId._proof_5 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
(L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory... | null | false |
TotallyBounded.image | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : UniformSpace β] {f : α → β} {s : Set α},
TotallyBounded s → UniformContinuous f → TotallyBounded (f '' s) | The image of a totally bounded set under a uniformly continuous map is totally bounded. | true |
TestFunction.instAdd._proof_3 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (f g : TestFunction Ω F n),
(tsupport fun x => f x + g x) ⊆ ↑Ω | null | false |
dimH_iUnion | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {X : Type u_2} [inst : EMetricSpace X] {ι : Sort u_4} [Countable ι] (s : ι → Set X), dimH (⋃ i, s i) = ⨆ i, dimH (s i) | null | true |
Subgroup.instMulActionQuotientDiff._proof_5 | Mathlib.GroupTheory.SchurZassenhaus | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [inst_1 : IsMulCommutative ↥H] [inst_2 : H.FiniteIndex]
[inst_3 : H.Normal] (g₁ g₂ : G) (q : H.QuotientDiff), (g₁ * g₂) • q = g₁ • g₂ • q | null | false |
UInt8.instNonUnitalCommRing | Mathlib.Data.UInt | NonUnitalCommRing UInt8 | null | true |
IsRightRegular.subsingleton | Mathlib.Algebra.GroupWithZero.Regular | ∀ {R : Type u_1} [inst : MulZeroClass R], IsRightRegular 0 → Subsingleton R | The element `0` is right-regular if and only if `R` is trivial. | true |
LinearMap.compl₁₂ | Mathlib.LinearAlgebra.BilinearMap | {R₁ : Type u_3} →
{R₂ : Type u_4} →
[inst : Semiring R₁] →
[inst_1 : Semiring R₂] →
{Mₗ : Type u_6} →
{N : Type u_7} →
{Pₗ : Type u_9} →
{Qₗ : Type u_10} →
{Qₗ' : Type u_11} →
[inst_2 : AddCommMonoid Mₗ] →
[ins... | Composing linear maps `Q → M` and `Q' → N` with a bilinear map `M → N → P` to
form a bilinear map `Q → Q' → P`. | true |
AddSubmonoid.center.addCommMonoid'._proof_3 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : AddZeroClass M] (a b c : ↥(AddSubsemigroup.center M)), a + b + c = a + (b + c) | null | false |
CategoryTheory.Limits.Bicone.toCoconeFunctor._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {x x_1 : CategoryTheory.Limits.Bicone F}
(F_1 : x ⟶ x_1) (x_2 : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (x.ι x_2.as) F_1.hom = x_1.ι x_2.as | null | false |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.withProtectedMCtx.main | Lean.Meta.Tactic.Grind.Main | {m : Type → Type} →
{α : Type} →
[Monad m] →
[MonadControlT Lean.MetaM m] →
[MonadLiftT Lean.MetaM m] → Lean.Grind.Config → (Lean.MVarId → m α) → Lean.MVarId → m α | null | true |
NumberField.RingOfIntegers.instAlgebra_1._proof_1 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] (r : NumberField.RingOfIntegers K) (x : K),
(NumberField.RingOfIntegers.instAlgebra._aux_3 K) r * x = x * (NumberField.RingOfIntegers.instAlgebra._aux_3 K) r | null | false |
Std.DTreeMap.Internal.Impl.Const.minKey_alter_eq_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α] (h : t.WF)
{k : α} {f : Option β → Option β} {he : (Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl.isEmpty = false},
(Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl.minKey he = k ↔
(f (Std.DT... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_not._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, ¬2 ^ w - 1 - x.toNat < 2 ^ w → False | null | false |
CategoryTheory.RingObjCat.forget | Mathlib.CategoryTheory.Monoidal.Ring | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Functor (CategoryTheory.RingObjCat C) C | The forgetful functor from the category of ring objects in `C` to `C`. | true |
AlgebraicGeometry.Scheme.AffineCover.mk.inj | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {S : AlgebraicGeometry.Scheme} {I₀ : Type v}
{X : I₀ → CommRingCat} {f : (j : I₀) → AlgebraicGeometry.Spec (X j) ⟶ S} {idx : ↥S → I₀}
{covers : ∀ (x : ↥S), x ∈ Set.range ⇑(f (idx x))}
{map_prop : autoParam (∀ (j : I₀), P (f j)) AlgebraicGeometry.Sch... | null | true |
_private.Mathlib.Data.Option.NAry.0.Option.map_map₂_antidistrib_left._proof_1_1 | Mathlib.Data.Option.NAry | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_2} {δ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β}
{β' : Type u_5} {g : γ → δ} {f' : β' → α → δ} {g' : β → β'},
(∀ (a : α) (b : β), g (f a b) = f' (g' b) a) → Option.map g (Option.map₂ f a b) = Option.map₂ f' (Option.map g' b) a | null | false |
CompactlySupportedContinuousMap.semilatticeSup._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : SemilatticeSup β] [inst_2 : Zero β]
[inst_3 : TopologicalSpace β] [inst_4 : ContinuousSup β] (a b : CompactlySupportedContinuousMap α β),
b ≤ { toFun := ⇑a ⊔ ⇑b, continuous_toFun := ⋯, hasCompactSupport' := ⋯ } | null | false |
OrderIso.setIsotypicComponents._proof_4 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSemisimpleModule R M]
(m : ↥(fullyInvariantSubmodule R M)) (S : Submodule R M),
IsSimpleModule R ↥S → S ≤ ↑m → isotypicComponent R M ↥S ≤ ↑(⨆ i ∈ (fun m => {c | ↑c ≤ ↑m}) m, ⟨↑i, ⋯⟩) | null | false |
HomologicalComplex.xNextIso | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} → (C : HomologicalComplex V c) → {i j : ι} → c.Rel i j → (C.xNext i ≅ C.X j) | If `c.Rel i j`, then `C.xNext i` is isomorphic to `C.X j`. | true |
String.rawEndPos_ofList | Batteries.Data.String.Lemmas | ∀ (cs : List Char), (String.ofList cs).rawEndPos = { byteIdx := String.utf8Len cs } | null | true |
Subgroup.two_mul_widthInfty_mem_strictPeriods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ (𝒢 : Subgroup (GL (Fin 2) ℝ)), 2 * 𝒢.widthInfty ∈ 𝒢.strictPeriods | null | true |
Lean.LeanOptionValue.noConfusion | Lean.Util.LeanOptions | {P : Sort u} → {t t' : Lean.LeanOptionValue} → t = t' → Lean.LeanOptionValue.noConfusionType P t t' | null | false |
GaloisCoinsertion.u_l_le | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(self : GaloisCoinsertion l u) (x : α), u (l x) ≤ x | Main property of a Galois coinsertion. | true |
_private.Init.Data.Slice.Lemmas.0.Std.Slice.foldlM_toArray._simp_1_2 | Init.Data.Slice.Lemmas | ∀ {α β : Type w} {γ : Type x} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] {m : Type x → Type x'}
[inst_2 : Monad m] [LawfulMonad m] [inst_4 : Std.IteratorLoop α Id m] [Std.LawfulIteratorLoop α Id m]
{f : γ → β → m γ} {init : γ} {it : Std.Iter β}, Std.Iter.foldM f init it = Array.foldlM f init it.toArra... | null | false |
subalgebraOfSubring._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_1} [inst : Ring R] (S : Subring R), (algebraMap ℤ R) 0 ∈ S.carrier | null | false |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mkMulProof._unary.eq_def | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (iM : Q(CommGroupWithZero «$M»))
(_x : (_ : Mathlib.Tactic.FieldSimp.qNF M) ×' Mathlib.Tactic.FieldSimp.qNF M),
Mathlib.Tactic.FieldSimp.qNF.mkMulProof._unary iM _x =
PSigma.casesOn _x fun l₁ l₂ =>
match l₁, l₂ with
| [], l =>
have a := l.toNF;
q(⋯)... | null | false |
RestrictedProduct.instMonoidCoeOfSubmonoidClass._proof_5 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)]
(x x_1 : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕), ⇑(x * x_1) = ⇑(x * x_1) | null | false |
Int.Linear.OrOver._f | Init.Data.Int.Linear | (ℕ → Prop) → (n : ℕ) → Nat.below n → Prop | null | false |
AlgebraicGeometry.Scheme.RationalMap.equivFunctionFieldOver._proof_3 | Mathlib.AlgebraicGeometry.Birational.RationalMap | ∀ {X Y S : AlgebraicGeometry.Scheme} [inst : X.Over S] [inst_1 : Y.Over S],
(fun f => f.compHom (Y ↘ S) = AlgebraicGeometry.Scheme.Hom.toRationalMap (X ↘ S)) = fun f =>
AlgebraicGeometry.Scheme.RationalMap.IsOver S f | null | false |
LightCondensed.lanLightCondSet._proof_1 | Mathlib.Condensed.Discrete.Colimit | ∀ (X : Type u_1),
CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology LightProfinite)
(LightCondensed.lanPresheaf (LightCondensed.locallyConstantPresheaf X)) | null | false |
CategoryTheory.MorphismProperty.instIsClosedUnderIsomorphismsStructuredArrowStructuredArrowObjOfRespectsIso | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {T : Type u_3}
[inst_1 : CategoryTheory.Category.{v_3, u_3} T] (L : CategoryTheory.Functor A T)
{W : CategoryTheory.MorphismProperty T} {X : T} [W.RespectsIso],
(CategoryTheory.MorphismProperty.structuredArrowObj L W).IsClosedUnderIsomorphisms | null | true |
CategoryTheory.MorphismProperty.Over.mk_left | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) {X A : T} (f : A ⟶ X) (hf : P f),
(CategoryTheory.MorphismProperty.Over.mk Q f hf).left = A | null | true |
_private.Mathlib.RingTheory.Valuation.ValuationSubring.0.ValuationSubring.unitGroup_le_unitGroup._simp_1_1 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K), (0 ∈ A) = True | null | false |
ContDiffBump.neg | Mathlib.Analysis.Calculus.BumpFunction.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E]
(f : ContDiffBump 0) (x : E), ↑f (-x) = ↑f x | null | true |
Polynomial.mahlerMeasure_one | Mathlib.Analysis.Polynomial.MahlerMeasure | Polynomial.mahlerMeasure 1 = 1 | null | true |
ContinuousMap.instNormOneClassOfNonempty | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] [Nonempty α] [inst_4 : One E] [NormOneClass E], NormOneClass C(α, E) | null | true |
Units.opEquiv._proof_9 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : Monoid M] (x x_1 : Mᵐᵒᵖˣ),
MulOpposite.op
{ val := MulOpposite.unop ↑(x * x_1), inv := MulOpposite.unop ↑(x * x_1)⁻¹, val_inv := ⋯, inv_val := ⋯ } =
MulOpposite.op { val := MulOpposite.unop ↑x, inv := MulOpposite.unop ↑x⁻¹, val_inv := ⋯, inv_val := ⋯ } *
MulOpposite.op { val :... | null | false |
Std.ExtHashMap.contains_insertMany_list | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List (α × β)} {k : α},
(m.insertMany l).contains k = (m.contains k || (List.map Prod.fst l).contains k) | null | true |
LinearMap.BilinForm.isSymm_toMatrix'_iff_isSymm._simp_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} [inst : CommSemiring R₁] {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
{B : LinearMap.BilinForm R₁ (n → R₁)}, (LinearMap.BilinForm.toMatrix' B).IsSymm = B.IsSymm | null | false |
CochainComplex.homologyδOfTriangle._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(T : CategoryTheory.Pretriangulated.Triangle (CochainComplex C ℤ)) (n₀ : ℤ),
(HomologicalComplex.sc T.obj₃ n₀).HasHomology | null | false |
CommRingCat.Colimits.descFunLift.match_1 | Mathlib.Algebra.Category.Ring.Colimits | {J : Type u_1} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CommRingCat) →
(motive : CommRingCat.Colimits.Prequotient F → Sort u_2) →
(x : CommRingCat.Colimits.Prequotient F) →
((j : J) → (x : ↑(F.obj j)) → motive (CommRingCat.Colimits.Prequotient.of j x)) →
... | null | false |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.deriveInductionStructural.match_17 | Lean.Meta.Tactic.FunInd | (motive : Array Lean.Expr × Array Lean.MVarId → Sort u_1) →
(x : Array Lean.Expr × Array Lean.MVarId) →
((minors' : Array Lean.Expr) → (mvars : Array Lean.MVarId) → motive (minors', mvars)) → motive x | null | false |
_private.Mathlib.Analysis.Convex.Intrinsic.0.intrinsicInterior_nonempty._simp_1_1 | Mathlib.Analysis.Convex.Intrinsic | ∀ {α : Type u} {s : Set α}, s.Nonempty = (s ≠ ∅) | null | false |
IdemSemiring.toSemilatticeSup | Mathlib.Algebra.Order.Kleene | {α : Type u_5} → [self : IdemSemiring α] → SemilatticeSup α | null | true |
_private.Mathlib.Topology.Sequences.0.IsSeqCompact.isComplete._simp_1_6 | Mathlib.Topology.Sequences | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processImplicitArg._unsafe_rec | Lean.Elab.App | Lean.Name → Lean.Elab.Term.ElabAppArgs.M Lean.Expr | null | false |
CategoryTheory.Limits.isLimitOfHasKernelOfPreservesLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(G : CategoryTheory.Functor C D) →
... | If `G` preserves kernels and `C` has them, then the fork constructed of the mapped morphisms of
a kernel fork is a limit.
| true |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.sin_angle._simp_1_1 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Complex.UnitDisc.re_neg | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z : Complex.UnitDisc), (-z).re = -z.re | null | true |
Differentiable.norm | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [InnerProductSpace 𝕜 E]
[inst : NormedSpace ℝ E] {G : Type u_4} [inst_2 : NormedAddCommGroup G] [inst_3 : NormedSpace ℝ G] {f : G → E},
Differentiable ℝ f → (∀ (x : G), f x ≠ 0) → Differentiable ℝ fun y => ‖f y‖ | null | true |
RBTree.RBNode.Path.ins | BatteriesRecycling.RBTree.Basic | {α : Type u_1} → RBTree.RBNode.Path α → RBTree.RBNode α → RBTree.RBNode α | This function does the second part of `RBNode.ins`,
which unwinds the stack and rebuilds the tree.
| true |
Std.Iterators.PostconditionT.ext | Init.Data.Iterators.PostconditionMonad | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type w} {x y : Std.Iterators.PostconditionT m α}
(h : x.Property = y.Property), (fun p => ⟨↑p, ⋯⟩) <$> x.operation = y.operation → x = y | null | true |
CategoryTheory.Limits.MulticospanIndex.fstPiMapOfIsLimit | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Limits.MulticospanShape} →
(I : CategoryTheory.Limits.MulticospanIndex J C) →
(c : CategoryTheory.Limits.Fan I.left) →
{d : CategoryTheory.Limits.Fan I.right} → CategoryTheory.Limits.IsLimit d → (c.pt ⟶ d.pt) | The induced map `∏ᶜ I.left ⟶ ∏ᶜ I.right` via `I.fst` for limiting fans. | true |
groupHomology.d₁₀_single_inv | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (g : G) (a : ↑A),
((CategoryTheory.ConcreteCategory.hom (groupHomology.d₁₀ A)) fun₀ | g⁻¹ => a) =
-(CategoryTheory.ConcreteCategory.hom (groupHomology.d₁₀ A)) fun₀ | g => (A.ρ g) a | null | true |
Array.forIn'.loop.eq_2 | Init.Data.List.ToArray | ∀ {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (as : Array α)
(f : (a : α) → a ∈ as → β → m (ForInStep β)) (b : β) (i_2 : ℕ) (h_2 : i_2 + 1 ≤ as.size),
Array.forIn'.loop as f i_2.succ h_2 b = do
let __do_lift ← f as[as.size - 1 - i_2] ⋯ b
match __do_lift with
| ForInStep.done b => ... | null | true |
Std.Time.Internal.Bounded.LE.mul_pos._proof_1 | Std.Time.Internal.Bounded | ∀ {n m : ℤ} (bounded : Std.Time.Internal.Bounded.LE n m), ∀ num ≥ 0, n * num ≤ ↑bounded * num ∧ ↑bounded * num ≤ m * num | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getElem_shiftLeft._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | null | false |
FiniteIndexNormalSubgroup.instMax | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | {G : Type u_1} → [inst : Group G] → Max (FiniteIndexNormalSubgroup G) | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roi.isEmpty_iff_forall_not_mem._simp_1_5 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
Quaternion.ofComplex._proof_3 | Mathlib.Analysis.Quaternion | ∀ (x : ℝ), ↑((algebraMap ℝ ℂ) x) = ↑((algebraMap ℝ ℂ) x) | null | false |
CategoryTheory.Limits.Bicones.functoriality._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_5} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : J → C) (G : CategoryTheory.Functor C D)
[G.PreservesZeroMorphism... | null | false |
Nat.Partrec.Code.brecOn.eq | Mathlib.Computability.PartrecCode | ∀ {motive : Nat.Partrec.Code → Sort u} (t : Nat.Partrec.Code)
(F_1 : (t : Nat.Partrec.Code) → Nat.Partrec.Code.below t → motive t),
Nat.Partrec.Code.brecOn t F_1 = F_1 t (Nat.Partrec.Code.brecOn.go t F_1).2 | null | true |
_private.Mathlib.Analysis.Convex.Strong.0.aux_add | Mathlib.Analysis.Convex.Strong | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {a b m : ℝ} {x y : E} {f : E → ℝ},
0 ≤ a →
0 ≤ b →
a + b = 1 →
a * (f x + m / 2 * ‖x‖ ^ 2) + b * (f y + m / 2 * ‖y‖ ^ 2) - m / 2 * ‖a • x + b • y‖ ^ 2 =
a * f x + b * f y + m / 2 * a * b * ‖x - y‖ ^ 2 | null | true |
EuclideanGeometry.concyclic_empty | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P], EuclideanGeometry.Concyclic ∅ | The empty set is concyclic. | true |
Finsupp.embDomain_trans_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] (v : α →₀ M) (f : α ↪ β)
(g : β ↪ γ), Finsupp.embDomain (f.trans g) v = Finsupp.embDomain g (Finsupp.embDomain f v) | null | true |
Std.DTreeMap.Raw.getKeyD_eq_of_contains | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k fallback : α}, t.contains k = true → t.getKeyD k fallback = k | null | true |
Finset.powersetCard_card_add | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} (s : Finset α), 0 < n → Finset.powersetCard (s.card + n) s = ∅ | null | true |
HopfAlgCat.MonoidalCategory.inducingFunctorData_εIso | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u) [inst : CommRing R],
(HopfAlgCat.MonoidalCategory.inducingFunctorData R).εIso =
CategoryTheory.Iso.refl (CategoryTheory.MonoidalCategoryStruct.tensorUnit (BialgCat R)) | null | true |
CoxeterSystem.getElem_alternatingWord | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (p k : ℕ) (hk : k < p),
(CoxeterSystem.alternatingWord i j p)[k] = if Even (p + k) then i else j | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.0.homotopy_congruence.match_1 | Mathlib.Algebra.Homology.HomotopyCategory | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
(c : ComplexShape ι) {Y Z : HomologicalComplex V c} (x x_1 : Y ⟶ Z) (motive : homotopic V c x x_1 → Prop)
(x_2 : homotopic V c x x_1), (∀ (i : Homotopy x x_1), motive ⋯) → motive x_2 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.