name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.DependencyBuildMode._sizeOf_inst | Lean.Data.Lsp.Extra | SizeOf Lean.Lsp.DependencyBuildMode | null | false |
CategoryTheory.Limits.Trident.ι | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : J → (X ⟶ Y)} →
(t : CategoryTheory.Limits.Trident f) →
((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingParallelFamily J)).obj t.pt).obj
CategoryTheory.Limits.... | A trident `t` on the parallel family `f : J → (X ⟶ Y)` consists of two morphisms
`t.π.app zero : t.X ⟶ X` and `t.π.app one : t.X ⟶ Y`. Of these, only the first one is
interesting, and we give it the shorter name `Trident.ι t`. | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_toInt_lt_neg_two_pow_iff._proof_1_8 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
((w + 1) * 2 - 2 < (w + 1) * 2 - 1 → 2 ^ ((w + 1) * 2 - 2) < 2 ^ ((w + 1) * 2 - 1)) →
x.toInt * y.toInt ≤ 2 ^ ((w + 1) * 2 - 2) → ¬x.toInt * y.toInt * 2 < 2 ^ ((w + 1) * 2 - 1) * 2 → False | null | false |
CategoryTheory.SimplicialObject.Splitting.PInfty_comp_πSummand_id_assoc | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C] (n : ℕ) {Z : C}
(h :
s.N (Opposite.unop (CategoryTheory.SimplicialObject.Splitting.IndexSet.id (Opposite.op { len := n })).fst).len ⟶ Z),
CategoryThe... | null | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.parallel.aux2.match_1.congr_eq_2 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u_1} (motive : α ⊕ List (Computation α) → Sort u_2) (o : α ⊕ List (Computation α))
(h_1 : (a : α) → motive (Sum.inl a)) (h_2 : (ls : List (Computation α)) → motive (Sum.inr ls))
(ls : List (Computation α)),
o = Sum.inr ls →
(match o with
| Sum.inl a => h_1 a
| Sum.inr ls => h_2 ls) ≍
... | null | true |
Metric.diam_cthickening_le | Mathlib.Topology.MetricSpace.Thickening | ∀ {ε : ℝ} {α : Type u_2} [inst : PseudoMetricSpace α] (s : Set α),
0 ≤ ε → Metric.diam (Metric.cthickening ε s) ≤ Metric.diam s + 2 * ε | null | true |
AlgebraicGeometry.Scheme.OpenCover.finiteSubcover_X | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [H : CompactSpace ↥X] (x : ↥⋯.choose),
𝒰.finiteSubcover.X x = 𝒰.X (AlgebraicGeometry.Scheme.Cover.idx 𝒰 ↑x) | null | true |
DirectLimit.NonUnitalRing.lift_of | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonUnitalNonA... | null | true |
CategoryTheory.Monoidal.instMonoidalTransportedInverseEquivalenceTransported._proof_4 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} D] (e : C ≌ D)
{X₁ Y₁ X₂ Y₂ : CategoryTheory.Monoidal.Transported e} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
e.inverse.map (CategoryTheory.MonoidalCategorySt... | null | false |
Module.Grassmannian._sizeOf_inst | Mathlib.RingTheory.Grassmannian | (R : Type u) →
{inst : CommRing R} →
(M : Type v) →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} → (k : ℕ) → [SizeOf R] → [SizeOf M] → SizeOf (Module.Grassmannian R M k) | null | false |
Multiset.countP_congr | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} {s s' : Multiset α},
s = s' →
∀ {p p' : α → Prop} [inst : DecidablePred p] [inst_1 : DecidablePred p'],
(∀ x ∈ s, p x = p' x) → Multiset.countP p s = Multiset.countP p' s' | null | true |
instToStringFloat32 | Init.Data.Float32 | ToString Float32 | null | true |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetLimitCone_cone_π_app | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type w}
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape (Finset (CategoryTheory.Discrete α))ᵒᵖ C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete α) C) (j : CategoryTheory.Discrete α),
(Categ... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput.lhs | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput aig len → aig.RefVec len | null | true |
Lean.Server.RequestHandler._sizeOf_inst | Lean.Server.Requests | SizeOf Lean.Server.RequestHandler | null | false |
BddOrd.instConcreteCategoryBoundedOrderHomCarrier._proof_2 | Mathlib.Order.Category.BddOrd | ∀ {X Y : BddOrd} (f : X ⟶ Y), { hom' := f.hom' } = f | null | false |
Function.IsFixedPt.image_iterate | Mathlib.Dynamics.FixedPoints.Basic | ∀ {α : Type u_1} {f : α → α} {s : Set α},
Function.IsFixedPt (Set.image f) s → ∀ (n : ℕ), Function.IsFixedPt (Set.image f^[n]) s | null | true |
Set.coe_snd_biUnionEqSigmaOfDisjoint | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_5} {ι : Type u_6} {s : Set ι} {f : ι → Set α} (h : s.PairwiseDisjoint f) (x : ↑(⋃ i ∈ s, f i)),
↑((Set.biUnionEqSigmaOfDisjoint h) x).snd = ↑x | null | true |
Quaternion.instNormedAddCommGroupReal._proof_3 | Mathlib.Analysis.Quaternion | ∀ (x y : Quaternion ℝ) (r : ℝ), inner ℝ (r • x) y = (starRingEnd ℝ) r * inner ℝ x y | null | false |
Aesop.TraceOption.mk.noConfusion | Aesop.Tracing | {P : Sort u} →
{traceClass : Lean.Name} →
{option : Lean.Option Bool} →
{traceClass' : Lean.Name} →
{option' : Lean.Option Bool} →
{ traceClass := traceClass, option := option } = { traceClass := traceClass', option := option' } →
(traceClass = traceClass' → option = option' → ... | null | false |
WittVector.instCommRing._proof_9 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (z : ℤ)
(x : WittVector p (MvPolynomial R ℤ)),
WittVector.mapFun (⇑(MvPolynomial.counit R)) (z • x) = z • WittVector.mapFun (⇑(MvPolynomial.counit R)) x | null | false |
ULift.seminormedRing._proof_17 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] (a : ULift.{u_1, u_2} α), -a + a = 0 | null | false |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._proof_1_10 | Mathlib.LinearAlgebra.Goursat | ∀ {R : Type u_1} [inst : Ring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
MvPolynomial.killCompl_monomial_eq_monomial_comapDomain_of_subset | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] {f : σ → τ} (hf : Function.Injective f)
{s : τ →₀ ℕ} (c : R),
↑s.support ⊆ Set.range f →
(MvPolynomial.killCompl hf) ((MvPolynomial.monomial s) c) = (MvPolynomial.monomial (Finsupp.comapDomain f s ⋯)) c | null | true |
CategoryTheory.Functor.Elements.initialOfCorepresentableBy | Mathlib.CategoryTheory.Elements | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C (Type u_1)} → {X : C} → F.CorepresentableBy X → F.Elements | The initial object in `F.Elements` if `F` is corepresentable. | true |
Aesop.Nanos.nanos | Aesop.Nanos | Aesop.Nanos → ℕ | null | true |
torusMap_zero_radius | Mathlib.MeasureTheory.Integral.TorusIntegral | ∀ {n : ℕ} (c : Fin n → ℂ), torusMap c 0 = Function.const (Fin n → ℝ) c | null | true |
Ordinal.inductionOnWellOrder | Mathlib.SetTheory.Ordinal.Basic | ∀ {motive : Ordinal.{u_1} → Prop} (o : Ordinal.{u_1}),
(∀ (α : Type u_1) [inst : LinearOrder α] [inst_1 : WellFoundedLT α], motive (Ordinal.type fun x1 x2 => x1 < x2)) →
motive o | To prove a result on ordinals, it suffices to prove it for order types of well-orders. | true |
MeasureTheory.MemLp.exists_boundedContinuous_integral_rpow_sub_le | Mathlib.MeasureTheory.Function.ContinuousMapDense | ∀ {α : Type u_1} [inst : TopologicalSpace α] [NormalSpace α] [inst_2 : MeasurableSpace α] [BorelSpace α] {E : Type u_2}
[inst_4 : NormedAddCommGroup E] {μ : MeasureTheory.Measure α} [NormedSpace ℝ E] [μ.WeaklyRegular] {p : ℝ},
0 < p →
∀ {f : α → E},
MeasureTheory.MemLp f (ENNReal.ofReal p) μ →
∀ {... | Any function in `ℒp` can be approximated by bounded continuous functions when `0 < p < ∞`,
version in terms of `∫`. | true |
ContinuousOpenMap._sizeOf_inst | Mathlib.Topology.Hom.Open | (α : Type u_6) →
(β : Type u_7) →
{inst : TopologicalSpace α} → {inst_1 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → SizeOf (α →CO β) | null | false |
indicator_ae_eq_zero_of_restrict_ae_eq_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} {f : α → β}
[inst_1 : Zero β], MeasurableSet s → f =ᵐ[μ.restrict s] 0 → s.indicator f =ᵐ[μ] 0 | null | true |
AlgebraicGeometry.pointEquivClosedPoint._proof_4 | Mathlib.AlgebraicGeometry.AlgClosed.Basic | ∀ {X : AlgebraicGeometry.Scheme} {K : Type u_1} [inst : Field K] [inst_1 : IsAlgClosed K]
(f : X ⟶ AlgebraicGeometry.Spec (CommRingCat.of K)) [inst_2 : AlgebraicGeometry.LocallyOfFiniteType f]
(x : ↑(closedPoints ↥X)),
(fun p => ⟨↑p (IsLocalRing.closedPoint K), ⋯⟩) ((fun x => ⟨AlgebraicGeometry.pointOfClosedPoint... | null | false |
Set.Ioc_add_bij | Mathlib.Algebra.Order.Interval.Set.Monoid | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [IsOrderedCancelAddMonoid M] [ExistsAddOfLE M]
(a b d : M), Set.BijOn (fun x => x + d) (Set.Ioc a b) (Set.Ioc (a + d) (b + d)) | null | true |
CategoryTheory.CommMon.X | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommMon C → C | The underlying object in the ambient monoidal category | true |
CategoryTheory.Limits.WalkingMulticospan.ctorElim | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u} →
(ctorIdx : ℕ) →
(t : CategoryTheory.Limits.WalkingMulticospan J) →
ctorIdx = t.ctorIdx → CategoryTheory.Limits.WalkingMulticospan.ctorElimType ctorIdx → motive t | null | false |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.setParentBump_rankD_lt._proof_1 | Batteries.Data.UnionFind.Basic | ∀ {arr' : Array Batteries.UFNode} {arr : Array Batteries.UFNode} {x : Fin arr.size} {y : Fin arr.size} {i : ℕ},
¬↑x < arr.size → False | null | false |
Lean.Doc.Block.brecOn_7 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1... | null | false |
AddMonoidAlgebra.single_mem_grade | Mathlib.Algebra.MonoidAlgebra.Grading | ∀ {M : Type u_1} {R : Type u_4} [inst : CommSemiring R] (i : M) (r : R),
AddMonoidAlgebra.single i r ∈ AddMonoidAlgebra.grade R i | null | true |
Polynomial.Monic.add_of_left | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, p.Monic → q.degree < p.degree → (p + q).Monic | null | true |
_private.Mathlib.NumberTheory.NumberField.Completion.FinitePlace.0.NumberField.FinitePlace.add_le._proof_1_4 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(w : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)),
IsUniformAddGroup (WithVal (IsDedekindDomain.HeightOneSpectrum.valuation K w)) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
setOf_riemannianEDist_lt_subset_nhds' | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
(I : ModelWithCorners ℝ E H) {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[inst_5 : Bundle.RiemannianBundle fun x => TangentSpace I x] [inst_6 : IsManifold I 1 M]
[IsC... | Any neighborhood of `x` contains all the points which are close enough to `x` for the
Riemannian distance, `ℝ≥0∞` version. | true |
Bundle.Pullback.lift | Mathlib.Data.Bundle | {B : Type u_1} →
{F : Type u_2} →
{E : B → Type u_3} → {B' : Type u_4} → (f : B' → B) → Bundle.TotalSpace F (f *ᵖ E) → Bundle.TotalSpace F E | The base map `f : B' → B` lifts to a canonical map on the total spaces. | true |
MeasureTheory.LocallyIntegrable.mono_measure._gcongr_1 | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ ν : MeasureTheory.Measure X},
ν ≤ μ → MeasureTheory.LocallyIntegrable f μ → MeasureTheory.LocallyIntegrable f ν | null | false |
TopCat.instAbelianPresheaf._proof_4 | Mathlib.Topology.Sheaves.Abelian | ∀ {X : TopCat} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C],
autoParam
(∀ (P Q R : TopCat.Presheaf C X) (f : P ⟶ Q) (g g' : Q ⟶ R),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStru... | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.Y_eq_of_equiv._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 1 = u * P 1 | null | false |
Equiv.invFun | Mathlib.Logic.Equiv.Defs | {α : Sort u_1} → {β : Sort u_2} → α ≃ β → β → α | The backward map of an equivalence.
Do NOT use `e.invFun` directly. Use the coercion of `e.symm` instead. | true |
Matrix.diagonalLinearMap._proof_1 | Mathlib.Data.Matrix.Basic | ∀ (n : Type u_2) (α : Type u_1) [inst : DecidableEq n] [inst_1 : AddCommMonoid α] (x y : n → α),
(↑(Matrix.diagonalAddMonoidHom n α)).toFun (x + y) =
(↑(Matrix.diagonalAddMonoidHom n α)).toFun x + (↑(Matrix.diagonalAddMonoidHom n α)).toFun y | null | false |
Turing.TM1.SupportsStmt.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (S : Finset Λ) (a : Γ → σ → Γ) (q : Turing.TM1.Stmt Γ Λ σ),
Turing.TM1.SupportsStmt S (Turing.TM1.Stmt.write a q) = Turing.TM1.SupportsStmt S q | null | true |
Mathlib.TacticAnalysis.Pass._sizeOf_inst | Mathlib.Tactic.TacticAnalysis | SizeOf Mathlib.TacticAnalysis.Pass | null | false |
Matrix.vecMul_empty | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {n' : Type uₙ} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype n'] (v : n' → α)
(B : Matrix n' (Fin 0) α), Matrix.vecMul v B = ![] | null | true |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_24 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} {a : α},
a ∈ l →
∀ (hl : l ≠ []),
¬l.length - (l.dropLast.length + 1) + 1 ≤ [l.getLast ⋯].dropLast.length →
l.length - (l.dropLast.length + [l.getLast ⋯].dropLast.length + 1) < [[l.getLast ⋯].getLast ⋯].length | null | false |
Ideal.exists_finset_card_eq_height_of_isNoetherianRing | Mathlib.RingTheory.Ideal.KrullsHeightTheorem | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] (p : Ideal R) [p.IsPrime],
∃ s, p ∈ (Ideal.span ↑s).minimalPrimes ∧ ↑s.card = p.height | If `p` is a prime in a Noetherian ring `R`, there exists a `p`-primary ideal `I`
spanned by `p.height` elements. | true |
NumberField.basisOfFractionalIdeal._proof_2 | Mathlib.NumberTheory.NumberField.FractionalIdeal | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
LinearMap.CompatibleSMul (↥↑↑I) K ℤ (NumberField.RingOfIntegers K) | null | false |
_private.Mathlib.Data.Fin.Tuple.Finset.0.Fin.mem_piFinset_iff_last_init._simp_1_2 | Mathlib.Data.Fin.Tuple.Finset | ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∀ (i : Fin (n + 1)), P i) = ((∀ (i : Fin n), P i.castSucc) ∧ P (Fin.last n)) | null | false |
Mathlib.Tactic.Widget.StringDiagram.PenroseVar.indices | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.PenroseVar → List ℕ | The indices of the variable. | true |
AddUnits.leftOfAdd.eq_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (a b : M) (hu : a + b = ↑u) (hc : AddCommute a b),
u.leftOfAdd a b hu hc = { val := a, neg := b + ↑(-u), val_neg := ⋯, neg_val := ⋯ } | null | true |
Subring.instField._proof_13 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] (x : ℚ≥0) (x_1 : ↥(Subring.center K)), ↑x * x_1 = ↑x * x_1 | null | false |
Lean.Meta.NormCast.NormCastExtension.up | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.NormCastExtension → Lean.Meta.SimpExtension | A simp set which lifts coercions to the top level. | true |
List.prod_inv_reverse | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : Group G] (L : List G), L.prod⁻¹ = (List.map (fun x => x⁻¹) L).reverse.prod | This is the `List.prod` version of `mul_inv_rev` | true |
CategoryTheory.Localization.Lifting | Mathlib.CategoryTheory.Localization.Predicate | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{E : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
CategoryTheory.Functor C D →
CategoryTheory.MorphismProperty C →
... | When `L : C ⥤ D` is a localization functor for `W : MorphismProperty C` and
`F : C ⥤ E` is a functor, we shall say that `F' : D ⥤ E` lifts `F` if the obvious diagram
is commutative up to an isomorphism. | true |
Equiv.prodAssoc.match_3 | Mathlib.Logic.Equiv.Prod | ∀ (α : Type u_1) (β : Type u_3) (γ : Type u_2) (motive : α × β × γ → Prop) (x : α × β × γ),
(∀ (fst : α) (fst_1 : β) (snd : γ), motive (fst, fst_1, snd)) → motive x | null | false |
Lean.Meta.Sym.Arith.ClassifyResult.commRing | Lean.Meta.Sym.Arith.Types | ℕ → Lean.Meta.Sym.Arith.ClassifyResult | null | true |
Std.Async.MaybeTask.ctorElimType | Std.Async.Basic | {α : Type} → {motive : Std.Async.MaybeTask α → Sort u} → ℕ → Sort (max 1 u) | null | false |
CategoryTheory.MorphismProperty.HasRightCalculusOfFractions.exists_rightFraction | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {W : CategoryTheory.MorphismProperty C}
[self : W.HasRightCalculusOfFractions] ⦃X Y : C⦄ (φ : W.LeftFraction X Y),
∃ ψ, CategoryTheory.CategoryStruct.comp ψ.s φ.f = CategoryTheory.CategoryStruct.comp ψ.f φ.s | null | true |
Ordinal.CNF.rec_pos | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (b : Ordinal.{u_2}) {o : Ordinal.{u_2}} {C : Ordinal.{u_2} → Sort u_1} (ho : o ≠ 0) (H0 : C 0)
(H : (o : Ordinal.{u_2}) → o ≠ 0 → C (o % b ^ Ordinal.log b o) → C o),
Ordinal.CNF.rec b H0 H o = H o ho (Ordinal.CNF.rec b H0 H (o % b ^ Ordinal.log b o)) | null | true |
Bundle.TotalSpace.toProd._proof_1 | Mathlib.Data.Bundle | ∀ (B : Type u_1) (F : Type u_2), Function.LeftInverse (fun x => ⟨x.1, x.2⟩) fun x => (x.proj, x.snd) | null | false |
CategoryTheory.Limits.prod.inl.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
[inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y],
CategoryTheory.Limits.prod.inl X Y = CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X) 0 | null | true |
Nat.succ_injective | Mathlib.Data.Nat.Basic | Function.Injective Nat.succ | null | true |
_private.Mathlib.RingTheory.Localization.Away.Basic.0.IsLocalization.Away.map_injective_iff._simp_1_1 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {M : Type u_1} [inst : Monoid M] (x z : M), (x ∈ Submonoid.powers z) = ∃ n, z ^ n = x | null | false |
Affine.Simplex.isCompact_closedInterior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_4} {V : Type u_5} {P : Type u_6} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [OrderClosedTopology 𝕜] [CompactIccSpace 𝕜] [ContinuousAdd 𝕜] [inst_7 : AddCommGroup V]
[inst_8 : TopologicalSpace V] [IsTopologicalAddGroup V] [inst_10 : Module 𝕜 ... | The closed interior of a simplex is compact. | true |
LinearMap.isBigOTVS_rev_comp | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} (g : E →ₗ[𝕜] F),
Filter.comap... | null | true |
_private.Mathlib.Algebra.BigOperators.ModEq.0.Int.prod_modEq_single._simp_1_1 | Mathlib.Algebra.BigOperators.ModEq | ∀ (a b : ℤ) (c : ℕ), (a ≡ b [ZMOD ↑c]) = (↑a = ↑b) | null | false |
CategoryTheory.Comma.unopFunctor_map | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) {X Y : CategoryTheory.Comma L.op R.op} (f : X ⟶ Y),
(CategoryTheory.... | null | true |
AddCommMonCat.recOn | Mathlib.Algebra.Category.MonCat.Basic | {motive : AddCommMonCat → Sort u_1} →
(t : AddCommMonCat) →
((carrier : Type u) → [str : AddCommMonoid carrier] → motive { carrier := carrier, str := str }) → motive t | null | false |
CommMonCat.FilteredColimits.forget_preservesFilteredColimits | Mathlib.Algebra.Category.MonCat.FilteredColimits | CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget CommMonCat) | null | true |
Subfield.sInf_toSubring | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} [inst : DivisionRing K] (s : Set (Subfield K)), (sInf s).toSubring = ⨅ t ∈ s, t.toSubring | null | true |
WeierstrassCurve.Projective.negDblY_eq' | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} {P : Fin 3 → R},
W'.Equation P →
W'.negDblY P * P 2 ^ 2 =
-(MvPolynomial.eval P) W'.polynomialX *
((MvPolynomial.eval P) W'.polynomialX ^ 2 -
W'.a₁ * (MvPolynomial.eval P) W'.polynomialX * P 2 * (P 1 - W'.neg... | null | true |
himp_iff_imp._simp_1 | Mathlib.Order.Heyting.Basic | ∀ (p q : Prop), p ⇨ q = (p → q) | null | false |
HasFiniteFPowerSeriesOnBall.rec | Mathlib.Analysis.Analytic.CPolynomialDef | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
{f : E → F} →
... | null | false |
_private.Mathlib.Probability.Distributions.SetBernoulli.0.ProbabilityTheory.setBernoulli_ae_subset._simp_1_2 | Mathlib.Probability.Distributions.SetBernoulli | ∀ {α : Type u_1} {s t : Set α}, (¬s ⊆ t) = ∃ x ∈ s, x ∉ t | null | false |
Set.biUnion_diff_biUnion_eq | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {ι : Type u_2} {s t : Set ι} {f : ι → Set α},
(s ∪ t).PairwiseDisjoint f → (⋃ i ∈ s, f i) \ ⋃ i ∈ t, f i = ⋃ i ∈ s \ t, f i | **Alias** of `Set.biUnion_sdiff_biUnion_eq`. | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processId._sparseCasesOn_1 | Lean.Elab.PatternVar | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (Lean.ConstantInfo.ctorInfo val)) →
(Nat.hasNotBit 64 t.ctorIdx → motive t) → motive t | null | false |
Complex.im_mul_ofReal | Mathlib.Data.Complex.Basic | ∀ (z : ℂ) (r : ℝ), (z * ↑r).im = z.im * r | null | true |
ConvexOn.exists_lipschitzOnWith_of_isBounded | Mathlib.Analysis.Convex.Continuous | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x₀ : E} {r r' : ℝ},
ConvexOn ℝ (Metric.ball x₀ r) f →
r' < r → Bornology.IsBounded (f '' Metric.ball x₀ r) → ∃ K, LipschitzOnWith K f (Metric.ball x₀ r') | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Images.0.CategoryTheory.Limits.image.map_id._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
_private.Mathlib.Data.Finset.NAry.0.Finset.mem_image₂._simp_1_2 | Mathlib.Data.Finset.NAry | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Mathlib.Tactic.WLOGResult.reductionGoal | Mathlib.Tactic.WLOG | Mathlib.Tactic.WLOGResult → Lean.MVarId | The `reductionGoal` requires showing that the case `h : ¬ P` can be reduced to the case where
`P` holds. It has two additional assumptions in its context:
* `h : ¬ P`: the assumption that `P` does not hold
* `H`: the statement that in the original context `P` suffices to prove the goal.
| true |
LinearMap.instSMulCommClassWithConvId | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} {C : Type u_5} [inst : CommSemiring R]
[inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A] [inst_3 : SMulCommClass R A A]
[inst_4 : IsScalarTower R A A] [inst_5 : AddCommMonoid C] [inst_6 : Module R C] [inst_7 : CoalgebraStruct R C]
[inst_8 : Monoid S] [inst... | null | true |
NumberField.RingOfIntegers.mapAlgEquiv._proof_1 | Mathlib.NumberTheory.NumberField.Basic | ∀ {k : Type u_2} {K : Type u_3} {L : Type u_4} {E : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra k K] [inst_4 : Algebra k L] [inst_5 : EquivLike E K L] [AlgEquivClass E k K L], AlgHomClass E k K L | null | false |
_private.Mathlib.Analysis.Convex.Function.0.OrderIso.strictConvexOn_symm._simp_1_1 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u_1} [inst : LT α] {x y : α}, (x > y) = (y < x) | null | false |
Std.HashMap.getD_eq_fallback_of_contains_eq_false | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {a : α}
{fallback : β}, m.contains a = false → m.getD a fallback = fallback | null | true |
CategoryTheory.Triangulated.SpectralObject.ω₂_map_hom₃ | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {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.Limits.HasZeroObject C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Addit... | null | true |
Pi.instBiheytingAlgebra._proof_1 | Mathlib.Order.Heyting.Basic | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → BiheytingAlgebra (α i)] (a b c : (i : ι) → α i),
a \ b ≤ c ↔ a ≤ b ⊔ c | null | false |
Interval.commMonoid._proof_5 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (a : Interval α), a * 1 = a | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Dual.0.InnerProductSpace.toDual._simp_5 | Mathlib.Analysis.InnerProductSpace.Dual | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.Functor.isoWhiskerRight_twice | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {H K : CategoryTheory.Functor B C} (F : CategoryTheory.Functor C D)
(G : C... | null | true |
ContinuousMap.concat | Mathlib.Topology.ContinuousMap.Interval | {α : Type u_1} →
[inst : LinearOrder α] →
[inst_1 : TopologicalSpace α] →
[OrderTopology α] →
{a b c : α} →
[Fact (a ≤ b)] →
[Fact (b ≤ c)] →
{E : Type u_2} →
[inst_5 : TopologicalSpace E] → C(↑(Set.Icc a b), E) → C(↑(Set.Icc b c), E) → C(↑(Set.Icc... | The concatenation of two continuous maps defined on adjacent intervals. If the values of the
functions on the common bound do not agree, this is defined as an arbitrarily chosen constant
map. See `concatCM` for the corresponding map on the subtype of compatible function pairs. | true |
jacobiSum_one_one | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {F : Type u_1} {R : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : CommRing R],
jacobiSum 1 1 = ↑(Fintype.card F) - 2 | If `1` is the trivial multiplicative character on a finite field `F`, then `J(1,1) = #F-2`. | true |
CategoryTheory.Equivalence.mapAddGrp_counitIso | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(e : C ≌ D) [inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal],
e.mapAddGrp.c... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.