name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Subset.congr_right.match_1_5 | Mathlib.SetTheory.ZFC.PSet | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (α_1 : Type u_1) (A_1 : α_1 → PSet.{u_1}) (b : (PSet.mk α_1 A_1).Type)
(motive : (∃ a, (A a).Equiv (A_1 b)) → Prop) (x : ∃ a, (A a).Equiv (A_1 b)),
(∀ (a : α) (ab : (A a).Equiv (A_1 b)), motive ⋯) → motive x | null | false |
Prod.smulZeroClass | Mathlib.Algebra.GroupWithZero.Action.Prod | {R : Type u_5} →
{M : Type u_6} →
{N : Type u_7} →
[inst : Zero M] → [inst_1 : Zero N] → [SMulZeroClass R M] → [SMulZeroClass R N] → SMulZeroClass R (M × N) | null | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.signVariations_eraseLead_mul_X_sub_C._proof_1_1 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] {P : Polynomial R} {η : R} (d : ℕ),
P.natDegree = d + 1 →
((Polynomial.X - Polynomial.C η) * P).natDegree = P.natDegree + 1 →
((Polynomial.X - Polynomial.C η) * P).nextCoeff = P.coeff d - η * P.coeff (d + 1) | null | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs.0.isLinearSet_iff._simp_1_2 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {α : Type u} {p : Finset α → Prop}, (∃ s, p s) = ∃ s, ∃ (hs : s.Finite), p hs.toFinset | null | false |
_private.Lean.Meta.UnificationHint.0.Lean.Meta.initFn._@.Lean.Meta.UnificationHint.1858784148._hygCtx._hyg.2 | Lean.Meta.UnificationHint | IO (Lean.SimpleScopedEnvExtension Lean.Meta.UnificationHintEntry Lean.Meta.UnificationHints) | null | false |
IsPurelyInseparable.tower_bot | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [IsPurelyInseparable F K], IsPurelyInseparable F E | If `K / E / F` is a field extension tower such that `K / F` is purely inseparable,
then `E / F` is also purely inseparable. | true |
Function.locallyFinsuppWithin.instAddCommGroup._proof_7 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y]
(D : Function.locallyFinsuppWithin U Y) (n : ℤ), ⇑(n • D) = n • ⇑D | null | false |
SimpleGraph.Walk.length_ofSupport | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {l : List V} (hne : l ≠ []) (hchain : List.IsChain G.Adj l),
(SimpleGraph.Walk.ofSupport l hne hchain).length = l.length - 1 | null | true |
EuclideanDomain.wellFoundedRelation | Mathlib.Algebra.EuclideanDomain.Defs | {R : Type u} → [EuclideanDomain R] → WellFoundedRelation R | null | true |
CategoryTheory.Limits.image.lift_mk_factorThruImage_assoc | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasImage f] {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.image.lift
{ I := CategoryTheory.Limits.image f, m := CategoryTheory.Limits.image.ι f, m_mono := ⋯,
... | null | true |
Std.Http.Status.notFound.sizeOf_spec | Std.Http.Data.Status | sizeOf Std.Http.Status.notFound = 1 | null | true |
UInt64.toUSize_mod_of_dvd_usizeSize | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), b.toNat ∣ USize.size → (a % b).toUSize = a.toUSize % b.toUSize | null | true |
_private.Mathlib.Order.SuccPred.LinearLocallyFinite.0.toZ_neg._proof_1_1 | Mathlib.Order.SuccPred.LinearLocallyFinite | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] [inst_2 : IsSuccArchimedean ι] [inst_3 : PredOrder ι]
{i0 i : ι}, i < i0 → ∃ n, Order.pred^[n] i0 = i | null | false |
Lean.Lsp.Location._sizeOf_1 | Lean.Data.Lsp.Basic | Lean.Lsp.Location → ℕ | null | false |
Lean.Order.prop_pre_intro | Std.Internal.Do.Assertion | ∀ (x y : Prop), (x → Lean.Order.PartialOrder.rel True y) → Lean.Order.PartialOrder.rel x y | null | true |
Lean.DataValue.recOn | Lean.Data.KVMap | {motive : Lean.DataValue → Sort u} →
(t : Lean.DataValue) →
((v : String) → motive (Lean.DataValue.ofString v)) →
((v : Bool) → motive (Lean.DataValue.ofBool v)) →
((v : Lean.Name) → motive (Lean.DataValue.ofName v)) →
((v : ℕ) → motive (Lean.DataValue.ofNat v)) →
((v : ℤ) → mo... | null | false |
Complex.dist_of_im_eq | Mathlib.Analysis.Complex.Norm | ∀ {z w : ℂ}, z.im = w.im → dist z w = dist z.re w.re | null | true |
Real.tendsto_eulerMascheroniSeq' | Mathlib.NumberTheory.Harmonic.EulerMascheroni | Filter.Tendsto Real.eulerMascheroniSeq' Filter.atTop (nhds Real.eulerMascheroniConstant) | null | true |
Perfection.lift | Mathlib.RingTheory.Perfection | (p : ℕ) →
[hp : Fact (Nat.Prime p)] →
(R : Type u₁) →
[inst : CommSemiring R] →
[CharP R p] →
[PerfectRing R p] →
(S : Type u₂) → [inst_3 : CommSemiring S] → [inst_4 : CharP S p] → (R →+* S) ≃ (R →+* Perfection S p) | Given rings `R` and `S` of characteristic `p`, with `R` being perfect,
any homomorphism `R →+* S` can be lifted to a homomorphism `R →+* Perfection S p`. | true |
Submonoid.mem_saturation_iff | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : CommMonoid M] {s : Submonoid M} {x : M}, x ∈ s.saturation ↔ ∃ y, x * y ∈ s | null | true |
Polynomial.instFree | Mathlib.LinearAlgebra.Finsupp.VectorSpace | ∀ {R : Type u_1} [inst : Semiring R], Module.Free R (Polynomial R) | null | true |
Polynomial.separable_C_mul_X_pow_add_C_mul_X_add_C | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommRing R] {n : ℕ} (a b c : R),
↑n = 0 → IsUnit b → (Polynomial.C a * Polynomial.X ^ n + Polynomial.C b * Polynomial.X + Polynomial.C c).Separable | If `n = 0` in `R` and `b` is a unit, then `a * X ^ n + b * X + c` is separable. | true |
vadd_mem_nhds_self._simp_1 | Mathlib.Topology.Algebra.ConstMulAction | ∀ {G : Type u_4} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [ContinuousConstVAdd G G] {g : G} {s : Set G},
(g +ᵥ s ∈ nhds g) = (s ∈ nhds 0) | null | false |
CategoryTheory.ShortComplex.π₂_map | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.ShortComplex C} (f : X ⟶ Y), CategoryTheory.ShortComplex.π₂.map f = f.τ₂ | null | true |
Filter.Tendsto.add_atBot | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : AddCommGroup α] [inst_2 : LinearOrder α]
[IsOrderedAddMonoid α] [OrderTopology α] {l : Filter β} {f g : β → α} {C : α},
Filter.Tendsto f l (nhds C) → Filter.Tendsto g l Filter.atBot → Filter.Tendsto (fun x => f x + g x) l Filter.atBot | In a linearly ordered additive commutative group with the order
topology, if `f` tends to `C` and `g` tends to `atBot` then `f + g` tends to `atBot`. | true |
_private.Aesop.Script.StructureStatic.0.Aesop.Script.StaticStructureM.run._proof_2 | Aesop.Script.StructureStatic | ∀ (script : Aesop.Script.UScript) (i : ℕ) (h : i ∈ [:Array.size script]),
script[i].postGoals.size = 1 → 0 < script[i].postGoals.size | null | false |
Int.floor_lt_ceil_of_lt | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsOrderedRing R] {a b : R},
a < b → ⌊a⌋ < ⌈b⌉ | null | true |
zpow_mod_orderOf | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Group G] (x : G) (z : ℤ), x ^ (z % ↑(orderOf x)) = x ^ z | null | true |
MeasureTheory.volume_pi_ball | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasureTheory.MeasureSpace (α i)]
[∀ (i : ι), MeasureTheory.SigmaFinite MeasureTheory.volume] [inst_3 : (i : ι) → MetricSpace (α i)] (x : (i : ι) → α i)
{r : ℝ}, 0 < r → MeasureTheory.volume (Metric.ball x r) = ∏ i, MeasureTheory.volume (Met... | null | true |
Matrix.instNonAssocRing._proof_5 | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_1} {α : Type u_2} [inst : DecidableEq n] [inst_1 : NonAssocRing α] (a : Matrix n n α), -a + a = 0 | null | false |
Dioph._aux_Mathlib_NumberTheory_Dioph___unexpand_Dioph_eq_dioph_1 | Mathlib.NumberTheory.Dioph | Lean.PrettyPrinter.Unexpander | null | false |
Std.Net.IPv4Addr.octets | Std.Net.Addr | Std.Net.IPv4Addr → Vector UInt8 4 | This structure represents the address: `octets[0].octets[1].octets[2].octets[3]`.
| true |
Nat.prod_mem_smoothNumbers | Mathlib.NumberTheory.SmoothNumbers | ∀ (n N : ℕ), (List.filter (fun x => decide (x < N)) n.primeFactorsList).prod ∈ N.smoothNumbers | The product of the prime factors of `n` that are less than `N` is an `N`-smooth number. | true |
CategoryTheory.Functor.FullyFaithful.addMonObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.OplaxMonoidal] (hF : F.FullyFaithful) (X : C)
[inst_5... | null | false |
CategoryTheory.Functor.IsIso | Mathlib.CategoryTheory.IsoCat | {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] → CategoryTheory.Functor C D → Prop | A functor `F : C ⥤ D` is an isomorphism of categories if it is full, faithful and
bijective on objects. Such a functor has a strict inverse `Functor.strictInv` and assembles
into an `IsoCat` via `Functor.asIsomorphism`. | true |
String.Pos.isUTF8FirstByte_getUTF8Byte_offset | Init.Data.String.Lemmas.Order | ∀ {s : String} {p : s.Pos} {h : p.offset < s.rawEndPos}, (s.getUTF8Byte p.offset h).IsUTF8FirstByte | null | true |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex.0.NumberField.nrComplexPlaces_eq_zero_iff._simp_1_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ {α : Sort u_1} (p : α → Prop), IsEmpty (Subtype p) = ∀ (x : α), ¬p x | null | false |
_private.Mathlib.Data.Finset.Sym.0.Finset.not_isDiag_mk_of_mem_offDiag._proof_1_1 | Mathlib.Data.Finset.Sym | ∀ {α : Type u_1} {s : Finset α} {a b : α}, a ∈ s ∧ b ∈ s ∧ ¬a = b → ¬a = b | null | false |
FintypeCat.instFiniteAut | Mathlib.CategoryTheory.FintypeCat | ∀ (X : FintypeCat), Finite (CategoryTheory.Aut X) | null | true |
AdicCompletion.isAdicCauchy_iff | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(f : ℕ → M), AdicCompletion.IsAdicCauchy I M f ↔ ∀ (n : ℕ), f n ≡ f (n + 1) [SMOD I ^ n • ⊤] | The `I`-adic Cauchy condition can be checked on successive `n`. | true |
CategoryTheory.Functor.PullbackObjObj.mapArrowRight._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_2} {C₃ : Type u_4} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_3, u_4} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ : CategoryTheory.Arrow C₁}
{f₃ f₃' : CategoryTheor... | null | false |
_private.Std.Time.Date.Unit.Year.0.Std.Time.Year.instReprEra.repr.match_1 | Std.Time.Date.Unit.Year | (motive : Std.Time.Year.Era → Sort u_1) →
(x : Std.Time.Year.Era) → (Unit → motive Std.Time.Year.Era.bce) → (Unit → motive Std.Time.Year.Era.ce) → motive x | null | false |
Filter.map_neg | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Neg α] {f : Filter α}, Filter.map Neg.neg f = -f | null | true |
DirectLimit.instMulActionOfMulActionHomClass._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{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 : Monoid R]
... | null | false |
_private.Mathlib.Data.Seq.Parallel.0.Computation.parallel.aux1.match_1.eq_3 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u_1} (motive : Option (Stream'.Seq1 (Option (Computation α))) → Sort u_2) (c : Computation α)
(S' : Stream'.Seq (Option (Computation α))) (h_1 : Unit → motive none)
(h_2 : (S' : Stream'.Seq (Option (Computation α))) → motive (some (none, S')))
(h_3 : (c : Computation α) → (S' : Stream'.Seq (Option (Co... | null | true |
CategoryTheory.Retract.trans._proof_2 | Mathlib.CategoryTheory.Retract | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (h : CategoryTheory.Retract X Y) {Z : C}
(h' : CategoryTheory.Retract Y Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h.i h'.i)
(CategoryTheory.CategoryStruct.comp h'.r h.r) =
CategoryTheory.CategoryStruc... | null | false |
Subsemiring.centralizer_eq_top_iff_subset | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R] {s : Set R}, Subsemiring.centralizer s = ⊤ ↔ s ⊆ ↑(Subsemiring.center R) | null | true |
VAdd.mk._flat_ctor | Mathlib.Algebra.Notation.Defs | {G : Type u} → {P : Type v} → (G → P → P) → VAdd G P | null | false |
Std.Rxc.LawfulHasSize.size_eq_succ_of_succ?_eq_some | Init.Data.Range.Polymorphic.Basic | ∀ {α : Type u} {inst : LE α} {inst_1 : Std.PRange.UpwardEnumerable α} {inst_2 : Std.Rxc.HasSize α}
[self : Std.Rxc.LawfulHasSize α] (lo hi lo' : α),
lo ≤ hi → Std.PRange.succ? lo = some lo' → Std.Rxc.HasSize.size lo hi = Std.Rxc.HasSize.size lo' hi + 1 | If the smallest value in the range satisfies the upper bound and has a successor, the size is
one larger than the size of the range starting at the successor. | true |
Lean.Meta.Grind.Arith.CommRing.CommSemiring.noConfusionType | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Sort u → Lean.Meta.Grind.Arith.CommRing.CommSemiring → Lean.Meta.Grind.Arith.CommRing.CommSemiring → Sort u | null | false |
right_eq_ite_iff | Init.PropLemmas | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, (y = if p then x else y) ↔ p → y = x | null | true |
Finsupp.uniqueLinearEquiv_symm_apply | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ (R : Type u_1) {α : Type u_3} (M : Type u_4) [inst : AddCommMonoid M] [inst_1 : Semiring R] [inst_2 : Module R M]
[inst_3 : Subsingleton α] (a : α) (a_1 : M), (Finsupp.uniqueLinearEquiv R M a).symm a_1 = fun₀ | a => a_1 | null | true |
isDedekindDomain_iff | Mathlib.RingTheory.DedekindDomain.Basic | ∀ (A : Type u_2) [inst : CommRing A] (K : Type u_4) [inst_1 : CommRing K] [inst_2 : Algebra A K] [IsFractionRing A K],
IsDedekindDomain A ↔
IsDomain A ∧ IsNoetherianRing A ∧ Ring.DimensionLEOne A ∧ ∀ {x : K}, IsIntegral A x → ∃ y, (algebraMap A K) y = x | An integral domain is a Dedekind domain iff and only if it is
Noetherian, has dimension ≤ 1, and is integrally closed in a given fraction field.
In particular, this definition does not depend on the choice of this fraction field. | true |
Std.Do.SPred.forall_nil | Std.Do.SPred.SPred | ∀ {α : Sort u_1} {P : α → Std.Do.SPred []}, Std.Do.SPred.forall P = { down := ∀ (a : α), (P a).down } | null | true |
AddSubgroup.index_pi | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_3} [inst_1 : Fintype ι] (H : ι → AddSubgroup G),
(AddSubgroup.pi Set.univ H).index = ∏ i, (H i).index | null | true |
_private.Mathlib.CategoryTheory.Shift.ShiftSequence.0.CategoryTheory.Functor.ShiftSequence.tautological._simp_4 | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | null | false |
Real.summable_Lp_add_of_nonneg | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} {f g : ι → ℝ} {p : ℝ},
1 ≤ p →
(∀ (i : ι), 0 ≤ f i) →
(∀ (i : ι), 0 ≤ g i) →
(Summable fun i => f i ^ p) → (Summable fun i => g i ^ p) → Summable fun i => (f i + g i) ^ p | null | true |
Finset.prod_eq_prod_sdiff_singleton_mul | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] [inst_1 : DecidableEq ι] {s : Finset ι} {i : ι},
i ∈ s → ∀ (f : ι → M), ∏ x ∈ s, f x = (∏ x ∈ s \ {i}, f x) * f i | null | true |
Std.DTreeMap.Internal.Impl.insert._proof_24 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced →
∀ (d : Std.DTreeMap.Internal.Impl α β),
r'.size ≤ d.size → d.size ≤ r'.size + 1 → Std.DTreeMap.Internal.Impl.BalanceLPrecond d.size l'.size | null | false |
CategoryTheory.Iso.coreLeftUnitor | Mathlib.CategoryTheory.Core | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D},
F.leftUnitor.core =
(CategoryTheory.Functor.id C).coreComp F ≪≫
CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.Functor.coreId C) F.core ≪≫ F.cor... | null | true |
Lean.Elab.Tactic.ResolveSimpIdResult._sizeOf_1 | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.ResolveSimpIdResult → ℕ | null | false |
Seminorm.closedBall_zero' | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E] {r : ℝ} (x : E),
0 < r → Seminorm.closedBall 0 x r = Set.univ | null | true |
_private.Mathlib.Algebra.NoZeroSMulDivisors.Defs.0.instIsTorsionFreeOfIsDomainOfNoZeroSMulDivisors._simp_1 | Mathlib.Algebra.NoZeroSMulDivisors.Defs | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Encodable.decidableRangeEncode.match_1 | Mathlib.Logic.Encodable.Basic | ∀ (α : Type u_1) [inst : Encodable α] (x : ℕ) (motive : x ∈ Set.range Encodable.encode → Prop)
(x_1 : x ∈ Set.range Encodable.encode), (∀ (n : α) (hn : Encodable.encode n = x), motive ⋯) → motive x_1 | null | false |
Polynomial.coeff_hermite_succ_zero | Mathlib.RingTheory.Polynomial.Hermite.Basic | ∀ (n : ℕ), (Polynomial.hermite (n + 1)).coeff 0 = -(Polynomial.hermite n).coeff 1 | null | true |
Cross.lieRing._proof_1 | Mathlib.LinearAlgebra.CrossProduct | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R (Fin 3 → R) | null | false |
SimpleGraph.Copy.mapNeighborSet | Mathlib.Combinatorics.SimpleGraph.Copy | {α : Type u_4} →
{β : Type u_5} →
{A : SimpleGraph α} → {B : SimpleGraph β} → (f : A.Copy B) → (a : α) → ↑(A.neighborSet a) ↪ ↑(B.neighborSet (f a)) | A copy induces an embedding of neighbor sets. | true |
WithVal.instOne | Mathlib.Topology.Algebra.Valued.WithVal | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : LinearOrderedCommGroupWithZero Γ₀] → [inst_1 : Ring R] → (v : Valuation R Γ₀) → One (WithVal v) | null | true |
CategoryTheory.ShortComplex.ShortExact.singleTriangleIso._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C] (n a a' : ℤ),
n + a = a' →
∀ (X : C) (i : ℤ),
(((HomologicalComplex.single C (ComplexShape.up ℤ) a').comp
(CategoryTheory.shiftFunctor (CochainComplex C ℤ) n)).obj
X).X
... | null | false |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.isNonarchimedean_smoothingFun._simp_1_1 | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
AffineSubspace.sSameSide_vadd_left_iff | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y : P} {v : V}, v ∈ s.direction → (s.SSameSide (v +ᵥ x) y ↔ s.SSameSide x y) | null | true |
Rat.instMetricSpace._proof_5 | Mathlib.Topology.Instances.Rat | autoParam (uniformity ℚ = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε})
PseudoMetricSpace.uniformity_dist._autoParam | null | false |
_private.Mathlib.Algebra.Order.Antidiag.Pi.0.Finset.mem_piAntidiag._proof_1_4 | Mathlib.Algebra.Order.Antidiag.Pi | ∀ {ι : Type u_1} {μ : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] {s : Finset ι} {f : ι → μ}
(e : ↥s ≃ Fin s.card),
(∀ (i : ι), f i ≠ 0 → i ∈ s) → (fun i => if hi : i ∈ s then (f ∘ Subtype.val ∘ ⇑e.symm) (e ⟨i, hi⟩) else 0) = f | null | false |
CategoryTheory.nerve.homEquiv._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {x y : CategoryTheory.ComposableArrows C 0}
(f : CategoryTheory.nerveEquiv x ⟶ CategoryTheory.nerveEquiv y),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ (CategoryTheory.nerve C) 0))
(CategoryTheory.ComposableArrows.mk₁ ... | null | false |
_private.Init.Data.Nat.Lemmas.0.Nat.lt_of_add_lt_add_right.match_1_1 | Init.Data.Nat.Lemmas | ∀ {k m : ℕ} (motive : (x : ℕ) → k + x < m + x → Prop) (x : ℕ) (x_1 : k + x < m + x),
(∀ (h : k + 0 < m + 0), motive 0 h) → (∀ (n : ℕ) (h : k + (n + 1) < m + (n + 1)), motive n.succ h) → motive x x_1 | null | false |
if_true | Init.ByCases | ∀ {α : Sort u_1} {x : Decidable True} (t e : α), (if True then t else e) = t | null | true |
BitVec.cpopNatRec_allOnes | Init.Data.BitVec.Lemmas | ∀ {n w acc : ℕ}, n ≤ w → (BitVec.allOnes w).cpopNatRec n acc = acc + n | null | true |
Std.Slice.length_iter_eq_size | Std.Data.Iterators.Lemmas.Producers.Slice | ∀ {γ : Type u} {α β : Type v} [inst : Std.ToIterator (Std.Slice γ) Id α β] [inst_1 : Std.Iterator α Id β]
{s : Std.Slice γ} [Std.Iterators.Finite α Id] [inst_3 : Std.IteratorLoop α Id Id] [Std.LawfulIteratorLoop α Id Id]
[inst_5 : Std.Slice.SliceSize γ] [Std.Slice.LawfulSliceSize γ], s.iter.length = s.size | null | true |
Subsemiring.mk'.congr_simp | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} [inst : NonAssocSemiring R] (s s_1 : Set R) (e_s : s = s_1) (sm sm_1 : Submonoid R) (e_sm : sm = sm_1)
(hm : ↑sm = s) (sa sa_1 : AddSubmonoid R) (e_sa : sa = sa_1) (ha : ↑sa = s),
Subsemiring.mk' s sm hm sa ha = Subsemiring.mk' s_1 sm_1 ⋯ sa_1 ⋯ | null | true |
ZFSet.coe_union._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x y : ZFSet.{u}), ↑x ∪ ↑y = ↑(x ∪ y) | null | false |
Computation.LiftRel.swap | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (cb : Computation β),
Computation.LiftRel (Function.swap R) cb ca ↔ Computation.LiftRel R ca cb | null | true |
IsAddConj.setoid.eq_1 | Mathlib.Algebra.Group.Conj | ∀ (α : Type u_1) [inst : AddMonoid α], IsAddConj.setoid α = { r := IsAddConj, iseqv := ⋯ } | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_invalid_of_isInvalidContinuationByte_eq_false | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.isInvalidContinuationByte b = false →
ByteArray.utf8DecodeChar?.parseFirstByte b = ByteArray.utf8DecodeChar?.FirstByte.invalid | null | true |
Lean.EnvExtension.instInhabitedAsyncMode | Lean.Environment | Inhabited Lean.EnvExtension.AsyncMode | null | true |
Filter.tendsto_inv₀_cobounded | Mathlib.Analysis.Normed.Field.Lemmas | ∀ {α : Type u_1} [inst : NormedDivisionRing α], Filter.Tendsto Inv.inv (Bornology.cobounded α) (nhds 0) | null | true |
_private.Mathlib.Analysis.Normed.Lp.lpSpace.0.Memℓp.const_smul._simp_1_5 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {x y : NNReal} {z : ℝ}, x ^ z * y ^ z = (x * y) ^ z | null | false |
Nat.factorial_pos._f | Mathlib.Data.Nat.Factorial.Basic | ∀ (x : ℕ) (f : Nat.below x), 0 < x.factorial | null | false |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.restrict_empty._simp_1_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M : Matroid α}, (M = Matroid.emptyOn α) = (M.E = ∅) | null | false |
_private.Mathlib.Topology.Algebra.OpenSubgroup.0.IsTopologicalAddGroup.exist_add_closure_nhds.match_1_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] {W : Set G} (x : Set G)
(motive : (∃ T ∈ nhds 0, x + T ⊆ W) → Prop) (x_1 : ∃ T ∈ nhds 0, x + T ⊆ W),
(∀ (T : Set G) (hT : T ∈ nhds 0) (mem : x + T ⊆ W), motive ⋯) → motive x_1 | null | false |
CategoryTheory.SingleFunctors.postcomp._proof_1 | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_6} {E : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] [inst_2 : CategoryTheory.Category.{u_2, u_3} E] {A : Type u_7}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : Cate... | null | false |
Aesop.LIFOQueue.mk.sizeOf_spec | Aesop.Search.Queue | ∀ (goals : Array Aesop.GoalRef), sizeOf { goals := goals } = 1 + sizeOf goals | null | true |
_private.Lean.Meta.Tactic.Grind.SimpUtil.0.Lean.Meta.Grind.reduceCtorEqCheap._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.SimpUtil | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
IO.Promise.noConfusion | Init.System.Promise | {P : Sort u} →
{α : Type} →
{t : IO.Promise α} → {α' : Type} → {t' : IO.Promise α'} → α = α' → t ≍ t' → IO.Promise.noConfusionType P t t' | null | false |
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalConv._regBuiltin.Lean.Elab.Tactic.Conv.evalConv.declRange_3 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
ZMod.instFiniteZModUnits | Mathlib.Data.ZMod.Units | ∀ (n : ℕ), Finite (ZMod n)ˣ | For each `n ≥ 0`, the unit group of `ZMod n` is finite. | true |
Sep.mk.noConfusion | Init.Core | {α : outParam (Type u)} →
{γ : Type v} →
{P : Sort u_1} → {sep sep' : (α → Prop) → γ → γ} → { sep := sep } = { sep := sep' } → (sep ≍ sep' → P) → P | null | false |
Polynomial.coeffList.eq_1 | Mathlib.Algebra.Polynomial.CoeffList | ∀ {R : Type u_1} [inst : Semiring R] (P : Polynomial R),
P.coeffList = List.map P.coeff (List.range P.degree.succ).reverse | null | true |
Module.restrictScalars | Mathlib.Algebra.Algebra.RestrictScalars | (R : Type u_1) →
(S : Type u_2) →
(M : Type u_3) →
[inst : Semiring S] →
[inst_1 : AddCommMonoid M] → [inst_2 : CommSemiring R] → [Algebra R S] → [Module S M] → Module R M | When `M` is a module over a ring `S`, and `S` is an algebra over `R`, then `M` inherits a
module structure over `R`. Not an instance because `S` cannot be inferred.
The preferred way of setting this up is `[Module R M] [Module S M] [IsScalarTower R S M]`.
| true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.copyInstanceAttribute.match_1 | Mathlib.Tactic.Translate.Core | (motive : Lean.ReducibilityStatus → Sort u_1) →
(__do_lift : Lean.ReducibilityStatus) →
(Unit → motive Lean.ReducibilityStatus.implicitReducible) →
((x : Lean.ReducibilityStatus) → motive x) → motive __do_lift | null | false |
Rep.linearization._proof_4 | Mathlib.RepresentationTheory.Rep.Basic | ∀ (k : Type u_3) (G : Type u_2) [inst : CommRing k] [inst_1 : Monoid G] {X Y Z : Action (Type u_1) G} (f : X ⟶ Y)
(g : Y ⟶ Z),
Rep.ofHom (Representation.linearizeMap (CategoryTheory.CategoryStruct.comp f g)) =
CategoryTheory.CategoryStruct.comp (Rep.ofHom (Representation.linearizeMap f))
(Rep.ofHom (Repre... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.