name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.GroupTheory.FreeGroup.Reduce.0.FreeGroup.toWord_mul_mk_eq._proof_1_14 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] (x : FreeGroup α) (i : ℕ) (a_1 : α × Bool),
((List.map ((fun g => (g.1, !g.2)) ∘ fun g => (g.1, !g.2)) x.toWord).dropLast[i]? = some a_1) =
¬x.toWord.dropLast[i]? = some a_1 →
¬(List.map ((fun g => (g.1, !g.2)) ∘ fun g => (g.1, !g.2)) x.toWord).dropLast[i]? = some a_1... | null | false |
TwoSidedIdeal.instSubSubtypeMem | Mathlib.RingTheory.TwoSidedIdeal.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocRing R] → (I : TwoSidedIdeal R) → Sub ↥I | null | true |
CategoryTheory.Discrete.productEquiv_functor_map | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} {X Y : CategoryTheory.Discrete (J × K)} (f : X ⟶ Y),
CategoryTheory.Discrete.productEquiv.functor.map f =
CategoryTheory.Discrete.Hom.rec (fun eq => CategoryTheory.eqToHom ⋯) f | null | true |
ContinuousAffineMap.decompContinuousLinearEquiv._proof_3 | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | ∀ (R : Type u_1) [inst : NormedField R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
le_inv_iff_mul_le_one_left | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulLeftMono α] {a b : α}, a ≤ b⁻¹ ↔ b * a ≤ 1 | null | true |
Lean.Grind.AC.Seq.endsWithVar_k | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Var → Bool | null | true |
WeierstrassCurve.Jacobian.neg_X | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} (P : Fin 3 → R), W'.neg P 0 = P 0 | null | true |
AddSubgroup.neg_mem_iff | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x : G}, -x ∈ H ↔ x ∈ H | null | true |
Lean.AttributeApplicationTime.afterCompilation.elim | Lean.Attributes | {motive : Lean.AttributeApplicationTime → Sort u} →
(t : Lean.AttributeApplicationTime) → t.ctorIdx = 1 → motive Lean.AttributeApplicationTime.afterCompilation → motive t | null | false |
AlgebraicGeometry.StructureSheaf.Localizations.comapFun._proof_6 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {S : Type u_1}
[inst_3 : CommRing S] {σ : R →+* S} (y : ↑(AlgebraicGeometry.PrimeSpectrum.Top S)),
IsLocalizedModule (PrimeSpectrum.comap σ y).asIdeal.primeCompl
(LocalizedModule.mkLinearMap (PrimeSpectrum.comap σ y).asIdeal.... | null | false |
Mathlib.Tactic.ModCases.NatMod.onModCases_succ | Mathlib.Tactic.ModCases | {p : Sort u_1} →
{n a : ℕ} →
(b : ℕ) →
(a ≡ b [MOD n] → p) →
Mathlib.Tactic.ModCases.NatMod.OnModCases n a (b.add 1) p → Mathlib.Tactic.ModCases.NatMod.OnModCases n a b p | The successor case decomposes `∃ m, b ≤ m < n ∧ a ≡ m (mod n)` into
`a ≡ b (mod n) ∨ ∃ m, b+1 ≤ m < n ∧ a ≡ m (mod n)`,
and the `a ≡ b (mod n) → p` case becomes a subgoal.
| true |
NonUnitalNormedCommRing.induced._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_3} (R : Type u_1) (S : Type u_2) [inst : FunLike F R S] [inst_1 : NonUnitalNormedCommRing S] (f : F),
((Filter.comap (fun p => (f p.1, f p.2)) (uniformity S)).lift' fun s => SetRel.comp s s) ≤
Filter.comap (fun p => (f p.1, f p.2)) (uniformity S) | null | false |
MeasureTheory.Measure.snd_mono | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{ρ μ : MeasureTheory.Measure (α × β)}, ρ ≤ μ → ρ.snd ≤ μ.snd | null | true |
AlgebraicGeometry.AffineSpace.instGeometricallyIrreducibleOverSchemeInferInstanceOverClass | Mathlib.AlgebraicGeometry.AffineSpace | ∀ {n : Type u} (S : AlgebraicGeometry.Scheme),
AlgebraicGeometry.GeometricallyIrreducible (AlgebraicGeometry.AffineSpace n S ↘ S) | null | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkCasesResultSeq._proof_1 | Lean.Meta.Tactic.Grind.Split | ∀ (alts : Array (List (Lean.TSyntax `grind))), alts.size = 1 → ¬0 < alts.size → False | null | false |
_private.Mathlib.Algebra.Order.Field.Power.0.Mathlib.Meta.Positivity.evalZPow._proof_5 | Mathlib.Algebra.Order.Field.Power | ∀ {u : Lean.Level} {α : Q(Type u)} (pα : Q(PartialOrder «$α»)) (_oα : Q(LinearOrder «$α»)),
«$pα» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toPartialOrder | null | false |
_private.Mathlib.Basic.IsEmpty.Basic.0.isEmpty_Prop._simp_1_1 | Mathlib.Basic.IsEmpty.Basic | ∀ {α : Sort u_1}, IsEmpty α = ¬Nonempty α | null | false |
CategoryTheory.HasProjectiveDimensionLT.subsingleton' | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Abelian C} {X : C} {n : ℕ}
[self : CategoryTheory.HasProjectiveDimensionLT X n] (i : ℕ),
n ≤ i → ∀ ⦃Y : C⦄, Subsingleton (CategoryTheory.Abelian.Ext X Y i) | null | true |
addRightReflectLT_of_addLeftReflectLT | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ (N : Type u_2) [inst : AddCommSemigroup N] [inst_1 : LT N] [AddLeftReflectLT N], AddRightReflectLT N | null | true |
Nat.Partition.powerSeriesMk_card_restricted_eq_powerSeriesMk_card_countRestricted | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | ∀ (R : Type u_1) [inst : CommRing R] [NoZeroDivisors R] {m : ℕ},
0 < m →
(PowerSeries.mk fun n => ↑(Nat.Partition.restricted n fun x => ¬m ∣ x).card) =
PowerSeries.mk fun n => ↑(Nat.Partition.countRestricted n m).card | null | true |
groupCohomology.shortComplexH0_g | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{max u u_1, u, u} k G),
(groupCohomology.shortComplexH0 A).g = groupCohomology.d₀₁ A | null | true |
HomologicalComplex.homology_π_ι | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {K : HomologicalComplex C c} (i : ι) [inst_2 : K.HasHomology i],
CategoryTheory.CategoryStruct.comp (K.homologyπ i) (K.homologyι i) =
CategoryTheory.CategoryStru... | null | true |
_private.Mathlib.Analysis.CStarAlgebra.GelfandDuality.0.gelfandTransform_isometry._simp_1_3 | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | null | false |
ProbabilityTheory.HasSubgaussianMGF.const_mul | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ} {c : NNReal},
ProbabilityTheory.HasSubgaussianMGF X c μ →
∀ (r : ℝ), ProbabilityTheory.HasSubgaussianMGF (fun ω => r * X ω) (⟨r ^ 2, ⋯⟩ * c) μ | null | true |
Mathlib.Tactic.Bicategory.tgtExpr | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Lean.Expr → Lean.MetaM Lean.Expr | The codomain of a morphism. | true |
ModuleCat.isLimitKernelFork._proof_6 | Mathlib.Algebra.Category.ModuleCat.Kernels | ∀ {R : Type u_2} [inst : Ring R] {M N P : ModuleCat R} (f : M ⟶ N) (g : N ⟶ P)
(H : Function.Exact ⇑(ModuleCat.Hom.hom f) ⇑(ModuleCat.Hom.hom g)) (H₂ : Function.Injective ⇑(ModuleCat.Hom.hom f))
(j : CategoryTheory.Limits.WalkingParallelPair),
(ModuleCat.kernelCone g).π.app j =
CategoryTheory.CategoryStruct.c... | null | false |
TopologicalSpace.Fiber.sigmaIsoHom.match_1 | Mathlib.Topology.FiberPartition | {S : Type u_1} →
{Y : Type u_2} →
(f : S → Y) →
(motive : (x : Function.Fiber f) × ↑↑x → Sort u_3) →
(x : (x : Function.Fiber f) × ↑↑x) → ((a : Function.Fiber f) → (x : ↑↑a) → motive ⟨a, x⟩) → motive x | null | false |
SheafOfModules.IsFiniteType.rec | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | {C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat] →
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddComm... | null | false |
cuspsSubMulAction | Mathlib.NumberTheory.ModularForms.Cusps | (𝒢 : Subgroup (GL (Fin 2) ℝ)) → SubMulAction (↥𝒢) (OnePoint ℝ) | The action of `𝒢` on its own cusps. | true |
Lean.Lsp.DocumentColorParams.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{toWorkDoneProgressParams : Lean.Lsp.WorkDoneProgressParams} →
{toPartialResultParams : Lean.Lsp.PartialResultParams} →
{textDocument : Lean.Lsp.TextDocumentIdentifier} →
{toWorkDoneProgressParams' : Lean.Lsp.WorkDoneProgressParams} →
{toPartialResultParams' : Lean.Lsp.Parti... | null | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageX._proof_7 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r : ℤ) (pq : κ) (hr : r₀ ≤ r),
data.i₀ r pq ⋯ ≤ data.i₁ pq | null | false |
Lean.Meta.mkId | Lean.Meta.AppBuilder | Lean.Expr → Lean.MetaM Lean.Expr | Returns `id e` | true |
AlternatingMap.domCoprod.summand._proof_1 | Mathlib.LinearAlgebra.Alternating.DomCoprod | ∀ {ιa : Type u_1} {ιb : Type u_2} [inst : Fintype ιa] [inst_1 : Fintype ιb] {R' : Type u_6} {Mᵢ : Type u_3}
{N₁ : Type u_4} {N₂ : Type u_5} [inst_2 : CommSemiring R'] [inst_3 : AddCommGroup N₁] [inst_4 : Module R' N₁]
[inst_5 : AddCommGroup N₂] [inst_6 : Module R' N₂] [inst_7 : AddCommMonoid Mᵢ] [inst_8 : Module R'... | null | false |
Subalgebra.mem_saturation_iff._simp_1 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
{s : Subalgebra R S} {M : Submonoid S} {H : M ≤ s.toSubmonoid} {x : S}, (x ∈ s.saturation M H) = ∃ m ∈ M, m • x ∈ s | null | false |
Fin.sum_univ_five | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddCommMonoid M] (f : Fin 5 → M), ∑ i, f i = f 0 + f 1 + f 2 + f 3 + f 4 | null | true |
Mathlib.Tactic.Widget.StringDiagram.stringEqM? | Mathlib.Tactic.Widget.StringDiagram | Lean.Expr → Lean.MetaM (Option ProofWidgets.Html) | Given an equality between 2-morphisms, return a string diagram of the LHS and RHS.
Otherwise `none`. | true |
_private.Init.Data.String.Lemmas.Splits.0.String.Pos.Splits.nextn._simp_1_1 | Init.Data.String.Lemmas.Splits | ∀ {s : String} {p : s.Pos} {t₁ t₂ : String}, p.Splits t₁ t₂ = p.toSlice.Splits t₁ t₂ | null | false |
MonadCont.Label.rec | Mathlib.Control.Monad.Cont | {α : Type w} →
{m : Type u → Type v} →
{β : Type u} →
{motive : MonadCont.Label α m β → Sort u_1} →
((apply : α → m β) → motive { apply := apply }) → (t : MonadCont.Label α m β) → motive t | null | false |
List.take_concat_get | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {l : List α} {i : ℕ} (h : i < l.length), (List.take i l).concat l[i] = List.take (i + 1) l | null | true |
range_pow_padicValNat_subset_divisors' | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p n : ℕ} [hp : Fact (Nat.Prime p)],
Finset.image (fun t => p ^ (t + 1)) (Finset.range (padicValNat p n)) ⊆ n.divisors.erase 1 | null | true |
DihedralGroup.oddCommuteEquiv | Mathlib.GroupTheory.SpecificGroups.Dihedral | {n : ℕ} → Odd n → { p // Commute p.1 p.2 } ≃ ZMod n ⊕ ZMod n ⊕ ZMod n ⊕ ZMod n × ZMod n | If n is odd, then the Dihedral group of order $2n$ has $n(n+3)$ pairs (represented as
$n + n + n + n*n$) of commuting elements. | true |
Filter.EventuallyEq.fun_comp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} {f g : α → β} {l : Filter α}, f =ᶠ[l] g → ∀ (h : β → γ), h ∘ f =ᶠ[l] h ∘ g | See `EventuallyEq.comp_tendsto` in Mathlib.Order.Filter.Tendsto for a similar statement w.r.t.
composition on the right. | true |
ShareCommonT | Init.ShareCommon | ShareCommon.StateFactory → (Type u → Type v) → Type u → Type (max u v) | null | true |
StarRingEquiv.mk.inj | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_1} {B : Type u_2} {inst : Add A} {inst_1 : Add B} {inst_2 : Mul A} {inst_3 : Mul B} {inst_4 : Star A}
{inst_5 : Star B} {toRingEquiv : A ≃+* B}
{map_star' : ∀ (a : A), toRingEquiv.toFun (star a) = star (toRingEquiv.toFun a)} {toRingEquiv_1 : A ≃+* B}
{map_star'_1 : ∀ (a : A), toRingEquiv_1.toFun (st... | null | true |
MeasureTheory.FiniteMeasure.ennreal_coeFn_eq_coeFn_toMeasure | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (ν : MeasureTheory.FiniteMeasure Ω) (s : Set Ω), ↑(ν s) = ↑ν s | null | true |
ConditionallyCompleteLinearOrderedField.le_inducedMap_mul_self_of_mem_cutMap | Mathlib.Algebra.Order.CompleteField | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : Field β]
[inst_4 : ConditionallyCompleteLinearOrder β] [IsStrictOrderedRing β] [Archimedean α] {a : α},
0 < a →
∀ b ∈ LinearOrderedField.cutMap β (a * a),
b ≤
ConditionallyCompleteLinearOrde... | Preparatory lemma for `inducedOrderRingHom`. | true |
_private.Lean.Meta.Tactic.Grind.PP.0.Lean.Meta.Grind.isArithOfCastLike | Lean.Meta.Tactic.Grind.PP | Lean.Expr → Bool | Returns `true` if `e` is an expression constructed using numerals,
`grind` cast-like operations, and arithmetic terms. Moreover, the
expression contains at least one cast-like application.
This kind of term is constructed by `grind` satellite solvers.
| true |
Lean.Parser.InputContext.substring | Lean.Parser.Types | Lean.Parser.InputContext → String.Pos.Raw → String.Pos.Raw → Substring.Raw | Extracts a substring of the input string, bounded by `startPos` and `stopPos`.
| true |
Std.Time.Duration.addMilliseconds | Std.Time.Duration | Std.Time.Duration → Std.Time.Millisecond.Offset → Std.Time.Duration | Adds a `Millisecond.Offset` to a `Duration`
| true |
Std.DHashMap.Raw.mem_toList_iff_get?_eq_some._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α],
m.WF → ∀ {k : α} {v : β k}, (⟨k, v⟩ ∈ m.toList) = (m.get? k = some v) | null | false |
_private.Mathlib.RingTheory.Valuation.Discrete.Basic.0.Valuation.valuationSubring_not_isField._simp_1_1 | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {R : Type u} [inst : NonAssocRing R] (s : Subring R) {x : ↥s}, (↑x = 0) = (x = 0) | null | false |
CategoryTheory.Bicategory.id_whiskerLeft._autoParam | Mathlib.CategoryTheory.Bicategory.Basic | Lean.Syntax | null | false |
CategoryTheory.Cat.HasLimits.limitCone_pt | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat),
(CategoryTheory.Cat.HasLimits.limitCone F).pt = CategoryTheory.Cat.HasLimits.limitConeX F | null | true |
_private.Mathlib.Algebra.Order.BigOperators.Ring.Finset.0.Finset.prod_add_prod_le._simp_1_7 | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
TensorProduct.ext_iff_inner_right_threefold | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G] {x y : TensorProduct 𝕜 (TensorProdu... | Given `x, y : E ⊗ F ⊗ G`, `x = y` iff `⟪x, a ⊗ₜ b ⊗ₜ c⟫ = ⟪y, a ⊗ₜ b ⊗ₜ c⟫` for all `a, b, c`.
See also `ext_iff_inner_right_threefold'` for when `x, y : E ⊗ (F ⊗ G)`. | true |
_private.Mathlib.Tactic.Determinant.Bird.Cert.0.Mathlib.Tactic.Determinant.certIterStepEntry.match_1 | Mathlib.Tactic.Determinant.Bird.Cert | (motive : ℕ → Sort u_1) → (t : ℕ) → (Unit → motive 0) → ((t' : ℕ) → motive t'.succ) → motive t | null | false |
Complex.re_nonneg_iff_nonneg | Mathlib.Analysis.Complex.Basic | ∀ {x : ℂ}, IsSelfAdjoint x → (0 ≤ x.re ↔ 0 ≤ x) | null | true |
CategoryTheory.Limits.KernelFork.IsLimit.ofι'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y K : C} {f : X ⟶ Y} (i : K ⟶ X)
(h :
{A : C} →
(k : A ⟶ X) → CategoryTheory.CategoryStruct.comp k f = 0 → { l // CategoryTheory.CategoryStruct.comp l i = k })
[hi : CategoryTheory.Mono ... | null | false |
_private.Mathlib.Combinatorics.Graph.Delete.0.Graph.deleteEdges_mono_left._simp_1_1 | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_1} {β : Type u_2} (G : Graph α β) (F : Set β), G.deleteEdges F = G.restrict (G.edgeSet \ F) | null | false |
_private.Lean.Declaration.0.Lean.ConstantInfo.value?._sparseCasesOn_1 | Lean.Declaration | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
((val : Lean.OpaqueVal) → motive (Lean.ConstantInfo.opaqueInfo val)) →
(Nat.hasNot... | null | false |
Lean.Meta.PostponedEntry.ctorIdx | Lean.Meta.Basic | Lean.Meta.PostponedEntry → ℕ | null | false |
Std.TreeSet.getD_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k a fallback : α},
(t.insert k).getD a fallback = if cmp k a = Ordering.eq ∧ k ∉ t then k else t.getD a fallback | null | true |
LieDerivation.instLieAlgebra._proof_1 | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (r : R)
(d e : LieDerivation R L L), ⁅d, r • e⁆ = r • ⁅d, e⁆ | null | false |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.insertAux.match_3 | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
(motive : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β) → Sort u_3) →
(entry : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) →
(Unit → motive Lean.PersistentHashMap.Entry.null) →
((node : Lean.PersistentHashMap.No... | null | false |
OrderHomClass | Mathlib.Order.Hom.Basic | (F : Type u_6) → (α : outParam (Type u_7)) → (β : outParam (Type u_8)) → [LE α] → [LE β] → [FunLike F α β] → Prop | `OrderHomClass F α b` asserts that `F` is a type of `≤`-preserving morphisms. | true |
Std.max_eq_ite_isGE_compare | Init.Data.Order.LemmasExtra | ∀ {α : Type u} [inst : Ord α] [inst_1 : LE α] {x : Max α} [Std.LawfulOrderOrd α] [Std.LawfulOrderLeftLeaningMax α]
{a b : α}, a ⊔ b = if (compare a b).isGE = true then a else b | null | true |
lineDerivWithin.eq_1 | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] (f : E → F) (s : Set E)
(x v : E), lineDerivWithin 𝕜 f s x v = derivWithin (fun t => f (x + t • v)) ((fun t => x + t • v) ... | null | true |
Std.Sat.AIG.IsPrefix.of._flat_ctor | Std.Sat.AIG.LawfulOperator | ∀ {α : Type} {decls1 decls2 : Array (Std.Sat.AIG.Decl α)} (size_le : decls1.size ≤ decls2.size),
(∀ (idx : ℕ) (h : idx < decls1.size), decls2[idx] = decls1[idx]) → Std.Sat.AIG.IsPrefix decls1 decls2 | null | false |
GenContFract.zeroth_den_eq_one | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K], g.dens 0 = 1 | null | true |
Lean.MonadCacheT.instAlternative | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] → [inst_2 : Hashable α] → [Monad m] → [Alternative m] → Alternative (Lean.MonadCacheT α β m) | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_245 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
ZMod.erdos_ginzburg_ziv | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {ι : Type u_1} {n : ℕ} {s : Finset ι} (a : ι → ZMod n), 2 * n - 1 ≤ s.card → ∃ t ⊆ s, t.card = n ∧ ∑ i ∈ t, a i = 0 | The **Erdős–Ginzburg–Ziv theorem** for `ℤ/nℤ`.
Any sequence of at least `2 * n - 1` elements of `ZMod n` contains a subsequence of `n` elements
whose sum is zero. | true |
HomologicalComplex.dgoToHomologicalComplex | Mathlib.Algebra.Homology.DifferentialObject | {β : Type u_1} →
[inst : AddCommGroup β] →
(b : β) →
(V : Type u_2) →
[inst_1 : CategoryTheory.Category.{v_1, u_2} V] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V] →
CategoryTheory.Functor (CategoryTheory.DifferentialObject ℤ (CategoryTheory.GradedObjectWithShift b V))
... | The functor from differential graded objects to homological complexes.
| true |
Lean.Meta.Grind.Arith.Linear.Struct.recOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive : Lean.Meta.Grind.Arith.Linear.Struct → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.Struct) →
((id : ℕ) →
(ringId? : Option ℕ) →
(type : Lean.Expr) →
(u : Lean.Level) →
(intModuleInst : Lean.Expr) →
(leInst? ltInst? lawfulOrderLTInst? isPreorderI... | null | false |
CategoryTheory.MorphismProperty.of_pullback_fst_of_descendsAlong | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C} {X Y Z : C}
{f : X ⟶ Z} {g : Y ⟶ Z} [P.DescendsAlong Q] [inst_2 : CategoryTheory.Limits.HasPullback f g],
Q f → P (CategoryTheory.Limits.pullback.fst f g) → P g | null | true |
_private.Lean.Meta.Hint.0.Lean.Meta.Hint.mkSuggestionsMessage._sparseCasesOn_5 | Lean.Meta.Hint | {motive : Lean.Meta.Hint.DiffGranularity → Sort u} →
(t : Lean.Meta.Hint.DiffGranularity) →
motive Lean.Meta.Hint.DiffGranularity.none → (Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
Lean.PrettyPrinter.Formatter.State.mk.injEq | Lean.PrettyPrinter.Formatter | ∀ (stxTrav : Lean.Syntax.Traverser) (leadWord : String) (leadWordIdent isUngrouped mustBeGrouped : Bool)
(stack : Array Std.Format) (stxTrav_1 : Lean.Syntax.Traverser) (leadWord_1 : String)
(leadWordIdent_1 isUngrouped_1 mustBeGrouped_1 : Bool) (stack_1 : Array Std.Format),
({ stxTrav := stxTrav, leadWord := lead... | null | true |
UInt16.size_dvd_usizeSize | Init.Data.UInt.Lemmas | UInt16.size ∣ USize.size | null | true |
instIsLocalizedModuleToLinearMapToAlgHomOfIsLocalizationAlgebraMapSubmonoid | Mathlib.Algebra.Module.LocalizedModule.IsLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {A : Type u_2} {Aₛ : Type u_3} [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : CommSemiring Aₛ] [inst_4 : Algebra A Aₛ] [inst_5 : Algebra R Aₛ]
[inst_6 : IsScalarTower R A Aₛ] [IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ],
IsLocalizedMo... | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_15 | Init.Data.BitVec.Bitblast | ∀ {p : Prop} [Decidable p], (¬¬p) = p | null | false |
Std.HashSet.Raw.containsThenInsert_fst | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α],
m.WF → ∀ {k : α}, (m.containsThenInsert k).1 = m.contains k | null | true |
spectrum.zero_notMem | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsUnit a → 0 ∉ spectrum R a | **Alias** of the reverse direction of `spectrum.zero_notMem_iff`. | true |
Std.ExtTreeMap.getKey?_minKey! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α], t ≠ ∅ → t.getKey? t.minKey! = some t.minKey! | null | true |
_private.Mathlib.NumberTheory.ModularForms.Bounds.0.CuspFormClass.exists_sum_range_norm_sq_qExpansion_coeff_le_of_mem_strictPeriods._simp_1_1 | Mathlib.NumberTheory.ModularForms.Bounds | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
AffineEquiv.mk | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_4} →
{V₂ : Type u_5} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
... | null | true |
_private.Mathlib.Data.List.Cycle.0.List.next_getLast_eq_head_of_notMem_dropLast._proof_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α}, l ≠ [] → 0 < l.length | null | false |
Btw.btw.antisymm | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularPartialOrder α] {a b c : α}, btw a b c → btw c b a → a = b ∨ b = c ∨ c = a | null | true |
isEllDivSequence_id | Mathlib.NumberTheory.EllipticDivisibilitySequence | IsEllipticDvdSequence id | **Alias** of `IsEllipticDvdSequence.id`.
---
The identity sequence is an EDS. | true |
Concept.intent_swap | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} (c : Concept α β r), c.swap.intent = c.extent | null | true |
MeasureTheory.Ioo_ae_eq_Ioc' | Mathlib.MeasureTheory.Measure.Interval | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : PartialOrder α] {a b : α},
μ {b} = 0 → Set.Ioo a b =ᵐ[μ] Set.Ioc a b | null | true |
ArithmeticFunction.vonMangoldt.residueClass_apply | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {q : ℕ} {a : ZMod q} [NeZero q],
IsUnit a →
∀ (n : ℕ),
↑(ArithmeticFunction.vonMangoldt.residueClass a n) =
(↑q.totient)⁻¹ * ∑ χ, χ a⁻¹ * χ ↑n * ↑(ArithmeticFunction.vonMangoldt n) | We can express `ArithmeticFunction.vonMangoldt.residueClass` as a linear combination
of twists of the von Mangoldt function by Dirichlet characters. | true |
TopologicalSpace.CompactOpens.coe_inf | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : QuasiSeparatedSpace α] (s t : TopologicalSpace.CompactOpens α),
↑(s ⊓ t) = ↑s ∩ ↑t | null | true |
AlgEquiv.aut_inv | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁]
(ϕ : A₁ ≃ₐ[R] A₁), ϕ⁻¹ = ϕ.symm | null | true |
MeasureTheory.L2.instInnerSubtypeAEEqFunMemAddSubgroupLpOfNatENNReal._proof_1 | Mathlib.MeasureTheory.Function.L2Space | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | null | false |
FinBddDistLat.forget_map | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y : FinBddDistLat} (f : X ⟶ Y),
⇑(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.forget FinBddDistLat).map f)) =
⇑(CategoryTheory.ConcreteCategory.hom f) | null | true |
Pi.zero_apply | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {M : ι → Type u_5} [inst : (i : ι) → Zero (M i)] (i : ι), 0 i = 0 | null | true |
List.toList_iter | Init.Data.Iterators.Lemmas.Producers.List | ∀ {β : Type w} {l : List β}, l.iter.toList = l | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.Evaluation.0.MvPolynomial.toMvPowerSeries_uniformContinuous._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.Evaluation | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) | null | false |
Std.Tactic.BVDecide.BVLogicalExpr.eval | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVExpr.Assignment → Std.Tactic.BVDecide.BVLogicalExpr → Bool | The semantics of boolean problems involving BitVec predicates as atoms.
| true |
Lean.Meta.RefinedDiscrTree.instToFormatLazyEntry | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Std.ToFormat Lean.Meta.RefinedDiscrTree.LazyEntry | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.