name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Sym2.rec.match_1 | Mathlib.Data.Sym.Sym2 | {α : Type u_1} → (motive : α × α → Sort u_2) → (x : α × α) → ((a b : α) → motive (a, b)) → motive x | null | false |
CategoryTheory.Abelian.extFunctorObj._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (n : ℕ), n + 0 = n | null | false |
_private.Mathlib.RingTheory.PolynomialAlgebra.0.PolyEquivTensor.left_inv._simp_1_3 | Mathlib.RingTheory.PolynomialAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_5} {N : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m : M) {α : Type u_9} (s : Finset α)
(n : α → N), ∑ a ∈ s, m ⊗ₜ[R] n a = m ⊗ₜ[R] ∑ a ∈ s, n a | null | false |
Subgroup.toAddSubgroup._proof_2 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] (x : AddSubgroup (Additive G)),
(fun S =>
let __src := Submonoid.toAddSubmonoid S.toSubmonoid;
{ toAddSubmonoid := __src, neg_mem' := ⋯ })
((fun S =>
let __src := AddSubmonoid.toSubmonoid S.toAddSubmonoid;
{ toSubmonoid := __src, inv_mem' := ... | null | false |
EuclideanGeometry.orthogonalProjection.congr_simp | Mathlib.Geometry.Euclidean.Projection | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : MetricSpace P] [inst_4 : NormedAddTorsor V P] (s : AffineSubspace 𝕜 P)
[inst_5 : Nonempty ↥s] [inst_6 : s.direction.HasOrthogonalProjection],
EuclideanGeometry.orthogonal... | null | true |
MvPolynomial.weightedHomogeneousComponent_eq_self | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] {w : σ → M} {n : M}
{p : MvPolynomial σ R},
MvPolynomial.IsWeightedHomogeneous w p n → (MvPolynomial.weightedHomogeneousComponent w n) p = p | null | true |
_private.Mathlib.Algebra.Homology.Localization.0.HomotopyCategory.quotient_map_mem_quasiIso_iff._simp_1_1 | Mathlib.Algebra.Homology.Localization | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c}
[inst_2 : CategoryTheory.CategoryWithHomology C] (f : K ⟶ L), HomologicalComplex.quasiIso C c f = QuasiIso f | null | false |
ByteArray.forIn.loop._proof_4 | Init.Data.ByteArray.Basic | ∀ (as : ByteArray), ∀ i < as.size, i ≤ as.size | null | false |
AddSubgroup.upperCentralSeriesStep_eq_comap_center | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : AddGroup G] (N : AddSubgroup G) [inst_1 : N.Normal],
N.upperCentralSeriesStep = AddSubgroup.comap (QuotientAddGroup.mk' N) (AddSubgroup.center (G ⧸ N)) | The proof that `upperCentralSeriesStep N` is the preimage of the centre of `G/N`\
under the canonical surjection. | true |
Tuple.comp_sort_eq_comp_iff_monotone | Mathlib.Data.Fin.Tuple.Sort | ∀ {n : ℕ} {α : Type u_1} [inst : LinearOrder α] {f : Fin n → α} {σ : Equiv.Perm (Fin n)},
f ∘ ⇑σ = f ∘ ⇑(Tuple.sort f) ↔ Monotone (f ∘ ⇑σ) | A permutation of a tuple `f` is `f` sorted if and only if it is monotone. | true |
AddMonoidAlgebra.opRingEquiv_symm_single | Mathlib.Algebra.MonoidAlgebra.Opposite | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Add M] (r : Rᵐᵒᵖ) (x : Mᵃᵒᵖ),
AddMonoidAlgebra.opRingEquiv.symm (AddMonoidAlgebra.single x r) =
MulOpposite.op (AddMonoidAlgebra.single (AddOpposite.unop x) (MulOpposite.unop r)) | null | true |
CategoryTheory.Functor.mapHomologicalComplexIdIso._proof_2 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} (W₁ : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} W₁]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms W₁] (c : ComplexShape ι) (K : HomologicalComplex W₁ c) (i j : ι),
c.Rel i j →
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl ((((CategoryTheory.Functor.id W₁).map... | null | false |
cfcₙ.congr_simp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_3} {A : Type u_4} {p p_1 : A → Prop} (e_p : p = p_1) [inst : CommSemiring R] [inst_1 : Nontrivial R]
[inst_2 : StarRing R] [inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R]
[inst_6 : NonUnitalRing A] [inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Mo... | null | true |
exists_lt_of_ciInf₂_lt | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_5} [inst : ConditionallyCompleteLinearOrder α] {a : α} [Nonempty ι]
[∀ (i : ι), Nonempty (κ i)] {f : (i : ι) → κ i → α}, ⨅ i, ⨅ j, f i j < a → ∃ i j, f i j < a | null | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁ | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof | null | true |
Matrix.specialOrthogonalGroup | Mathlib.LinearAlgebra.UnitaryGroup | (n : Type u) →
[inst : DecidableEq n] → [inst_1 : Fintype n] → (R : Type v) → [inst_2 : CommRing R] → Submonoid (Matrix n n R) | `Matrix.specialOrthogonalGroup n` is the group of orthogonal `n` by `n` where the determinant
is one. (This definition is only correct if 2 is invertible.) | true |
Equiv.mulOneClass | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [MulOneClass β] → MulOneClass α | Transfer `MulOneClass` across an `Equiv` | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.casesOn | Std.Sync.Channel | {α : Type} →
{motive : Std.CloseableChannel.Bounded.State✝ α → Sort u} →
(t : Std.CloseableChannel.Bounded.State✝ α) →
((producers : Std.Queue (IO.Promise Bool)) →
(consumers : Std.Queue (Std.CloseableChannel.Bounded.Consumer✝ α)) →
(capacity : ℕ) →
(buf : Vector (IO.Ref ... | null | false |
_private.Mathlib.Data.List.OffDiag.0.List.Nodup.offDiag._proof_1_1 | Mathlib.Data.List.OffDiag | ∀ {α : Type u_1} {l : List α},
l.Nodup → ∀ (x y : α), (List.count x l * List.count y l - if x = y then List.count x l else 0) ≤ 1 | null | false |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.mapSetEmbedding._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u} {s : Set α}, (s ⊆ ∅) = (s = ∅) | null | false |
IsCyclotomicExtension.Rat.galEquivZMod.eq_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Galois | ∀ (n : ℕ) [inst : NeZero n] (K : Type u_1) [inst_1 : Field K] [inst_2 : NumberField K]
[hK : IsCyclotomicExtension {n} ℚ K],
IsCyclotomicExtension.Rat.galEquivZMod n K = IsCyclotomicExtension.autEquivPow K ⋯ | null | true |
_private.Mathlib.Data.List.Sort.0.List.erase_orderedInsert_of_notMem._proof_1_1 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [inst : DecidableRel r] [inst_1 : DecidableEq α] {x : α},
(List.orderedInsert r x []).erase x = [] | null | false |
_private.Mathlib.RingTheory.Ideal.MinimalPrime.Basic.0.Ideal.map_sup_mem_minimalPrimes_of_map_quotientMk_mem_minimalPrimes.match_1_1 | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {S : Type u_1} [inst_1 : CommRing S] [inst_2 : Algebra R S] {I : Ideal R}
{J : Ideal S} (q : Ideal S) (motive : q.IsPrime ∧ Ideal.map (algebraMap R S) I ⊔ J ≤ q → Prop)
(x : q.IsPrime ∧ Ideal.map (algebraMap R S) I ⊔ J ≤ q),
(∀ (left : q.IsPrime) (hleq : Ideal.map (algebra... | null | false |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.Finite.infsep._simp_1_3 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u} {s : Set α} {a : α} (hs : s.Finite), (a ∈ hs.toFinset) = (a ∈ s) | null | false |
Module.Basis.toMatrix_smul | Mathlib.LinearAlgebra.Matrix.Basis | ∀ {ι : Type u_1} {R₁ : Type u_9} {S : Type u_10} [inst : CommSemiring R₁] [inst_1 : Semiring S] [inst_2 : Algebra R₁ S]
[inst_3 : Fintype ι] [inst_4 : DecidableEq ι] (x : S) (b : Module.Basis ι R₁ S) (w : ι → S),
b.toMatrix (x • w) = (Algebra.leftMulMatrix b) x * b.toMatrix w | null | true |
LinearMap.IsReflective.coroot._proof_1 | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(B : M →ₗ[R] M →ₗ[R] R) {x : M} (hx : B.IsReflective x) (a b : M), Exists.choose ⋯ = Exists.choose ⋯ + Exists.choose ⋯ | null | false |
ENNReal.ofReal_essSup | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) (MeasureTheory.ae μ) f →
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) (MeasureTheory.ae μ) f →
ENNReal.ofReal (essSup f μ) = essSup (fun a => ENNReal.ofReal (f a)) μ | null | true |
_private.Mathlib.RingTheory.LocalRing.ResidueField.Ideal.0.instIsFractionRingQuotientIdealResidueField._simp_3 | Mathlib.RingTheory.LocalRing.ResidueField.Ideal | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} [inst_1 : I.IsTwoSided] (x y : R),
(x - y ∈ I) = ((Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y) | null | false |
CompactlySupportedContinuousMap.noConfusionType | Mathlib.Topology.ContinuousMap.CompactlySupported | Sort u →
{α : Type u_5} →
{β : Type u_6} →
[inst : TopologicalSpace α] →
[inst_1 : Zero β] →
[inst_2 : TopologicalSpace β] →
CompactlySupportedContinuousMap α β →
{α' : Type u_5} →
{β' : Type u_6} →
[inst' : TopologicalSpace α'] →... | null | false |
HomotopyEquiv.toHomologyIso._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_3}
{c : ComplexShape ι} {K L : HomologicalComplex C c} (h : HomotopyEquiv K L) (i : ι) [inst_2 : K.HasHomology i]
[inst_3 : L.HasHomology i],
CategoryTheory.CategoryStruct.comp (HomologicalComplex.ho... | null | false |
IsOpen.is_const_of_deriv_eq_zero | Mathlib.Analysis.Calculus.MeanValue | ∀ {𝕜 : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] {f : 𝕜 → G}
{s : Set 𝕜},
IsOpen s → IsPreconnected s → DifferentiableOn 𝕜 f s → Set.EqOn (deriv f) 0 s → ∀ {x y : 𝕜}, x ∈ s → y ∈ s → f x = f y | null | true |
Std.IterM.fold_filterMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β]
[Std.Iterators.Finite α m] [inst_2 : Monad m] [LawfulMonad m] [inst_4 : Monad n] [inst_5 : MonadAttach n]
[LawfulMonad n] [WeaklyLawfulMonadAttach n] [inst_8 : Std.IteratorLoop α m n] [Std.LawfulIteratorLoop α m n]
[in... | null | true |
Std.Broadcast.Sync.send | Std.Sync.Broadcast | {α : Type} → Std.Broadcast.Sync α → α → IO ℕ | Send a value through the channel, blocking until the transmission could be completed.
| true |
_private.Mathlib.FieldTheory.Finite.Basic.0.FiniteField.exists_root_sum_quadratic._simp_1_2 | Mathlib.FieldTheory.Finite.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.Hom.mk | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
{F : CategoryTheory.Functor C FintypeCat} →
{A B : CategoryTheory.PreGaloisCategory.PointedGaloisObject F} →
(val : A.obj ⟶ B.obj) →
autoParam ((CategoryTheory.ConcreteCat... | null | true |
Std.DTreeMap.Internal.Impl.getKeyLE?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α),
Std.DTreeMap.Internal.Impl.getKeyLE? k = Std.DTreeMap.Internal.Impl.getKeyLE?.go k none | null | true |
MulAction.stabilizer_smul_eq_right | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {β : Type u_3} [inst : Group G] [inst_1 : MulAction G β] {α : Type u_4} [inst_2 : Group α]
[inst_3 : MulAction α β] [SMulCommClass G α β] (a : α) (b : β),
MulAction.stabilizer G (a • b) = MulAction.stabilizer G b | null | true |
WeierstrassCurve.Projective.add | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → (Fin 3 → R) → Fin 3 → R | The addition of two projective point representatives on a Weierstrass curve. | true |
Subring.unop_sup | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocRing R] (S₁ S₂ : Subring Rᵐᵒᵖ), (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop | null | true |
List.lex_nil | Init.Data.List.Basic | ∀ {α : Type u} {lt : α → α → Bool} [inst : BEq α] {as : List α}, as.lex [] lt = false | null | true |
BitVec._sizeOf_inst._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.237 | Mathlib.Util.CompileInductive | (w : ℕ) → SizeOf (BitVec w) | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.DivModState.lawful_init._simp_1_3 | Init.Data.BitVec.Bitblast | ∀ {n : ℕ} {x y : BitVec n}, (x < y) = (x.toNat < y.toNat) | null | false |
map_eq_zero._simp_1 | Mathlib.Algebra.GroupWithZero.Units.Lemmas | ∀ {G₀ : Type u_3} {M₀' : Type u_4} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : MulZeroOneClass M₀']
[Nontrivial M₀'] [inst_3 : FunLike F G₀ M₀'] [MonoidWithZeroHomClass F G₀ M₀'] (f : F) {a : G₀}, (f a = 0) = (a = 0) | null | false |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameState.mk.injEq | Lean.Elab.DeclNameGen | ∀ (seen : Lean.ExprSet) (consts : Lean.NameSet) (seen_1 : Lean.ExprSet) (consts_1 : Lean.NameSet),
({ seen := seen, consts := consts } = { seen := seen_1, consts := consts_1 }) = (seen = seen_1 ∧ consts = consts_1) | null | true |
CategoryTheory.Lax.LaxTrans.recOn | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{motive : CategoryTheory.Lax.LaxTrans F G → Sort u} →
(t : CategoryTheory.Lax.LaxTrans F G) →
((app : (a : B) → ... | null | false |
MonoidAlgebra.isGroupLikeElem_of | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ {R : Type u_1} {A : Type u_3} {M : Type u_8} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A]
[inst_3 : Monoid M] (m : M), IsGroupLikeElem R ((MonoidAlgebra.of A M) m) | null | true |
Lean.PersistentEnvExtension.noConfusionType | Lean.Environment | Sort u →
{α β σ : Type} → Lean.PersistentEnvExtension α β σ → {α' β' σ' : Type} → Lean.PersistentEnvExtension α' β' σ' → Sort u | null | false |
MeasureTheory.VectorMeasure.exists_variation_le_add | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {X : Type u_1} {V : Type u_2} {mX : MeasurableSpace X} [inst : TopologicalSpace V] [inst_1 : ENormedAddCommMonoid V]
[inst_2 : T2Space V] (μ : MeasureTheory.VectorMeasure X V) {s : Set X},
MeasurableSet s →
∀ {ε : NNReal},
0 < ε →
μ.variation s ≠ ⊤ →
∃ P,
(∀ t ∈ P, t ⊆ s) ∧... | Measure version of `preVariation.exists_Finpartition_sum_ge`. | true |
_private.Mathlib.Analysis.InnerProductSpace.TwoDim.0.Orientation.termω | Mathlib.Analysis.InnerProductSpace.TwoDim | Lean.ParserDescr | null | true |
Lean.Expr.NumApps.State.counters | Lean.Util.NumApps | Lean.Expr.NumApps.State → Lean.NameMap ℕ | null | true |
CategoryTheory.unop_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : Cᵒᵖ)
{Y Z : Cᵒᵖ} (f : Y ⟶ Z),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).unop =
CategoryTheory.MonoidalCategoryStruct.whiskerLeft (Opposite.unop X) f.unop | null | true |
SetRel.IsWellFounded.eq_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} (R : SetRel α α), R.IsWellFounded = WellFounded fun x1 x2 => (x1, x2) ∈ R | null | true |
_private.Mathlib.RingTheory.Coalgebra.CoassocSimps.0.CoassocSimps._aux_Mathlib_RingTheory_Coalgebra_CoassocSimps___unexpand_TensorProduct_map_1 | Mathlib.RingTheory.Coalgebra.CoassocSimps | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.zero_φK | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
(CategoryTheory.ShortComplex.LeftHomologyMapData.zero h₁ h₂).φK = 0 | null | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.MatcherKey.mk._flat_ctor | Lean.Meta.Match.Match | Lean.Expr → Bool → Bool → Lean.Meta.Match.MatcherKey✝ | null | false |
ContinuousLinearMap.restrictScalars_smul | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.RestrictScalars | ∀ {A : Type u_1} {M₁ : Type u_2} {M₂ : Type u_3} {R : Type u_4} {S : Type u_5} [inst : Semiring A] [inst_1 : Semiring R]
[inst_2 : Semiring S] [inst_3 : AddCommMonoid M₁] [inst_4 : Module A M₁] [inst_5 : Module R M₁]
[inst_6 : TopologicalSpace M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Module A M₂] [inst_9 : Module ... | null | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.smul_add._simp_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Type u_2} [inst : Preorder α] {s t : Set α}, (s ∪ t).IsPWO = (s.IsPWO ∧ t.IsPWO) | null | false |
WeierstrassCurve.Affine.addX_self_of_Y_ne | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Affine F} [inst_1 : DecidableEq F] {x y : F},
W.Equation x y →
y ≠ W.negY x y →
W.addX x x (W.slope x x y y) =
(x ^ 4 - WeierstrassCurve.b₄ W * x ^ 2 - 2 * WeierstrassCurve.b₆ W * x - WeierstrassCurve.b₈ W) /
(4 * x ^ 3 + WeierstrassCur... | The explicit duplication formula for the `x`-coordinate when `2*P ≠ 0`. | true |
Lean.Elab.TerminationHints.noConfusionType | Lean.Elab.PreDefinition.TerminationHint | Sort u → Lean.Elab.TerminationHints → Lean.Elab.TerminationHints → Sort u | null | false |
NumberField.IsCMField.isConj_complexConj | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (φ : K →+* ℂ),
NumberField.ComplexEmbedding.IsConj φ (NumberField.IsCMField.complexConj K) | The complex conjugation is the conjugation of any complex embedding of a CM-field.
| true |
Nat.nth_add_one | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} {n : ℕ}, ¬p 0 → Nat.nth p n ≠ 0 → Nat.nth (fun i => p (i + 1)) n + 1 = Nat.nth p n | null | true |
instLinearOrderedCommGroupWithZeroMultiplicativeOrderDualOfLinearOrderedAddCommGroupWithTop._proof_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroupWithTop α] (n : ℕ) (a : Multiplicative αᵒᵈ), a ^ ↑n.succ = a ^ ↑n * a | null | false |
MeasurableSMul.mk | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} [inst : SMul M α] [inst_1 : MeasurableSpace M] [inst_2 : MeasurableSpace α]
[toMeasurableConstSMul : MeasurableConstSMul M α],
autoParam (∀ (x : α), Measurable fun x_1 => x_1 • x) MeasurableSMul.measurable_smul_const._autoParam →
MeasurableSMul M α | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.completeBipartiteGraph_isContained_iff.match_1_7 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_2} {G : SimpleGraph V} {α : Type u_3} {β : Type u_1} [inst : Fintype β]
(f : (completeBipartiteGraph α β).Copy G) (x : V)
(motive : (∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x) → Prop)
(hr : ∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x),
(∀ (w : β) (left : w ∈ F... | null | false |
List.flatMap | Init.Prelude | {α : Type u} → {β : Type v} → (α → List β) → List α → List β | Applies a function that returns a list to each element of a list, and concatenates the resulting
lists.
Examples:
* `[2, 3, 2].flatMap List.range = [0, 1, 0, 1, 2, 0, 1]`
* `["red", "blue"].flatMap String.toList = ['r', 'e', 'd', 'b', 'l', 'u', 'e']`
| true |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂),
CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂ →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ComposableArrows.mk₃ f₁₂ f₃ f₄).map' 0 1 C... | null | false |
PiNat.mem_cylinder_comm | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} (x y : (n : ℕ) → E n) (n : ℕ), y ∈ PiNat.cylinder x n ↔ x ∈ PiNat.cylinder y n | null | true |
delabNotIn | Mathlib.Util.Delaborators | Lean.PrettyPrinter.Delaborator.Delab | Delaborator for `∉`. | true |
CategoryTheory.Pseudofunctor.CoGrothendieck.noConfusion | Mathlib.CategoryTheory.Bicategory.Grothendieck | {P : Sort u} →
{𝒮 : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} →
{t : F.CoGrothendieck} →
{𝒮' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} 𝒮'} →
... | null | false |
CategoryTheory.Limits.instPreservesColimitsOfShapeDiscreteOfFiniteOfPreservesFiniteCoproducts | Mathlib.CategoryTheory.Limits.Preserves.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (J : Type u) [Finite J] [CategoryTheory.Limits.PreservesFiniteCoproducts F],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete J) F | null | true |
CochainComplex.HomComplex.CohomologyClass.toSmallShiftedHom | Mathlib.Algebra.Homology.DerivedCategory.SmallShiftedHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{K L : CochainComplex C ℤ} →
{n : ℤ} →
[inst_2 :
CategoryTheory.Localization.HasSmallLocalizedShiftedHom
(HomologicalComplex.quasiIso C (ComplexShape.up ℤ)) ℤ K L]... | Given `x : CohomologyClass K L n`, this is the element in the type
`SmallShiftedHom` relatively to quasi-isomorphisms that is associated
to the `x`. | true |
Function.Surjective.involutiveNeg._proof_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Neg M₂] [inst_1 : InvolutiveNeg M₁] (f : M₁ → M₂),
(∀ (x : M₁), f (-x) = -f x) → ∀ (x : M₁), - -f x = f x | null | false |
ContinuousAlgEquiv.coeCLE_apply | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (e : A ≃A[R] B) (a : A), ↑e a = e a | null | true |
_private.Init.Data.Array.Find.0.Array.getElem?_zero_flatten._simp_1_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {l : List α}, l[0]? = l.head? | null | false |
Std.DTreeMap.Raw.Equiv.forIn_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} {δ : Type w}
{m : Type w → Type w'} [Std.TransCmp cmp] [inst : Monad m] [LawfulMonad m] {b : δ}
{f : (a : α) × β a → δ → m (ForInStep δ)}, t₁.WF → t₂.WF → t₁.Equiv t₂ → forIn t₁ b f = forIn t₂ b f | null | true |
Subgroup.mulSingle_mem_pi._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_5} {f : η → Type u_6} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → Subgroup (f i)} (i : η) (x : f i), (Pi.mulSingle i x ∈ Subgroup.pi I H) = (i ∈ I → x ∈ H i) | null | false |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceOpcyclesE_X₁ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ i₂ i₃ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.Cat... | null | true |
CommHopfAlgCat.casesOn | Mathlib.Algebra.Category.CommHopfAlgCat | {R : Type u} →
[inst : CommRing R] →
{motive : CommHopfAlgCat R → Sort u_1} →
(t : CommHopfAlgCat R) →
((X : Type v) → [commRing : CommRing X] → [hopfAlgebra : HopfAlgebra R X] → motive ↧X) → motive t | null | false |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real.0.RealRMK.integral_riesz_aux._simp_1_7 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | null | false |
_private.Mathlib.Algebra.Homology.DerivedCategory.TStructure.0.DerivedCategory.TStructure.t._proof_12 | Mathlib.Algebra.Homology.DerivedCategory.TStructure | (ComplexShape.embeddingUpIntLE 0).IsTruncLE | null | false |
_private.Init.Omega.Int.0.Lean.Omega.Fin.ne_iff_lt_or_gt._simp_1_1 | Init.Omega.Int | ∀ {a b : ℕ}, (a ≠ b) = (a < b ∨ b < a) | null | false |
SSet.Subcomplex.Pairing.RankFunction.filtration_of_isSuccLimit | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι) [OrderBot ι]
[SuccOrder ι] (i : ι), Order.IsSuccLimit i → f.filtration i = ⨆ j, ⨆ (_ : j < i), f.filtration j | null | true |
NNRat.instContinuousSub | Mathlib.Topology.Instances.Rat | ContinuousSub ℚ≥0 | null | true |
Std.TreeMap.getKeyD_diff_of_not_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k fallback : α},
k ∉ t₂ → (t₁ \ t₂).getKeyD k fallback = t₁.getKeyD k fallback | null | true |
genLoopEquivOfUnique._proof_3 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} (N : Type u_2) [inst_1 : Unique N] (p : LoopSpace X x),
{ toFun := fun c => p (c default), continuous_toFun := ⋯ } ∈ GenLoop N X x | null | false |
Lean.Server.instMonadLiftCancellableMRequestM.match_1 | Lean.Server.Requests | {α : Type} →
(motive : Except Lean.Server.RequestCancellation α → Sort u_1) →
(r : Except Lean.Server.RequestCancellation α) →
((a : Lean.Server.RequestCancellation) → motive (Except.error a)) → ((v : α) → motive (Except.ok v)) → motive r | null | false |
FinPartOrd.Iso.mk_inv | Mathlib.Order.Category.FinPartOrd | ∀ {α β : FinPartOrd} (e : ↑α.toPartOrd ≃o ↑β.toPartOrd), (FinPartOrd.Iso.mk e).inv = FinPartOrd.ofHom ↑e.symm | null | true |
Std.TreeSet.Raw.min?_insert_le_self | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [inst : Std.TransCmp cmp] (h : t.WF) {k kmi : α},
(t.insert k).min?.get ⋯ = kmi → (cmp kmi k).isLE = true | null | true |
ContinuousMap.casesOn | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{motive : C(X, Y) → Sort u} →
(t : C(X, Y)) →
((toFun : X → Y) →
(continuous_toFun : Continuous toFun) →
motive { toFun := toFun, continuous_toFun :... | null | false |
_private.Mathlib.Topology.Instances.RatLemmas.0.«termℚ∞» | Mathlib.Topology.Instances.RatLemmas | Lean.ParserDescr | null | true |
Lean.Elab.Do.instToMessageDataMutVar | Lean.Elab.Do.Basic | Lean.ToMessageData Lean.Elab.Do.MutVar | null | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapCycles₁_quotientGroupMk'_epi._simp_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal] (a : G), (↑a)⁻¹ = ↑a⁻¹ | null | false |
ArithmeticFunction.instAlgebra | Mathlib.NumberTheory.ArithmeticFunction.Defs | {R : Type u_1} →
{S : Type u_2} → [inst : CommSemiring R] → [inst_1 : Semiring S] → [Algebra R S] → Algebra R (ArithmeticFunction S) | null | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.isCongruentCheck.go._unsafe_rec | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool | null | false |
CategoryTheory.PrelaxFunctorStruct.map₂ | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | {B : Type u₁} →
[inst : Quiver B] →
[inst_1 : (a b : B) → Quiver (a ⟶ b)] →
{C : Type u₂} →
[inst_2 : Quiver C] →
[inst_3 : (a b : C) → Quiver (a ⟶ b)] →
(self : CategoryTheory.PrelaxFunctorStruct B C) →
{a b : B} → {f g : a ⟶ b} → (f ⟶ g) → (self.map f ⟶ self.map... | The action of a lax prefunctor on 2-morphisms. | true |
EReal.neg_eq_top_iff | Mathlib.Data.EReal.Operations | ∀ {x : EReal}, -x = ⊤ ↔ x = ⊥ | null | true |
ArchimedeanClass.closedBallAddSubgroup.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M]
(c : ArchimedeanClass M), c.closedBallAddSubgroup = ArchimedeanClass.addSubgroup (UpperSet.Ici c) | null | true |
Std.DTreeMap.Internal.Const.RicSliceData.rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Const.RicSliceData α β → Sort u_1} →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => β) →
(range : Std.Ric α) → motive { treeMap := treeMap, range := range }) →
(t : Std.DTreeMap.Internal.Const.Ric... | null | false |
ModuleCat.CoextendScalars.obj' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} → {S : Type u₂} → [inst : Ring R] → [inst_1 : Ring S] → (R →+* S) → ModuleCat R → ModuleCat S | If `M` is an `R`-module, then the set of `R`-linear maps `S →ₗ[R] M` is an `S`-module with
scalar multiplication defined by `s • l := x ↦ l (x • s)`.
This is an implementation detail: use `(coextendScalars f).obj` instead.
| true |
Lean.Data.AC.Variable.mk | Init.Data.AC | {α : Sort u} → {op : α → α → α} → (value : α) → Option (PLift (Std.LawfulIdentity op value)) → Lean.Data.AC.Variable op | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.