name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SSet.stdSimplex.faceRepresentableBy._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (S : Finset (Fin (n + 1))) (m : ℕ) (e : Fin (m + 1) ≃o ↥S) {j : SimplexCategory}
(x : (SSet.stdSimplex.face S).toSSet.obj (Opposite.op j)),
∀
x_1 ∈
Finset.image
⇑(SimplexCategory.Hom.toOrderHom
(SSet.stdSimplex.objEquiv
(SSet.stdSimplex.objMk
((O... | null | false |
MulArchimedean.of_locallyFiniteOrder | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_2} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] [LocallyFiniteOrder G],
MulArchimedean G | Any locally finite linear group is mul-archimedean. | true |
PythagoreanTriple.isPrimitiveClassified_of_coprime | Mathlib.NumberTheory.PythagoreanTriples | ∀ {x y z : ℤ} (h : PythagoreanTriple x y z), x.gcd y = 1 → h.IsPrimitiveClassified | null | true |
Lean.Elab.Tactic.UnusedSimpArgsInfo._sizeOf_inst | Lean.Elab.Tactic.Simp | SizeOf Lean.Elab.Tactic.UnusedSimpArgsInfo | null | false |
PrimeSpectrum.ConstructibleSetData.map_id | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} [inst : CommSemiring R] (s : PrimeSpectrum.ConstructibleSetData R),
PrimeSpectrum.ConstructibleSetData.map (RingHom.id R) s = s | null | true |
Lean.Grind.CommRing.SPolResult.m₂ | Lean.Meta.Sym.Arith.Poly | Lean.Grind.CommRing.SPolResult → Lean.Grind.CommRing.Mon | Monomial factor applied to polynomial `p₂`. | true |
_private.Mathlib.Algebra.MonoidAlgebra.Support.0.MonoidAlgebra.support_single_mul._simp_1_1 | Mathlib.Algebra.MonoidAlgebra.Support | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
LinearMap.linearEquivOfInjective.congr_simp | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {V₂ : Type v'}
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] [inst_5 : FiniteDimensional K V] [inst_6 : FiniteDimensional K V₂]
(f f_1 : V →ₗ[K] V₂) (e_f : f = f_1) (hf : Function.Injective ⇑f) (hdim : Module.fin... | null | true |
instInhabitedAddMonoidHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : AddZero M] [inst_1 : AddZeroClass N],
instInhabitedAddMonoidHom = { default := 0 } | null | true |
CategoryTheory.CostructuredArrow.prodInverse._proof_1 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_7} [inst : CategoryTheory.Category.{u_5, u_7} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] {C' : Type u_8} [inst_2 : CategoryTheory.Category.{u_6, u_8} C']
{D' : Type u_4} [inst_3 : CategoryTheory.Category.{u_2, u_4} D'] (S : CategoryTheory.Functor C D)
(S' : CategoryTheory.Func... | null | false |
_private.Mathlib.NumberTheory.Primorial.0.Nat.Prime.dvd_primorial_iff._proof_1_1 | Mathlib.NumberTheory.Primorial | ∀ {p n : ℕ}, Nat.Prime p → p ≤ n → p ∈ {p ∈ Finset.range (n + 1) | Nat.Prime p} | null | false |
Option.get_dite | Init.Data.Option.Lemmas | ∀ {β : Type u_1} {p : Prop} {x : Decidable p} (b : p → β) (w : (if h : p then some (b h) else none).isSome = true),
(if h : p then some (b h) else none).get w = b ⋯ | null | true |
CategoryTheory.LocalizerMorphism.LeftResolution.opFunctor_obj | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) (X₂ : C₂)
(L : (Φ.LeftResolution X₂)ᵒᵖ),
(CategoryThe... | null | true |
Matrix.IsSelfAdjoint.eq_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} [inst : CommRing R] [inst_1 : Fintype n] (J A₁ : Matrix n n R),
J.IsSelfAdjoint A₁ = J.IsAdjointPair J A₁ A₁ | null | true |
Finset.insert_inj_on | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), Set.InjOn (fun a => insert a s) (↑s)ᶜ | null | true |
Subrepresentation.mk.injEq | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : Semiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} (toSubmodule : Submodule A W)
(apply_mem_toSubmodule : ∀ (g : G) ⦃v : W⦄, v ∈ toSubmodule → (ρ g) v ∈ toSubmodule) (toSubmodule_1 : Submodule A W)
(app... | null | true |
_private.Init.Data.List.Zip.0.List.map_snd_zip.match_1_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : List α) → (x_1 : List β) → x_1.length ≤ x.length → Prop) (x : List α)
(x_1 : List β) (x_2 : x_1.length ≤ x.length),
(∀ (x : List α) (x_3 : [].length ≤ x.length), motive x [] x_3) →
(∀ (b : β) (bs : List β) (h : (b :: bs).length ≤ [].length), motive [] (b :: bs) h) ... | null | false |
Polynomial.nonempty_support_iff | Mathlib.Algebra.Polynomial.Degree.Support | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.support.Nonempty ↔ p ≠ 0 | null | true |
MeasureTheory.laverage_lt_top | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
∫⁻ (x : α), f x ∂μ ≠ ⊤ → ⨍⁻ (x : α), f x ∂μ < ⊤ | null | true |
normalize_eq_zero | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α}, normalize x = 0 ↔ x = 0 | null | true |
Finpartition.IsEquipartition.card_interedges_sparsePairs_le' | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : DecidableEq α] {A : Finset α} {P : Finpartition A} {G : SimpleGraph α} [inst_4 : DecidableRel G.Adj]
{ε : 𝕜},
P.IsEquipartition →
0 ≤ ε →
↑((P.sparsePairs G ε).biUnion fun x =>
... | null | true |
Int.instConditionallyCompleteLinearOrder._proof_11 | Mathlib.Data.Int.ConditionallyCompleteOrder | ∀ (s : Set ℤ), s.Nonempty ∧ BddBelow s → BddBelow s | null | false |
Lean.Grind.Order.le_eq_true_of_lt | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] {a b : α}, a < b → (a ≤ b) = True | null | true |
_private.Lean.Util.PPExt.0.Lean.ppTerm.match_1 | Lean.Util.PPExt | (motive : Except IO.Error Std.Format → Sort u_1) →
(__do_lift : Except IO.Error Std.Format) →
((fmt : Std.Format) → motive (Except.ok fmt)) → ((ex : IO.Error) → motive (Except.error ex)) → motive __do_lift | null | false |
Mathlib.Tactic.LinearCombination.smul_lt_const | Mathlib.Tactic.LinearCombination.Lemmas | ∀ {α : Type u_1} {K : Type u_2} {t s : K} [inst : Ring K] [inst_1 : PartialOrder K] [IsOrderedRing K]
[inst_3 : AddCommGroup α] [inst_4 : PartialOrder α] [IsOrderedAddMonoid α] [inst_6 : Module K α]
[IsStrictOrderedModule K α], t < s → ∀ {a : α}, 0 < a → t • a < s • a | null | true |
_private.Mathlib.Algebra.CharP.Basic.0.Int.cast_injOn_of_ringChar_ne_two._simp_1_3 | Mathlib.Algebra.CharP.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (0 = 1) = False | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastShiftLeft._simp_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft | ∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p | null | false |
CongruenceSubgroup.exists_Gamma_le_conj' | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (g : GL (Fin 2) ℚ) (M : ℕ) [NeZero M],
∃ N,
N ≠ 0 ∧
ConjAct.toConjAct ((Matrix.GeneralLinearGroup.map (Rat.castHom ℝ)) g) •
Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N) ≤
Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma M) | For any `g ∈ GL(2, ℚ)` and `M ≠ 0`, there exists `N` such that `g Γ(N) g⁻¹ ≤ Γ(M)`. | true |
CategoryTheory.Functor.initial_const_initial | Mathlib.CategoryTheory.Filtered.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.IsCofiltered C] [inst_3 : CategoryTheory.Limits.HasInitial D],
((CategoryTheory.Functor.const C).obj (⊥_ D)).Initial | The inclusion of the initial object is initial. | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Pass.casesOn | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | {motive : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Pass → Sort u} →
(t : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Pass) →
((name : Lean.Name) →
(run' : Lean.MVarId → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PreProcessM (Option Lean.MVarId)) →
motive { name := name, run' := run' }) →
... | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.go._proof_5 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (w : ℕ) (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (lhs : aig.RefVec w)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (rhs : aig_1.RefVec w)
(hraig : aig.decls.size ≤ { aig := aig_1, vec := rhs }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := rhs }, hraig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitb... | null | false |
ZFSet.Nonempty.eq_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (u : ZFSet.{u}), u.Nonempty = (↑u).Nonempty | null | true |
MvPolynomial.totalDegree_pow | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (a : MvPolynomial σ R) (n : ℕ),
(a ^ n).totalDegree ≤ n * a.totalDegree | null | true |
OpenAddSubgroup.instSemilatticeInfOpenAddSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → SemilatticeInf (OpenAddSubgroup G) | null | true |
List.append_of_mem | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ l → ∃ s t, l = s ++ a :: t | See also `eq_append_cons_of_mem`, which proves a stronger version
in which the initial list must not contain the element.
| true |
directedOn_ge_Icc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), DirectedOn (fun x1 x2 => x1 ≥ x2) (Set.Icc a b) | null | true |
CliffordAlgebra.involute | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → {Q : QuadraticForm R M} → CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q | Grade involution, inverting the sign of each basis vector. | true |
MulAction.mem_orbit_self | Mathlib.GroupTheory.GroupAction.Defs | ∀ {M : Type u_1} {α : Type u_3} [inst : Monoid M] [inst_1 : MulAction M α] (a : α), a ∈ MulAction.orbit M a | null | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.simpleEnum.noConfusion | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | {P : Sort u} →
{info : Lean.InductiveVal} →
{ctors : Array Lean.ConstructorVal} →
{info' : Lean.InductiveVal} →
{ctors' : Array Lean.ConstructorVal} →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.simpleEnum info ctors =
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.M... | null | false |
_private.Init.Data.Array.MapIdx.0.Array.mapIdx_eq_singleton_iff._simp_1_1 | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : ℕ → α → β} {b : β}, (List.mapIdx f l = [b]) = ∃ a, l = [a] ∧ f 0 a = b | null | false |
BiheytingHom.map_sdiff' | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_6} {β : Type u_7} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β] (self : BiheytingHom α β)
(a b : α), self.toFun (a \ b) = self.toFun a \ self.toFun b | The proposition that a bi-Heyting homomorphism preserves the difference operation. | true |
Array.toListRev_iterFromIdx | Std.Data.Iterators.Lemmas.Producers.Array | ∀ {β : Type w} {array : Array β} {pos : ℕ}, (array.iterFromIdx pos).toListRev = (List.drop pos array.toList).reverse | null | true |
QuotientGroup.preimageMkEquivSubgroupProdSet._proof_5 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) (t : Set (α ⧸ s)) (a : ↥s × ↑t), ↑(Quotient.out ↑a.2 * ↑a.1) ∈ t | null | false |
Batteries.TransCmp.cmp_congr_left | Batteries.Classes.Deprecated | ∀ {α : Sort u_1} {cmp : α → α → Ordering} [Batteries.TransCmp cmp] {x y z : α},
cmp x y = Ordering.eq → cmp x z = cmp y z | null | true |
add_zsmul_add | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] (a b : G) (n : ℤ), n • (a + b) + a = a + n • (b + a) | null | true |
_private.Mathlib.Analysis.Normed.Module.FiniteDimension.0.LinearIndependent.eventually._simp_1_1 | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : Fintype ι] [inst_4 : DecidableEq ι],
LinearIndependent R v = (((LinearMap.lsum R (fun x => R) ℕ) fun i => LinearMap.id.smulRight (v i)).ker = ⊥) | null | false |
MeasureTheory.Content.recOn | Mathlib.MeasureTheory.Measure.Content | {G : Type w} →
[inst : TopologicalSpace G] →
{motive : MeasureTheory.Content G → Sort u} →
(t : MeasureTheory.Content G) →
((toFun : TopologicalSpace.Compacts G → NNReal) →
(mono' : ∀ (K₁ K₂ : TopologicalSpace.Compacts G), ↑K₁ ⊆ ↑K₂ → toFun K₁ ≤ toFun K₂) →
(sup_disjoint' :... | null | false |
_private.Mathlib.Data.Finsupp.Order.0.Finsupp.subset_support_tsub._simp_1_1 | Mathlib.Data.Finsupp.Order | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
MonoidAlgebra.mapRangeAddEquiv_apply | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Mul M] (e : R ≃+ S)
(x : MonoidAlgebra R M) (m : M), ((MonoidAlgebra.mapAddEquiv M e) x) m = e (x m) | **Alias** of `MonoidAlgebra.mapAddEquiv_apply`. | true |
_private.Std.Time.Format.DateFormat.0.Std.Time.DateFormatSymbols.enUS._proof_6 | Std.Time.Format.DateFormat | #["M", "T", "W", "T", "F", "S", "S"].size = 7 | null | false |
CategoryTheory.ShortComplex.HomologyMapData.mk.inj | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Limits.HasZeroMorphisms C}
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : S₁.HomologyData} {h₂ : S₂.HomologyData}
{left : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁.left h₂.left}
{right : CategoryTheory.ShortC... | null | true |
Aesop.withAesopTraceNode | Aesop.Tracing | {m : Type → Type} →
{ε : Type} →
[Monad m] →
[Lean.MonadTrace m] →
[MonadLiftT BaseIO m] →
[Lean.MonadRef m] →
[Lean.AddMessageContext m] →
[Lean.MonadOptions m] →
[Lean.MonadAlwaysExcept ε m] →
{α : Type} →
[L... | null | true |
Stream'.get_tail | Mathlib.Data.Stream.Init | ∀ {α : Type u} {n : ℕ} {s : Stream' α}, s.tail.get n = s.get (n + 1) | null | true |
IsSemiprimaryRing.mk._flat_ctor | Mathlib.RingTheory.Jacobson.Semiprimary | ∀ {R : Type u_1} [inst : Ring R],
IsSemisimpleRing (R ⧸ Ring.jacobson R) → IsNilpotent (Ring.jacobson R) → IsSemiprimaryRing R | null | false |
Turing.TM2ComputableInTime.rec | Mathlib.Computability.TuringMachine.Computable | {α β αΓ βΓ : Type} →
{ea : α → List αΓ} →
{eb : β → List βΓ} →
{f : α → β} →
{motive : Turing.TM2ComputableInTime ea eb f → Sort u} →
((toTM2ComputableAux : Turing.TM2ComputableAux αΓ βΓ) →
(time : ℕ → ℕ) →
(outputsFun :
(a : α) →
... | null | false |
_private.Mathlib.GroupTheory.CosetCover.0.Subgroup.exists_finiteIndex_of_leftCoset_cover_aux.match_1_3 | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : Group G] {ι : Type u_2} {H : ι → Subgroup G} {g : ι → G} {s : Finset ι} (j : ι)
(motive : (∃ x, ∀ i ∈ s, H i = H j → ↑(g i) ≠ ↑x) → Prop) (x : ∃ x, ∀ i ∈ s, H i = H j → ↑(g i) ≠ ↑x),
(∀ (x : G) (hx : ∀ i ∈ s, H i = H j → ↑(g i) ≠ ↑x), motive ⋯) → motive x | null | false |
_private.Lean.Meta.Transform.0.Lean.Meta.transformWithCache.visit.visitLambda._unsafe_rec | Lean.Meta.Transform | {m : Type → Type} →
[Monad m] →
[MonadLiftT Lean.MetaM m] →
[MonadControlT Lean.MetaM m] →
(Lean.Expr → m Lean.TransformStep) →
(Lean.Expr → m Lean.TransformStep) →
Bool →
Bool →
Bool →
(x : STWorld IO.RealWorld m) →
... | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.SelectM.State.suggestions | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.SelectM.State✝ → Array Lean.Meta.Tactic.TryThis.Suggestion | null | true |
CategoryTheory.pi.coneOfConeEvalIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Pi | ∀ {I : Type u_1} {C : I → Type u_2} [inst : (i : I) → CategoryTheory.Category.{u_1, u_2} (C i)] {J : Type u_1}
[inst_1 : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J ((i : I) → C i)}
{c : (i : I) → CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Pi.eval C i))}
(P : (i : I) → CategoryTheory.Lim... | null | false |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution'.b | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} → {hζ : IsPrimitiveRoot ζ 3} → FermatLastTheoremForThreeGen.Solution'✝ hζ → NumberField.RingOfIntegers K | null | true |
Int.dvd_of_tmod_eq_zero | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, b.tmod a = 0 → a ∣ b | null | true |
Equiv.restrictPreimageFinset_apply_coe | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} (e : α ≃ β) (s : Finset β) (a : ↥(s.preimage ⇑e ⋯)),
↑((e.restrictPreimageFinset s) a) = e ↑a | null | true |
Real.rpow_add_le_add_rpow | Mathlib.Analysis.MeanInequalitiesPow | ∀ {p a b : ℝ}, 0 ≤ a → 0 ≤ b → 0 ≤ p → p ≤ 1 → (a + b) ^ p ≤ a ^ p + b ^ p | null | true |
Submodule.equivOpposite._proof_2 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(p q : Submodule R Aᵐᵒᵖ),
MulOpposite.op (Submodule.comap (↑(MulOpposite.opLinearEquiv R)) (p + q)) =
MulOpposite.op (Submodule.comap (↑(MulOpposite.opLinearEquiv R)) p) +
MulOpposite.op (Submodule.comap (... | null | false |
Lean.Meta.Grind.NormalizePattern.State.bvarsFound._default | Lean.Meta.Tactic.Grind.EMatchTheorem | Std.HashSet ℕ | null | false |
Equiv.booleanAlgebra._proof_4 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : BooleanAlgebra β] (a b : α), e (e.symm (e a ⊓ e b)) = e a ⊓ e b | null | false |
_private.Mathlib.CategoryTheory.Sites.Descent.Precoverage.0.CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.sieve.fac | Mathlib.CategoryTheory.Sites.Descent.Precoverage | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type t} {S : C} {X : ι → C} {f : (i : ι) → X i ⟶ S}
{ι' : Type t'} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S} {i : ι} {Z : C} {q : Z ⟶ X i}
(hq :
(CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.sieve✝ f f' i).arrows (CategoryTheory.Over.homM... | null | true |
Filter.map_mul_right_nhdsGT | Mathlib.Topology.Algebra.Group.Basic | ∀ {H : Type x} [inst : TopologicalSpace H] [inst_1 : CommGroup H] [inst_2 : PartialOrder H] [IsOrderedMonoid H]
[ContinuousMul H] {c a : H},
Filter.map (fun x => x * c) (nhdsWithin a (Set.Ioi a)) = nhdsWithin (a * c) (Set.Ioi (a * c)) | null | true |
Set.singleton_zero | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Zero α], {0} = 0 | null | true |
Int.reduceBinPred | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | Lean.Name → ℕ → (ℤ → ℤ → Bool) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.Step | null | true |
Polynomial.quotientSpanCXSubCXSubCAlgEquiv._proof_5 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R (Polynomial R) (Polynomial R) | null | false |
String.Internal.nextWhile | Init.Data.String.Bootstrap | String → (Char → Bool) → String.Pos.Raw → String.Pos.Raw | null | true |
QuotientAddGroup.automorphize_smul_left | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {M : Type u_11} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M] [T2Space M] {R : Type u_12}
[inst_3 : DivisionRing R] [inst_4 : Module R M] [ContinuousConstSMul R M] {G : Type u_13} [inst_6 : AddGroup G]
{Γ : AddSubgroup G} (f : G → M) (g : G ⧸ Γ → R),
QuotientAddGroup.automorphize (g ∘ Quotient.mk' • f)... | Automorphization of a function into an `R`-`Module` distributes, that is, commutes with the
`R`-scalar multiplication. | true |
Set.fintypeOfFintypeImage._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) {f : α → β} {g : β → Option α} (I : Function.IsPartialInv f g)
[inst : Fintype ↑(f '' s)] (x : α), x ∈ { val := Multiset.filterMap g (f '' s).toFinset.val, nodup := ⋯ } ↔ x ∈ s | null | false |
isLocalHom_id | Mathlib.RingTheory.LocalRing.RingHom.Basic | ∀ (R : Type u_4) [inst : Semiring R], IsLocalHom (RingHom.id R) | null | true |
_private.Init.Data.Order.Factories.0.Std.LawfulOrderInf.of_lt._simp_1_2 | Init.Data.Order.Factories | ∀ {a b : Prop} [Decidable a] [Decidable b], (¬a ↔ ¬b) = (a ↔ b) | null | false |
Turing.TM2to1.Λ'.go.noConfusion | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{P : Sort u} →
{k : K} →
{a : Turing.TM2to1.StAct K Γ σ k} →
{a_1 : Turing.TM2.Stmt Γ Λ σ} →
{k' : K} →
{a' : Turing.TM2to1.StAct K Γ σ k'} →
... | null | false |
Std.Http.Config.maxStartLineLength | Std.Http.Server.Config | Std.Http.Config → ℕ | Maximum number of bytes consumed while parsing request start-lines (default: 8192 bytes).
| true |
CategoryTheory.CatEnrichedOrdinary.Hom.recOn | Mathlib.CategoryTheory.Bicategory.CatEnriched | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] →
{X Y : CategoryTheory.CatEnrichedOrdinary C} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.CatEnrichedOrdinary.Hom f g → Sort u_1} →
(t : CategoryTh... | null | false |
pow_left_strictMono | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftStrictMono M] [MulRightStrictMono M] {n : ℕ},
n ≠ 0 → StrictMono fun x => x ^ n | See also `pow_left_strictMonoOn₀`. | true |
AlgebraicGeometry.Scheme.Hom.copyBase.eq_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) (g : ↥X → ↥Y) (h : ⇑f = g),
f.copyBase g h =
{ base := TopCat.ofHom { toFun := g, continuous_toFun := ⋯ },
c := CategoryTheory.CategoryStruct.comp f.c (TopCat.Presheaf.pushforwardEq ⋯ X.presheaf).hom, prop := ⋯ } | null | true |
CategoryTheory.FreeMonoidalCategory.HomEquiv.id_tensorHom_id | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} {X Y : CategoryTheory.FreeMonoidalCategory C},
CategoryTheory.FreeMonoidalCategory.HomEquiv
((CategoryTheory.FreeMonoidalCategory.Hom.id X).tensor (CategoryTheory.FreeMonoidalCategory.Hom.id Y))
(CategoryTheory.FreeMonoidalCategory.Hom.id (X.tensor Y)) | null | true |
CategoryTheory.Functor.uncurry._proof_5 | Mathlib.CategoryTheory.Functor.Currying | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_6, u_2} D] {E : Type u_5} [inst_2 : CategoryTheory.Category.{u_3, u_5} E]
(X : CategoryTheory.Functor C (CategoryTheory.Functor D E)),
{ app := fun X_1 => ((CategoryTheory.CategoryStruct.id X).app X_... | null | false |
QuadraticMap.noConfusionType | Mathlib.LinearAlgebra.QuadraticForm.Basic | Sort u_1 →
{R : Type u} →
{M : Type v} →
{N : Type w} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] →
QuadraticMap R M N →
{... | null | false |
unitInterval.instIsProbabilityMeasureElemRealVolume | Mathlib.MeasureTheory.Constructions.UnitInterval | MeasureTheory.IsProbabilityMeasure MeasureTheory.volume | null | true |
MeasureTheory.integrableOn_image_iff_integrableOn_deriv_smul_of_monotoneOn | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {s : Set ℝ} {f f' : ℝ → ℝ},
MeasurableSet s →
(∀ x ∈ s, HasDerivWithinAt f (f' x) s x) →
MonotoneOn f s →
∀ (g : ℝ → F),
MeasureTheory.IntegrableOn g (f '' s) MeasureTheory.volume ↔
MeasureTheory.Integrab... | Integrability in the change of variable formula for differentiable functions: if a real
function `f` is monotone and differentiable on a measurable set `s`, then a function
`g : ℝ → F` is integrable on `f '' s` if and only if `f' x • g ∘ f` is integrable on `s` . | true |
Metric.isCompact_closure_iff_exists_finite_isCover | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : MetricSpace X] [ProperSpace X] {ε : NNReal} {s : Set X},
ε ≠ 0 → (IsCompact (closure s) ↔ ∃ N ⊆ s, N.Finite ∧ Metric.IsCover ε s N) | A set in a proper metric space admits a finite cover iff it is relatively compact.
[R. Vershynin, *High Dimensional Probability*][vershynin2018high], 4.2.3. Note that the print
edition incorrectly claims that this holds without the `ProperSpace X` assumption. | true |
lt_of_lt_mul_of_le_one_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Preorder α] [MulRightMono α] {a b c : α}, a < b * c → b ≤ 1 → a < c | null | true |
Geometry.SimplicialComplex.recOn | Mathlib.Analysis.Convex.SimplicialComplex.Basic | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : Ring 𝕜] →
[inst_1 : PartialOrder 𝕜] →
[inst_2 : AddCommGroup E] →
[inst_3 : Module 𝕜 E] →
{motive : Geometry.SimplicialComplex 𝕜 E → Sort u} →
(t : Geometry.SimplicialComplex 𝕜 E) →
((toPreAbstractSim... | null | false |
_private.Mathlib.NumberTheory.LucasLehmer.0.LucasLehmer.norm_num_ext.sModNatTR.go.match_1.eq_1 | Mathlib.NumberTheory.LucasLehmer | ∀ (motive : ℕ → ℕ → Sort u_1) (acc : ℕ) (h_1 : (acc : ℕ) → motive 0 acc) (h_2 : (n acc : ℕ) → motive n.succ acc),
(match 0, acc with
| 0, acc => h_1 acc
| n.succ, acc => h_2 n acc) =
h_1 acc | null | true |
Lean.Meta.Grind.Arith.CommRing.SimpResult.mk.injEq | Lean.Meta.Tactic.Grind.Arith.CommRing.SafePoly | ∀ (p : Lean.Grind.CommRing.Poly) (k₁ k₂ : ℤ) (m₂ : Lean.Grind.CommRing.Mon) (p_1 : Lean.Grind.CommRing.Poly)
(k₁_1 k₂_1 : ℤ) (m₂_1 : Lean.Grind.CommRing.Mon),
({ p := p, k₁ := k₁, k₂ := k₂, m₂ := m₂ } = { p := p_1, k₁ := k₁_1, k₂ := k₂_1, m₂ := m₂_1 }) =
(p = p_1 ∧ k₁ = k₁_1 ∧ k₂ = k₂_1 ∧ m₂ = m₂_1) | null | true |
Lean.PrettyPrinter.Delaborator.SubExpr.withBoundedAppFnArgs | Lean.PrettyPrinter.Delaborator.SubExpr | {α : Type} →
{m : Type → Type} →
[Monad m] → [MonadReaderOf Lean.SubExpr m] → [MonadWithReaderOf Lean.SubExpr m] → ℕ → m α → (α → m α) → m α | Uses `xa` to compute the fold across up to `maxArgs` outermost arguments of an application,
where `xf` provides the initial value and is evaluated in the context of the application minus
the arguments being folded across.
| true |
PresheafOfModules.pushforwardCompCoyonedaFreeYonedaCorepresentableBy._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Pullback | ∀ {C D : Type u_1} [inst : CategoryTheory.SmallCategory C] [inst_1 : CategoryTheory.SmallCategory D]
{F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ RingCat} {S : CategoryTheory.Functor Cᵒᵖ RingCat}
(φ : S ⟶ F.op.comp R) (X : C) {M N : PresheafOfModules R} (g : M ⟶ N)
(f : (PresheafOfModules.free... | null | false |
IsAntichain.image_relIso | Mathlib.Order.Antichain | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {s : Set α},
IsAntichain r s → ∀ (φ : r ≃r r'), IsAntichain r' (⇑φ '' s) | null | true |
Lean.Meta.Grind.saveEMatchDiagInfo | Lean.Meta.Tactic.Grind.Types | List Lean.Meta.Grind.EMatchDiagNode → Lean.Meta.Grind.EMatchDiagNode → Lean.Meta.Grind.GrindM Unit | null | true |
_private.Init.Data.UInt.Bitwise.0.USize.toUInt32_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : USize}, (a < b) = (a.toNat < b.toNat) | null | false |
_private.Mathlib.Topology.Homotopy.Contractible.0.homotopic_of_indiscrete.match_1_1 | Mathlib.Topology.Homotopy.Contractible | {X : Type u_1} →
(motive : ↑unitInterval × X → Sort u_2) →
(x : ↑unitInterval × X) → ((t : ↑unitInterval) → (a : X) → motive (t, a)) → motive x | null | false |
_private.Lean.Elab.Tactic.Omega.OmegaM.0.Lean.Elab.Tactic.Omega.analyzeAtom.match_6 | Lean.Elab.Tactic.Omega.OmegaM | (motive : Lean.Name × Array Lean.Expr → Sort u_1) →
(x : Lean.Name × Array Lean.Expr) →
((head x' : Lean.Expr) → motive (`Nat.cast, #[Lean.Expr.const `Int [], head, x'])) →
((x : Lean.Name × Array Lean.Expr) → motive x) → motive x | null | false |
CategoryTheory.PreGaloisCategory.surjective_of_nonempty_fiber_of_isConnected | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat)
[inst_1 : CategoryTheory.PreGaloisCategory C] [CategoryTheory.PreGaloisCategory.FiberFunctor F] {X A : C}
[Nonempty (F.obj X).obj] [CategoryTheory.PreGaloisCategory.IsConnected A] (f : X ⟶ A),
Function.Surjective... | null | true |
Array.set_eraseIdx._proof_3 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {w : i < xs.size} {j : ℕ} {a : α} (h' : ¬i ≤ j), i < (xs.set j a ⋯).size | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.