name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.StructuredArrow.map₂IsoPreEquivalenceInverseCompProj._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} E]
{T : CategoryTheory.Functor C D} {S : CategoryTheory.Functor D E} {T' : CategoryTheory.Functor C E} (d : D) (e : E)
(u : e ⟶ ... | null | false |
WithTop.toDual_symm | Mathlib.Order.WithBot | ∀ {α : Type u_1}, WithTop.toDual.symm = WithBot.ofDual | null | true |
StarSubalgebra.topologicalClosure._proof_2 | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
[inst_7 : IsSemitopologicalSemiring A] (s : StarSubalgebra R A), 1 ∈ s.topologicalClosure.carrier | null | false |
Digraph.mk.sizeOf_spec | Mathlib.Combinatorics.Digraph.Basic | ∀ {V : Type u_1} [inst : SizeOf V] (Adj : V → V → Prop), sizeOf { Adj := Adj } = 1 | null | true |
CategoryTheory.ShiftMkCore.assoc_hom_app._autoParam | Mathlib.CategoryTheory.Shift.Basic | Lean.Syntax | null | false |
SMulPosReflectLE.lift | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : SMul α β] [inst_4 : SMul α γ] (f : β → γ) [inst_5 : Zero β] [inst_6 : Zero γ] [SMulPosReflectLE α γ],
(∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂) → (∀ (a : α) (b : β), f (a • b) = a • f b) → f 0 = 0 →... | null | true |
Eq.trans_ssubset | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSSubset α] {a b c : α}, a = b → b ⊂ c → a ⊂ c | **Alias** of `ssubset_of_eq_of_ssubset`. | true |
Nat.smallSchroder | Mathlib.Combinatorics.Enumerative.Schroder | ℕ → ℕ | The small Schröder number is equal to : `largeSchroder n = 2 * smallSchroder (n + 1), n ≥ 1` | true |
Std.DTreeMap.isEmpty | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → Bool | Returns `true` if the tree map contains no mappings. | true |
CategoryTheory.prod.leftUnitor_isEquivalence | Mathlib.CategoryTheory.Products.Unitor | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C], (CategoryTheory.prod.leftUnitor C).IsEquivalence | null | true |
Lean.Elab.Tactic.BVDecide.Frontend.M.simplifyTernaryProof | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | (Lean.Expr → Lean.Expr) →
Lean.Expr →
Option Lean.Expr →
Lean.Expr → Option Lean.Expr → Lean.Expr → Option Lean.Expr → Option (Lean.Expr × Lean.Expr × Lean.Expr) | null | true |
εNFA.ctorIdx | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → εNFA α σ → ℕ | null | false |
DirectSum.decompose_one | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜],
(DirectSum.decompose 𝒜) 1 = 1 | null | true |
Std.TreeMap.Raw.contains_map | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
{f : α → β → γ} {k : α}, t.WF → (Std.TreeMap.Raw.map f t).contains k = t.contains k | null | true |
Lean.Meta.RecursorUnivLevelPos.ctorElim | Lean.Meta.RecursorInfo | {motive : Lean.Meta.RecursorUnivLevelPos → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.RecursorUnivLevelPos) →
ctorIdx = t.ctorIdx → Lean.Meta.RecursorUnivLevelPos.ctorElimType ctorIdx → motive t | null | false |
CategoryTheory.PreOneHypercover.Hom.ext'_iff | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} {f g : E.Hom F},
f = g ↔
∃ (hs₀ : f.s₀ = g.s₀) (_ :
∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)) (hs₁ :
∀... | null | true |
Associated.dvd_iff_dvd_left | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M] {a b c : M}, Associated a b → (a ∣ c ↔ b ∣ c) | null | true |
Set.projIcc_of_le_left | Mathlib.Order.Interval.Set.ProjIcc | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (h : a ≤ b) {x : α}, x ≤ a → Set.projIcc a b h x = ⟨a, ⋯⟩ | null | true |
Mathlib.Tactic.ClickSuggestions.Choice | Mathlib.Tactic.ClickSuggestions.FindPremises | Type | A choice of which discrimination trees to build. | true |
hasStrictFDerivAt_zero | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] (x : E), HasStrictFDerivAt 0 0 x | null | true |
CategoryTheory.Category.comp_id._autoParam | Mathlib.CategoryTheory.Category.Basic | Lean.Syntax | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.m._default | Std.Time.Format.Basic | Option Std.Time.Minute.Ordinal | null | false |
Std.DHashMap.Internal.Raw₀.getEntry?_eq_getEntry? | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [PartialEquivBEq α] [LawfulHashable α]
{m : Std.DHashMap.Internal.Raw₀ α β},
Std.DHashMap.Internal.Raw.WFImp ↑m →
∀ {a : α}, m.getEntry? a = Std.Internal.List.getEntry? a (Std.DHashMap.Internal.toListModel (↑m).buckets) | null | true |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_union_Ioc_union_Ioc_cycle._proof_1_1 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α},
Set.Ioc a b ∪ Set.Ioc b c ∪ Set.Ioc c a = Set.Ioc (min a (min b c)) (max a (max b c)) | null | false |
Lean.Lsp.instToJsonDocumentChange.match_1 | Lean.Data.Lsp.Basic | (motive : Lean.Lsp.DocumentChange → Sort u_1) →
(x : Lean.Lsp.DocumentChange) →
((x : Lean.Lsp.CreateFile) → motive (Lean.Lsp.DocumentChange.create x)) →
((x : Lean.Lsp.RenameFile) → motive (Lean.Lsp.DocumentChange.rename x)) →
((x : Lean.Lsp.DeleteFile) → motive (Lean.Lsp.DocumentChange.delete x)) ... | null | false |
Booleanisation.instSemilatticeInf._proof_3 | Mathlib.Order.Booleanisation | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (x x_1 x_2 : Booleanisation α), x ≤ x_1 → x ≤ x_2 → x ≤ x_1 ⊓ x_2 | null | false |
Lean.AxiomVal.casesOn | Lean.Declaration | {motive : Lean.AxiomVal → Sort u} →
(t : Lean.AxiomVal) →
((toConstantVal : Lean.ConstantVal) →
(isUnsafe : Bool) → motive { toConstantVal := toConstantVal, isUnsafe := isUnsafe }) →
motive t | null | false |
Std.Format.bracket | Init.Data.Format.Basic | String → Std.Format → String → Std.Format | Creates a format `l ++ f ++ r` with a flattening group, nesting the contents by the length of `l`.
The group's `FlattenBehavior` is `allOrNone`; for `fill` use `Std.Format.bracketFill`.
| true |
Lean.Meta.Grind.Context.cheapCases._default | Lean.Meta.Tactic.Grind.Types | Bool | null | false |
linearIndependent_fin_cons | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {x : V} {n : ℕ}
{v : Fin n → V}, LinearIndependent K (Fin.cons x v) ↔ LinearIndependent K v ∧ x ∉ Submodule.span K (Set.range v) | **Alias** of `linearIndependent_finCons`. | true |
WeierstrassCurve.Projective.PointClass | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | (R : Type r) → [CommRing R] → Type r | The equivalence class of a projective point representative on a Weierstrass curve. | true |
Monoid.CoprodI.Word.consRecOn._proof_3 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (m : (i : ι) × M i) (w : List ((i : ι) × M i))
(h1 : ∀ l ∈ m :: w, l.snd ≠ 1) (h2 : List.IsChain (fun l l' => l.fst ≠ l'.fst) (m :: w)),
{ toList := w, ne_one := ⋯, chain_ne := ⋯ }.fstIdx ≠ some m.fst | null | false |
eq_zero_or_one_of_sq_eq_self | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] [IsRightCancelMulZero M₀] {x : M₀}, x ^ 2 = x → x = 0 ∨ x = 1 | null | true |
Std.Time.Database.TZdb.getLocalZoneRules | Std.Time.Zoned.Database.TZdb | Std.Time.Database.TZdb → IO Std.Time.TimeZone.ZoneRules | Retrieves the timezone rules for the local timezone, re-reading the `TZ` and `TZDIR`
environment variables on each call so that runtime changes are reflected immediately.
| true |
ChainComplex.toSingle₀Equiv._proof_6 | Mathlib.Algebra.Homology.Single | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] (C : ChainComplex V ℕ) (X : V)
(φ : C ⟶ (ChainComplex.single₀ V).obj X),
(fun f => HomologicalComplex.mkHomToSingle ↑f ⋯) ((fun φ => ⟨φ.f 0, ⋯⟩) φ) = ... | null | false |
IsOpen.add_closure | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G] {s : Set G},
IsOpen s → ∀ (t : Set G), s + closure t = s + t | null | true |
_private.Std.Sat.CNF.RelabelFin.0.Std.Sat.CNF.Clause.of_maxLiteral_eq_some._simp_1_3 | Std.Sat.CNF.RelabelFin | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b | null | false |
CategoryTheory.Quiv.equivOfIso._proof_2 | Mathlib.CategoryTheory.Category.Quiv | ∀ {V W : CategoryTheory.Quiv} (e : V ≅ W) (X : ↑W),
(CategoryTheory.CategoryStruct.comp e.inv e.hom).obj X = (CategoryTheory.CategoryStruct.id W).obj X | null | false |
Irrational.of_pow | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ} (n : ℕ), Irrational (x ^ n) → Irrational x | null | true |
Set.IsWF.min_add | Mathlib.Data.Finset.MulAntidiagonal | ∀ {α : Type u_1} {s t : Set α} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedCancelAddMonoid α]
(hs : s.IsWF) (ht : t.IsWF) (hsn : s.Nonempty) (htn : t.Nonempty), ⋯.min ⋯ = hs.min hsn + ht.min htn | null | true |
Matrix.frobenius_norm_replicateCol | Mathlib.Analysis.Matrix.Normed | ∀ {n : Type u_4} {α : Type u_5} {ι : Type u_7} [inst : Fintype n] [inst_1 : Unique ι]
[inst_2 : SeminormedAddCommGroup α] (v : n → α), ‖Matrix.replicateCol ι v‖ = ‖WithLp.toLp 2 v‖ | null | true |
Order.not_isSuccLimit_add_one | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : PartialOrder α] (a : α) [inst_1 : Add α] [inst_2 : One α] [SuccAddOrder α] [NoMaxOrder α],
¬Order.IsSuccLimit (a + 1) | null | true |
Algebra.leftMulMatrix_complex | Mathlib.RingTheory.Complex | ∀ (z : ℂ), (Algebra.leftMulMatrix Complex.basisOneI) z = !![z.re, -z.im; z.im, z.re] | null | true |
UInt16.pow | Init.Data.UInt.Basic | UInt16 → ℕ → UInt16 | The power operation, raising a 16-bit unsigned integer to a natural number power,
wrapping around on overflow. Usually accessed via the `^` operator.
This function is currently *not* overridden at runtime with an efficient implementation,
and should be used with caution. See https://github.com/leanprover/lean4/issues/... | true |
NumberField.InfinitePlace.mult_isComplex | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] (w : { w // w.IsComplex }), (↑w).mult = 2 | null | true |
Std.HashSet.contains_toList | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k : α},
m.toList.contains k = m.contains k | null | true |
_private.Mathlib.Topology.Baire.Lemmas.0.dense_of_mem_residual.match_1_1 | Mathlib.Topology.Baire.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (motive : (∃ t ⊆ s, IsGδ t ∧ Dense t) → Prop)
(x : ∃ t ⊆ s, IsGδ t ∧ Dense t), (∀ (w : Set X) (hts : w ⊆ s) (left : IsGδ w) (hd : Dense w), motive ⋯) → motive x | null | false |
ModuleCat.smulNatTrans._proof_8 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ (R : Type u_1) [inst : Ring R] (x x_1 : R),
{ app := fun M => M.smul (x + x_1), naturality := ⋯ } =
{ app := fun M => M.smul x, naturality := ⋯ } + { app := fun M => M.smul x_1, naturality := ⋯ } | null | false |
Ideal.Quotient.ring._aux_23 | Mathlib.RingTheory.Ideal.Quotient.Defs | {R : Type u_1} → [inst : Ring R] → (I : Ideal R) → [I.IsTwoSided] → ℤ → R ⧸ I | null | false |
Function.Surjective.smulCommClass | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [inst : SMul M α] [inst_1 : SMul N α] [inst_2 : SMul M β]
[inst_3 : SMul N β] [SMulCommClass M N α] {f : α → β},
Function.Surjective f →
(∀ (c : M) (x : α), f (c • x) = c • f x) → (∀ (c : N) (x : α), f (c • x) = c • f x) → SMulCommClass M N β | null | true |
CompHausLike.LocallyConstant.sigmaIso._proof_3 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
{Q : CompHausLike P} {Z : Type (max u_1 u_2)} (r : LocallyConstant (↑Q.toTop) Z),
CompactSpace ((i : Function.Fiber ⇑r) × ↑(CompHausLike.LocallyConstant.fiber r i).toTop) | null | false |
String.Pos.Raw.isValidUTF8_extract_iff | Init.Data.String.Basic | ∀ {s : String} (p₁ p₂ : String.Pos.Raw),
p₁ ≤ p₂ →
p₂ ≤ s.rawEndPos →
((s.toByteArray.extract p₁.byteIdx p₂.byteIdx).IsValidUTF8 ↔
p₁ = p₂ ∨ String.Pos.Raw.IsValid s p₁ ∧ String.Pos.Raw.IsValid s p₂) | null | true |
extChartAt_self_apply | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ (𝕜 : Type u_1) {E : Type u_2} {H : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {x y : H},
↑(extChartAt I x) y = ↑I y | null | true |
CategoryTheory.InjectiveResolution.definition._@.Mathlib.CategoryTheory.Abelian.Injective.Resolution.4211954440._hygCtx._hyg.8 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[CategoryTheory.EnoughInjectives C] → (Z : C) → CategoryTheory.InjectiveResolution Z | null | false |
MeasureTheory.Measure.LebesgueDecomposition.zero_mem_measurableLE | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
0 ∈ MeasureTheory.Measure.LebesgueDecomposition.measurableLE μ ν | null | true |
Lean.Elab.Info.ofChoiceInfo.elim | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
t.ctorIdx = 14 → ((i : Lean.Elab.ChoiceInfo) → motive (Lean.Elab.Info.ofChoiceInfo i)) → motive t | null | false |
one_half_le_sum_primes_ge_one_div | Mathlib.NumberTheory.SumPrimeReciprocals | ∀ (k : ℕ), 1 / 2 ≤ ∑ p ∈ (4 ^ (k.primesBelow.card + 1)).succ.primesBelow \ k.primesBelow, 1 / ↑p | The sum over primes `k ≤ p ≤ 4^(π(k-1)+1)` over `1/p` (as a real number) is at least `1/2`. | true |
List.isEmpty_eq_false_iff._simp_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = false) = (l ≠ []) | null | false |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.CastKind | Mathlib.Tactic.Translate.TagUnfoldBoundary | Type | There are 3 kinds of casting functions for a definition `foo := body`:
1. Equality: `foo = body`
2. Unfolding: `foo → body`
3. Refolding: `body → foo`
| true |
MvPolynomial.homEquiv._proof_1 | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {S : Type u_1} {σ : Type u_2} [inst : CommRing S] (f : σ → S) (x : σ),
(fun f => ⇑f ∘ MvPolynomial.X) ((fun f => MvPolynomial.eval₂Hom (Int.castRingHom S) f) f) x = f x | null | false |
_private.Mathlib.Order.Interval.Set.Fin.0.Fin.preimage_rev_Ico._simp_1_2 | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} {i j : Fin n}, (i.rev < j) = (j.rev < i) | null | false |
Stream'.Seq.update._proof_2 | Mathlib.Data.Seq.Defs | ∀ {α : Type u_1} (s : Stream'.Seq α) (n : ℕ) (f : α → α), Stream'.IsSeq (Function.update (↑s) n (Option.map f (↑s n))) | null | false |
Complex.continuousWithinAt_log_of_re_neg_of_im_zero | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {z : ℂ}, z.re < 0 → z.im = 0 → ContinuousWithinAt Complex.log {z | 0 ≤ z.im} z | null | true |
FreeGroup.Red.Step.cons_not | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}, FreeGroup.Red.Step ((x, b) :: (x, !b) :: L) L | null | true |
LawfulMonadStateOf.get_bind_map_set | Batteries.Control.LawfulMonadState | ∀ {σ : Type u_1} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : MonadStateOf σ m] [LawfulMonadStateOf σ m]
{α : Type u_1} (f : σ → PUnit.{u_1 + 1} → α),
(do
let s ← get
f s <$> set s) =
do
let __do_lift ← get
pure (f __do_lift PUnit.unit) | null | true |
ergodic_vadd_of_denseRange_nsmul | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {X : Type u_2} [inst : TopologicalSpace X] [R1Space X] [inst_2 : MeasurableSpace X] [BorelSpace X] {M : Type u_3}
[inst_4 : AddMonoid M] [inst_5 : TopologicalSpace M] [inst_6 : AddAction M X] [ContinuousVAdd M X] {g : M},
(DenseRange fun x => x • g) →
∀ (μ : MeasureTheory.Measure X) [MeasureTheory.IsFiniteMea... | If an additive monoid `M` continuously acts on an R₁ topological space `X`,
`g` is an element of `M` such that its natural multiples are dense in `M`,
and `μ` is a finite inner regular measure on `X` which is ergodic with respect to the action of `M`,
then the vector addition of `g` is an ergodic map. | true |
FiniteField.frobeniusAlgEquivOfAlgebraic | Mathlib.FieldTheory.Finite.Basic | (K : Type u_1) →
[inst : Field K] →
[Fintype K] → (L : Type u_3) → [inst_2 : Field L] → [inst_3 : Algebra K L] → [Algebra.IsAlgebraic K L] → Gal(L/K) | If `L/K` is an algebraic extension of a finite field, the Frobenius `K`-algebra endomorphism
of `L` is an automorphism. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform.0.SimpleGraph.unreduced_edges_subset._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
Complementeds.disjoint_coe._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : BoundedOrder α] {a b : Complementeds α},
Disjoint ↑a ↑b = Disjoint a b | null | false |
List.rtakeWhile_concat | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (p : α → Bool) (l : List α) (x : α),
List.rtakeWhile p (l ++ [x]) = if p x = true then List.rtakeWhile p l ++ [x] else [] | null | true |
_private.Mathlib.Order.CompleteLattice.PiLex.0.Pi.Colex.instInfSetColexForall._proof_1 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} [inst : LinearOrder ι] [WellFoundedGT ι], IsWellFounded ιᵒᵈ fun x1 x2 => x1 < x2 | null | false |
StrictConcaveOn.lt_map_sum | Mathlib.Analysis.Convex.Jensen | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} {ι : Type u_5} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜]
[IsStrictOrderedRing 𝕜] [inst_3 : AddCommGroup E] [inst_4 : AddCommGroup β] [inst_5 : PartialOrder β]
[IsOrderedAddMonoid β] [inst_7 : Module 𝕜 E] [inst_8 : Module 𝕜 β] [IsStrictOrderedModule 𝕜 β] {s : Set... | Concave **strict Jensen inequality**.
If the function is strictly concave, the weights are strictly positive and the indexed family of
points is non-constant, then Jensen's inequality is strict.
See also `StrictConcaveOn.map_sum_eq_iff`. | true |
Module.Basis.ofIsCoprimeDifferentIdeal | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | (A : Type u_1) →
(B : Type u_2) →
{K : Type u_3} →
{L : Type u_4} →
[inst : CommRing A] →
[inst_1 : Field K] →
[inst_2 : Algebra A K] →
[IsFractionRing A K] →
[inst_4 : CommRing B] →
[inst_5 : Field L] →
[inst_... | Let `A ⊆ B` be a finite extension of Dedekind domains and assume that `A ⊆ R₁, R₂ ⊆ B` are two
subrings such that `Frac R₁ ⊔ Frac R₂ = Frac B`, `Frac R₁` and `Frac R₂` are linearly disjoint
over `Frac A`, and that `𝓓(R₁/A)` and `𝓓(R₂/A)` are coprime where `𝓓` denotes the different ideal
and `Frac R` denotes the frac... | true |
Lean.PrettyPrinter.Formatter.pushToken | Lean.PrettyPrinter.Formatter | Lean.SourceInfo → String → Bool → Lean.PrettyPrinter.FormatterM Unit | null | true |
CategoryTheory.MonoidalCategory.DayFunctor.equiv._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (V : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (X : CategoryTheory.MonoidalCategory.DayFunctor C V),
(CategoryTheory.CategoryStruct.id X).natTran... | null | false |
OreLocalization.instMonoidWithZero._proof_2 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : MonoidWithZero R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
(x : OreLocalization S R), x * 0 = 0 | null | false |
Lean.Meta.instReduceEvalLiteral_qq | Qq.ForLean.ReduceEval | Lean.Meta.ReduceEval Lean.Literal | null | true |
Lean.Elab.HeaderProcessedSnapshot.mk.sizeOf_spec | Lean.Elab.DefView | ∀ (toSnapshot : Lean.Language.Snapshot) (view : Lean.Elab.DefViewElabHeaderData) (state : Lean.Elab.Term.SavedState)
(tacStx? : Option Lean.Syntax) (tacSnap? : Option (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot))
(bodyStx : Lean.Syntax) (bodySnap : Lean.Language.SnapshotTask (Option Lean.Elab.... | null | true |
String.Slice.Pattern.Model.NoSuffixPatternModel | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} → (pat : ρ) → [String.Slice.Pattern.Model.PatternModel pat] → Prop | Predicate stating that a match for a given pattern is never a proper suffix of another match.
This implies that the notion of reverse match and longest reverse match coincide.
| true |
BitVec.getLsb'_ofFnBE | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : Fin n), (BitVec.ofFnBE f).getLsb i = f i.rev | **Alias** of `BitVec.getLsb_ofFnBE`. | true |
Set.Icc.mul_le_right | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {x y : ↑(Set.Icc 0 1)},
x * y ≤ y | null | true |
_private.Init.Omega.IntList.0.List.getElem?_map.match_1_1 | Init.Omega.IntList | ∀ {α : Type u_1} (motive : List α → ℕ → Prop) (x : List α) (x_1 : ℕ),
(∀ (x : ℕ), motive [] x) →
(∀ (head : α) (tail : List α), motive (head :: tail) 0) →
(∀ (head : α) (l : List α) (i : ℕ), motive (head :: l) i.succ) → motive x x_1 | null | false |
CliffordAlgebra.foldr'Aux._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Fold | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), SMulCommClass R R (CliffordAlgebra Q) | null | false |
FunLike.ring | Mathlib.Data.FunLike.Ring | {F : Type u_1} →
{α : Type u_2} →
[inst : FunLike F α α] →
[inst_1 : Zero F] →
[inst_2 : One F] →
[inst_3 : Mul F] →
[inst_4 : Add F] →
[inst_5 : Neg F] →
[inst_6 : Sub F] →
[inst_7 : AddCommGroup α] →
[IsZeroA... | A `FunLike` type with `(f + g) x = f x + g x` and `(f * g) x = f (g x)` is a `Ring` if `α` is a
`Ring`. | true |
_private.Init.Data.Dyadic.Basic.0.Rat.toDyadic.match_1.splitter | Init.Data.Dyadic.Basic | (motive : ℤ → Sort u_1) →
(prec : ℤ) → ((n : ℕ) → motive (Int.ofNat n)) → ((n : ℕ) → motive (Int.negSucc n)) → motive prec | null | true |
StarRingEquiv.trans | Mathlib.Algebra.Star.StarRingHom | {A : Type u_1} →
{B : Type u_2} →
{C : Type u_3} →
[inst : Add A] →
[inst_1 : Add B] →
[inst_2 : Mul A] →
[inst_3 : Mul B] →
[inst_4 : Star A] →
[inst_5 : Star B] →
[inst_6 : Add C] → [inst_7 : Mul C] → [inst_8 : Star C] → (A ≃⋆+*... | Transitivity of `StarRingEquiv`. | true |
BitVec.reduceDiv | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | Simplification procedure for division of `BitVec`s. | true |
_private.Mathlib.LinearAlgebra.BilinearForm.Orthogonal.0.LinearMap.BilinForm.ker_restrict_eq_of_codisjoint._simp_1_2 | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | null | false |
IsPRadical.injective_comp | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} (M : Type u_3) [inst : CommRing K] [inst_1 : CommRing L] [inst_2 : CommRing M]
(i : K →+* L) (p : ℕ) [ExpChar M p] [IsPRadical i p] [IsReduced M], Function.Injective fun f => f.comp i | If `i : K →+* L` is `p`-radical, then for any reduced ring `M` of exponential characteristic
`p`, the map `(L →+* M) → (K →+* M)` induced by `i` is injective.
A special case of `IsPRadical.injective_comp_of_pNilradical_eq_bot`
and a generalization of `IsPurelyInseparable.injective_comp_algebraMap`. | true |
Algebra.FinitePresentation.mvPolynomial_of_finitePresentation | Mathlib.RingTheory.FinitePresentation | ∀ {R : Type w₁} {A : Type w₂} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[Algebra.FinitePresentation R A] (ι : Type v) [Finite ι], Algebra.FinitePresentation R (MvPolynomial ι A) | If `A` is a finitely presented `R`-algebra, then `MvPolynomial (Fin n) A` is finitely presented
as `R`-algebra. | true |
_private.Lean.Meta.Tactic.Grind.Action.0.Lean.Meta.Grind.Action.loop.match_1 | Lean.Meta.Tactic.Grind.Action | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | null | false |
isAddRegular_unop | Mathlib.Algebra.Regular.Opposite | ∀ {R : Type u_1} [inst : Add R] {a : Rᵃᵒᵖ}, IsAddRegular (AddOpposite.unop a) ↔ IsAddRegular a | null | true |
Lean.Meta.CheckAssignment.Context.rec | Lean.Meta.ExprDefEq | {motive : Lean.Meta.CheckAssignment.Context → Sort u} →
((mvarId : Lean.MVarId) →
(mvarDecl : Lean.MetavarDecl) →
(fvars : Array Lean.Expr) →
(hasCtxLocals : Bool) →
(rhs : Lean.Expr) →
motive
{ mvarId := mvarId, mvarDecl := mvarDecl, fvars := fvars, h... | null | false |
Polynomial.add_modByMonic | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {q : Polynomial R} (p₁ p₂ : Polynomial R), (p₁ + p₂) %ₘ q = p₁ %ₘ q + p₂ %ₘ q | null | true |
Std.Iter.toArray.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α β : Type w} [inst : Std.Iterator α Id β] (it : Std.Iter β), it.toArray = it.toIterM.toArray.run | null | true |
Nat.minFac_eq | Mathlib.Data.Nat.Prime.Defs | ∀ (n : ℕ), n.minFac = if 2 ∣ n then 2 else n.minFacAux 3 | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ushiftRight_of_lt._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ}, 0 < n → n ≤ w → ¬(w - n).succ ≤ w → False | null | false |
Nat.maxPowDvdDiv.eq_1 | Mathlib.Data.Nat.MaxPowDiv | ∀ (p n : ℕ), p.maxPowDvdDiv n = if H : 1 < p ∧ n ≠ 0 then Nat.maxPowDvdDiv.go n p H else (0, n) | null | true |
Real.iteratedDerivWithin_cos_Icc | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ (n : ℕ) {a b : ℝ},
a < b → ∀ {x : ℝ}, x ∈ Set.Icc a b → iteratedDerivWithin n Real.cos (Set.Icc a b) x = iteratedDeriv n Real.cos x | null | true |
SSet.Subcomplex.PairingCore.pairing._proof_9 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} (h : A.PairingCore), h.I ∩ h.II = ∅ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.