name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UpperHalfPlane.measurableEmbedding_coe | Mathlib.Analysis.Complex.UpperHalfPlane.Measure | MeasurableEmbedding UpperHalfPlane.coe | null | true |
rothNumberNat_le_ruzsaSzemerediNumberNat' | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ (n : ℕ), (↑n / 3 - 2) * ↑(rothNumberNat ((n - 3) / 6)) ≤ ↑(ruzsaSzemerediNumberNat n) | Lower bound on the **Ruzsa-Szemerédi problem** in terms of 3AP-free sets.
If there exists a 3AP-free subset of `[1, ..., (n - 3) / 6]` of size `m`, then there exists a graph
with `n` vertices and `(n / 3 - 2) * m` edges such that each edge belongs to exactly one triangle.
| true |
Nat.lt_sum_ge | Batteries.Data.Nat.Lemmas | (a b : ℕ) → a < b ⊕' b ≤ a | Strong case analysis on `a < b ∨ b ≤ a` | true |
CategoryTheory.ShortComplex.SnakeInput.functorL₃_obj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.ShortComplex.SnakeInput.functorL₃.obj S = S.L₃ | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral.0.integral_gaussian_complex._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral | Complex.ofReal = ⇑(algebraMap ℝ ℂ) | null | false |
mem_subalgebraOfSubring._simp_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_1} [inst : Ring R] {x : R} {S : Subring R}, (x ∈ subalgebraOfSubring S) = (x ∈ S) | null | false |
CircleDeg1Lift.monotone | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), Monotone ⇑f | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.elabBlock.withSpace | Lean.Elab.DocString | String → String | null | true |
MulRightReflectLE.casesOn | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | {M : Type u_1} →
[inst : Mul M] →
[inst_1 : LE M] →
{motive : MulRightReflectLE M → Sort u} →
(t : MulRightReflectLE M) →
((le_of_mul_le_mul_right' : ∀ {b a₁ a₂ : M}, a₁ * b ≤ a₂ * b → a₁ ≤ a₂) → motive ⋯) → motive t | null | false |
CategoryTheory.Pretriangulated.Triangle.functorHomMk._proof_1 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} J]
(A B : CategoryTheory.Functor J (CategoryTheory.Pretriangulated.Triangle C))
(hom₁ : A.comp CategoryTheory.Pretriangulated.Triangle.π₁ ⟶ B.comp Categ... | null | false |
Setoid.instPartialOrder | Mathlib.Data.Setoid.Basic | {α : Type u_1} → PartialOrder (Setoid α) | null | true |
AlgHom.toLieHom_apply | Mathlib.Algebra.Lie.OfAssociative | ∀ {A : Type v} [inst : Ring A] {R : Type u} [inst_1 : CommRing R] [inst_2 : Algebra R A] {B : Type w} [inst_3 : Ring B]
[inst_4 : Algebra R B] (f : A →ₐ[R] B) (x : A), f.toLieHom x = f x | null | true |
Ideal.map_pi | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} [inst : Ring R] (I : Ideal R) [I.IsTwoSided] [Finite ι] (x : ι → R),
(∀ (i : ι), x i ∈ I) → ∀ (f : (ι → R) →ₗ[R] ι' → R) (i : ι'), f x i ∈ I | If `f : R^n → R^m` is an `R`-linear map and `I ⊆ R` is an ideal, then the image of `I^n` is
contained in `I^m`. | true |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.extractBind.match_4 | Lean.Elab.Do.Legacy | (motive : Option Lean.Expr → Sort u_1) →
(expectedType? : Option Lean.Expr) →
((expectedType : Lean.Expr) → motive (some expectedType)) →
((x : Option Lean.Expr) → motive x) → motive expectedType? | null | false |
MeasureTheory.measureReal_add_sdiff._auto_1 | Mathlib.MeasureTheory.Measure.Real | Lean.Syntax | null | false |
ENat.pow_ne_top_iff | Mathlib.Data.ENat.Basic | ∀ {a : ℕ∞} {n : ℕ}, a ^ n ≠ ⊤ ↔ a ≠ ⊤ ∨ n = 0 | null | true |
Nat.count_strict_mono | Mathlib.Data.Nat.Count | ∀ {p : ℕ → Prop} [inst : DecidablePred p] {m n : ℕ}, p m → m < n → Nat.count p m < Nat.count p n | null | true |
Derivation.map_smul_of_tower | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] {S : Type u_5}
[inst_6 : SMul S A] [inst_7 : SMul S M] [LinearMap.CompatibleSMul A M S R] (D : Derivation R A M) (r : S) (a :... | null | true |
MeasureTheory.IsStoppingTime | Mathlib.Probability.Process.Stopping | {Ω : Type u_1} →
{ι : Type u_3} → {m : MeasurableSpace Ω} → [inst : Preorder ι] → MeasureTheory.Filtration ι m → (Ω → WithTop ι) → Prop | A stopping time with respect to some filtration `f` is a function
`τ` such that for all `i`, the preimage of `{j | j ≤ i}` along `τ` is measurable
with respect to `f i`.
Intuitively, the stopping time `τ` describes some stopping rule such that at time
`i`, we may determine it with the information we have at time `i`. | true |
DirectSum.lequivCongrLeft_symm_lof | Mathlib.Algebra.DirectSum.Module | ∀ (R : Type u) [inst : Semiring R] {ι : Type v} {M : ι → Type w} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] {κ : Type u_1} [inst_3 : DecidableEq ι] [inst_4 : DecidableEq κ] {h : ι ≃ κ}
{k : κ} {x : M (h.symm k)},
(DirectSum.lequivCongrLeft R h).symm ((DirectSum.lof R κ (fun k => ... | null | true |
Function.Embedding.twoEmbeddingEquiv.match_1 | Mathlib.Data.Fin.Tuple.Embedding | {α : Type u_1} → (motive : α × α → Sort u_2) → (x : α × α) → ((a b : α) → motive (a, b)) → motive x | null | false |
List.Perm.trans | Init.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ l₃ : List α}, l₁.Perm l₂ → l₂.Perm l₃ → l₁.Perm l₃ | Permutation is transitive: `l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃`.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.exp_inj._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a b : G}, (a ≡ b [PMOD p]) = ∃ m, b - a = m • p | null | false |
LaurentPolynomial.isLocalization | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : CommSemiring R], IsLocalization.Away Polynomial.X (LaurentPolynomial R) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.adj_incidenceSet_inter._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Quaternion.instGroupWithZero._proof_7 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R], Nontrivial (Quaternion R) | null | false |
EMetric.ball_subset | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε₁ ε₂ : ENNReal},
edist x y + ε₁ ≤ ε₂ → edist x y ≠ ⊤ → Metric.eball x ε₁ ⊆ Metric.eball y ε₂ | **Alias** of `Metric.eball_subset`. | true |
SimpleGraph.diam_anti_of_ediam_ne_top | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1} {G G' : SimpleGraph α}, G ≤ G' → G.ediam ≠ ⊤ → G'.diam ≤ G.diam | null | true |
Lean.Order.instMonadTailST | Init.Internal.Order.MonadTail | {σ : Type} → Lean.Order.MonadTail (ST σ) | null | true |
_private.Mathlib.NumberTheory.Padics.ProperSpace.0.PadicInt.totallyBounded_univ._simp_1_5 | Mathlib.NumberTheory.Padics.ProperSpace | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : β → Prop}, (∃ y ∈ f '' s, p y) = ∃ x ∈ s, p (f x) | null | false |
_private.Mathlib.Tactic.NormNum.Eq.0.Mathlib.Meta.NormNum.evalEq.match_8 | Mathlib.Tactic.NormNum.Eq | (u : Lean.Level) →
(α :
have u := u;
Q(Type u)) →
(dsα : Q(DivisionSemiring «$α»)) →
(motive : Option Q(CharZero «$α») → Sort u_1) →
(__do_lift : Option Q(CharZero «$α»)) →
((_i : Q(CharZero «$α»)) → motive (some _i)) → ((x : Option Q(CharZero «$α»)) → motive x) → motive __do_l... | null | false |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.initFn._@.Lean.Parser.Term.Basic.2382944618._hygCtx._hyg.2 | Lean.Parser.Term.Basic | IO Unit | null | false |
Isometry.mapsTo_emetric_closedBall | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
Isometry f → ∀ (x : α) (r : ENNReal), Set.MapsTo f (Metric.closedEBall x r) (Metric.closedEBall (f x) r) | **Alias** of `Isometry.mapsTo_closedEBall`. | true |
Std.HashMap.Raw.emptyWithCapacity | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → optParam ℕ 8 → Std.HashMap.Raw α β | Creates a new empty hash map. The optional parameter `capacity` can be supplied to presize the
map so that it can hold the given number of mappings without reallocating. It is also possible to
use the empty collection notations `∅` and `{}` to create an empty hash map with the default
capacity.
| true |
SheafOfModules.Presentation.IsFinite.casesOn | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] →
[inst_3 : J.HasShe... | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.processLevel.go._sparseCasesOn_3 | Lean.Meta.Sym.Pattern | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
motive Lean.Level.zero →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a : Lean.LMVarId) → motive (Lean.Level.mvar a)) → (Nat.hasNotBit 37 t.ctorIdx → motive t) → motive t | null | false |
CochainComplex.Lifting.coe_cocycle₁'_v_comp_eq_zero | Mathlib.Algebra.Homology.ModelCategory.Lifting | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{A B X Y : CochainComplex C ℤ} {t : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {b : B ⟶ Y} (sq : CategoryTheory.CommSq t i p b)
(hsq : (n : ℤ) → ⋯.LiftStruct) (n m : ℤ)
(hnm : autoParam (n + 1 = m) CochainComplex.Lifting.coe_co... | null | true |
Vector.findSomeRev? | Init.Data.Vector.Basic | {α : Type u_1} → {β : Type u_2} → {n : ℕ} → (α → Option β) → Vector α n → Option β | null | true |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ico_succ_left_eq_erase_Ico._simp_1_2 | Mathlib.Order.Interval.Finset.Nat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
Lean.Elab.Term.Do.ToTerm.Kind.nestedSBC | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Kind | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Lean.MVarId.grewrite._sparseCasesOn_1 | Mathlib.Tactic.GRewrite.Core | {motive : ℕ → Sort u} → (t : ℕ) → ((n : ℕ) → motive n.succ) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.reverse._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, p.reverse.support.tail.Nodup = p.support.tail.Nodup | null | false |
ProofWidgets.RpcEncodablePacket.mk.injEq._@.ProofWidgets.Presentation.Expr.3227936355._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | ∀ (expr expr_1 : Lean.Json), ({ expr := expr } = { expr := expr_1 }) = (expr = expr_1) | null | false |
Ring.inverse_non_unit | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (x : M₀), ¬IsUnit x → Ring.inverse x = 0 | By definition, if `x` is not invertible then `inverse x = 0`. | true |
HasSum.smul_eq | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {ι : Type u_5} {κ : Type u_6} {R : Type u_7} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace M] [T3Space M] [ContinuousAdd M]
[ContinuousSMul R M] {f : ι → R} {g : κ → M} {s : R} {t u : M},
HasSum f s → HasSum g t → Has... | null | true |
HasDerivAt.nonpos_of_antitone | Mathlib.Analysis.Calculus.Deriv.Slope | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[OrderTopology 𝕜] {g : 𝕜 → 𝕜} {g' : 𝕜}, HasDerivAt g g' x → Antitone g → g' ≤ 0 | If an antitone function has a derivative, then this derivative is nonpositive. | true |
Module.Basis.addSubgroupOfClosure._proof_1 | Mathlib.LinearAlgebra.Basis.Submodule | ∀ {M : Type u_1} {R : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (A : AddSubgroup M)
{ι : Type u_2} (b : Module.Basis ι R M),
A = AddSubgroup.closure (Set.range ⇑b) → Submodule.span ℤ (Set.range ⇑b) = AddSubgroup.toIntSubmodule A | null | false |
NormedStarGroup.rec | Mathlib.Analysis.CStarAlgebra.Basic | {E : Type u_1} →
[inst : SeminormedAddCommGroup E] →
[inst_1 : StarAddMonoid E] →
{motive : NormedStarGroup E → Sort u} →
((norm_star_le : ∀ (x : E), ‖star x‖ ≤ ‖x‖) → motive ⋯) → (t : NormedStarGroup E) → motive t | null | false |
CategoryTheory.Limits.PushoutCocone.ext | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} →
{f : X ⟶ Y} →
{g : X ⟶ Z} →
{s t : CategoryTheory.Limits.PushoutCocone f g} →
(i : s.pt ≅ t.pt) →
autoParam (CategoryTheory.CategoryStruct.comp s.inl i.hom = t.inl)
Category... | To construct an isomorphism of pushout cocones, it suffices to construct an isomorphism
of the cocone points and check it commutes with `inl` and `inr`. | true |
_private.Mathlib.Condensed.Light.Sequence.0.InternalProjectivityProof.cover._proof_2 | Mathlib.Condensed.Light.Sequence | ∀ {S T : LightProfinite} (π : T ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj S LightProfinite.NatUnionInfty),
CompactSpace
(↑T.toTop ⊕
↑(CompHausLike.pullback
(CategoryTheory.CategoryStruct.comp
(InternalProjectivityProof.LightProfinite.fibreIncl✝ OnePoint.infty
... | null | false |
HomotopicalAlgebra.Precylinder.mk.inj | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {A I : C} {i₀ i₁ : A ⟶ I} {π : I ⟶ A}
{i₀_π :
autoParam (CategoryTheory.CategoryStruct.comp i₀ π = CategoryTheory.CategoryStruct.id A)
HomotopicalAlgebra.Precylinder.i₀_π._autoParam}
{i₁_π :
autoParam (CategoryTheory.CategoryStruct.comp i₁ π = C... | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.δ_σ₀Iter'._proof_1_13 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (j : ℕ) {m : ℕ}, j = 0 → m + 1 + 1 + j = m + 1 + 1 | null | false |
ProbabilityTheory.Kernel.condKernelReal.eq_1 | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {γ : Type u_3} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × ℝ))
[inst_1 : ProbabilityTheory.IsFiniteKernel κ],
κ.condKernelReal = ProbabilityTheory.IsCondKernelCDF.toKernel κ.condKernelCDF ⋯ | null | true |
Nonempty.some | Mathlib.Logic.Nonempty | {α : Sort u_3} → Nonempty α → α | Using `Classical.choice`, extracts a term from a `Nonempty` type. | true |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.map_add_atTop_eq._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b c : α}, (a ≤ c - b) = (a + b ≤ c) | null | false |
HasCardinalLT.Set.cocone_ι_app | Mathlib.CategoryTheory.Presentable.Type | ∀ (X : Type u) (κ : Cardinal.{u}) (x : HasCardinalLT.Set X κ),
(HasCardinalLT.Set.cocone X κ).ι.app x = TypeCat.ofHom Subtype.val | null | true |
Equiv.prodUnique_symm_apply | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} {β : Type u_10} [inst : Unique β] (x : α), (Equiv.prodUnique α β).symm x = (x, default) | null | true |
MeasureTheory.Measure.sum_eq_zero | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} {f : ι → MeasureTheory.Measure α},
MeasureTheory.Measure.sum f = 0 ↔ ∀ (i : ι), f i = 0 | null | true |
Std.Async.System.SystemUser.mk.injEq | Std.Async.System | ∀ (username : String) (userId : Option Std.Async.System.UserId) (groupId : Option Std.Async.System.GroupId)
(shell : Option String) (homeDir : Option System.FilePath) (username_1 : String)
(userId_1 : Option Std.Async.System.UserId) (groupId_1 : Option Std.Async.System.GroupId) (shell_1 : Option String)
(homeDir_... | null | true |
Turing.PartrecToTM2.natEnd | Mathlib.Computability.TuringMachine.ToPartrec | Turing.PartrecToTM2.Γ' → Bool | A predicate that detects the end of a natural number, either `Γ'.cons` or `Γ'.consₗ` (or
implicitly the end of the list), for use in predicate-taking functions like `move` and `clear`. | true |
Lean.addTraceAsMessages | Lean.Util.Trace | {m : Type → Type} →
[Lean.MonadOptions m] → [Monad m] → [Lean.MonadRef m] → [Lean.MonadLog m] → [Lean.MonadTrace m] → m Unit | null | true |
Real.exp_one_rpow | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ (x : ℝ), Real.exp 1 ^ x = Real.exp x | null | true |
CategoryTheory.Presheaf.restrictedULiftYonedaHomEquiv' | Mathlib.CategoryTheory.Limits.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{ℰ : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ] →
(A : CategoryTheory.Functor C ℰ) →
(P : CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) →
(E : ℰ) →
((CategoryTheory.CostructuredArrow.pr... | Auxiliary definition for `restrictedULiftYonedaHomEquiv`. | true |
Lagrange.eval_basis_of_ne | Mathlib.LinearAlgebra.Lagrange | ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : DecidableEq ι] {s : Finset ι} {v : ι → F} {i j : ι},
i ≠ j → j ∈ s → Polynomial.eval (v j) (Lagrange.basis s v i) = 0 | null | true |
AddCon.pi.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {ι : Type u_4} {f : ι → Type u_5} [inst : (i : ι) → Add (f i)] (C : (i : ι) → AddCon (f i)),
AddCon.pi C = { toSetoid := piSetoid, add' := ⋯ } | null | true |
Lean.registerOption | Lean.Data.Options | Lean.Name → Lean.OptionDecl → IO Unit | null | true |
TensorProduct.norm_map | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {H : Type u_5} [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]
[inst_7 : NormedAdd... | null | true |
Finsupp.sum_ite_eq | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] [inst_2 : DecidableEq α]
(f : α →₀ M) (a : α) (b : α → M → N),
(f.sum fun x v => if a = x then b x v else 0) = if a ∈ f.support then b a (f a) else 0 | null | true |
CategoryTheory.ShortComplex.Homotopy.rec | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ₁ φ₂ : S₁ ⟶ S₂} →
{motive : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ → Sort u} →
((h₀ : S₁.X₁ ⟶ S₂.X₁) →
(h₀_... | null | false |
Lean.PersistentHashMap.mk.injEq | Lean.Data.PersistentHashMap | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (root root_1 : Lean.PersistentHashMap.Node α β),
({ root := root } = { root := root_1 }) = (root = root_1) | null | true |
PEquiv.injective_of_forall_isSome | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} {f : α ≃. β}, (∀ (a : α), (f a).isSome = true) → Function.Injective ⇑f | If the domain of a `PEquiv` is all of `α`, its forward direction is injective. | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj_ε | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommMon C),
CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj A) =
CategoryTheory... | null | true |
List.sum | Init.Data.List.Basic | {α : Type u_1} → [Add α] → [Zero α] → List α → α | Computes the sum of the elements of a list.
Examples:
* `[a, b, c].sum = a + (b + (c + 0))`
* `[1, 2, 5].sum = 8`
| true |
HomotopyGroup.commGroup._proof_2 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] [inst_2 : Nontrivial N]
(a b : HomotopyGroup N X x), a * b = b * a | null | false |
Set.Finite.induction_on_subset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {motive : (s : Set α) → s.Finite → Prop} (s : Set α) (hs : s.Finite),
motive ∅ ⋯ →
(∀ {a : α} {t : Set α}, a ∈ s → ∀ (hts : t ⊆ s), a ∉ t → motive t ⋯ → motive (insert a t) ⋯) → motive s hs | Induction principle for finite sets: To prove a property `C` of a finite set `s`, it's enough
to prove for the empty set and to prove that `C t → C ({a} ∪ t)` for all `t ⊆ s`.
This is analogous to `Finset.induction_on'`. See also `Set.Finite.induction_on` for the version
requiring `motive t → motive ({a} ∪ t)` for all... | true |
Lean.ExternEntry.inline.noConfusion | Lean.Compiler.ExternAttr | {P : Sort u} →
{backend : Lean.Name} →
{pattern : String} →
{backend' : Lean.Name} →
{pattern' : String} →
Lean.ExternEntry.inline backend pattern = Lean.ExternEntry.inline backend' pattern' →
(backend = backend' → pattern = pattern' → P) → P | null | false |
FirstOrder.Language.Term.inhabitedOfConstant | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [Inhabited L.Constants] → Inhabited (L.Term α) | null | true |
Lean.Meta.Simp.Result.mk.noConfusion | Lean.Meta.Tactic.Simp.Types | {P : Sort u} →
{expr : Lean.Expr} →
{proof? : Option Lean.Expr} →
{cache : Bool} →
{expr' : Lean.Expr} →
{proof?' : Option Lean.Expr} →
{cache' : Bool} →
{ expr := expr, proof? := proof?, cache := cache } =
{ expr := expr', proof? := proof?', cac... | null | false |
MeasureTheory.Lp.coeFn_tsum | Mathlib.MeasureTheory.Function.LpSpace.InfiniteSum | ∀ {X : Type u_1} {E : Type u_2} {x : MeasurableSpace X} {μ : MeasureTheory.Measure X} [inst : NormedAddCommGroup E]
{ι : Type u_3} [Countable ι] {p : ENNReal} [hp : Fact (1 ≤ p)] [CompleteSpace E] {f : ι → ↥(MeasureTheory.Lp E p μ)},
∑' (n : ι), ‖f n‖ₑ ≠ ⊤ → ↑↑(∑' (n : ι), f n) =ᵐ[μ] fun x_1 => ∑' (n : ι), ↑↑(f n) ... | null | true |
_private.Init.Data.String.Lemmas.Iterate.0.String.Model.revPositionsFrom._proof_1 | Init.Data.String.Lemmas.Iterate | ∀ {s : String}, WellFounded (invImage (fun x => x.down) String.Pos.instWellFoundedRelationDown).1 | null | false |
_private.Lean.ImportingFlag.0.Lean.initFn._@.Lean.ImportingFlag.2251799370._hygCtx._hyg.2 | Lean.ImportingFlag | IO (IO.Ref Bool) | null | false |
CategoryTheory.MonObj.one_associator | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N P : C}
[inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] [inst_4 : CategoryTheory.MonObj P],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(Categor... | null | true |
Array.reverse_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : α → α_1 → α_2} {as : Array α} {bs : Array α_1},
as.size = bs.size → (Array.zipWith f as bs).reverse = Array.zipWith f as.reverse bs.reverse | null | true |
Mathlib.Tactic.Order.AtomicFact.le.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs : ℕ) (proof : Lean.Expr),
sizeOf (Mathlib.Tactic.Order.AtomicFact.le lhs rhs proof) = 1 + sizeOf lhs + sizeOf rhs + sizeOf proof | null | true |
OrderDual.instSemigroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [Semigroup α] → Semigroup αᵒᵈ | null | true |
EReal.instInv | Mathlib.Data.EReal.Inv | Inv EReal | null | true |
LinearPMap.inverse_apply_eq | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_4} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_5}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {f : E →ₗ.[R] F},
f.toFun.ker = ⊥ → ∀ {y : ↥f.inverse.domain} {x : ↥f.domain}, ↑f x = ↑y → ↑f.inverse y = ↑x | null | true |
Lean.MonadCache.noConfusionType | Lean.Util.MonadCache | Sort u →
{α β : Type} →
{m : Type → Type} → Lean.MonadCache α β m → {α' β' : Type} → {m' : Type → Type} → Lean.MonadCache α' β' m' → Sort u | null | false |
RegularSpace.inf | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_3} {t₁ t₂ : TopologicalSpace X}, RegularSpace X → RegularSpace X → RegularSpace X | null | true |
Fin.reduceBin | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | Lean.Name → ℕ → ({n : ℕ} → Fin n → Fin n → Fin n) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.DStep | null | true |
Lean.Parser.Command.versoCommentBody.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
Polynomial.resultant_add_mul_right | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g p : Polynomial R) (m n : ℕ),
p.natDegree + m ≤ n → f.natDegree ≤ m → f.resultant (g + f * p) m n = f.resultant g m n | `Res(f, g + fp) = Res(f, g)` if `deg f + deg p ≤ deg g`. | true |
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan._proof_7 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
{X_1 Y_1 Z_1 : CategoryTheory.Limits.PushoutCocone f g} (f_1 : X_1 ⟶ Y_1) (g_1 : Y_1 ⟶ Z_1),
{ hom := CategoryTheory.Under.homMk (CategoryTheory.CategoryStruct.comp f_1 g_1).hom ⋯, w := ⋯ } =
CategoryTheory.Catego... | null | false |
_private.Init.Data.Iterators.Consumers.Access.0.Std.Iter.atIdxSlow?.match_3.eq_2 | Init.Data.Iterators.Consumers.Access | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β) (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(property : it.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.Iter β) →
(out : β) →
(property : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yie... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsTrail.even_countP_edges_iff._simp_1_6 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
_private.Init.Data.Order.FactoriesExtra.0.DecidableLE.ofOrd._simp_3 | Init.Data.Order.FactoriesExtra | ∀ {α : Type u} {inst : Ord α} {inst_1 : LE α} [self : Std.LawfulOrderOrd α] (a b : α),
((compare a b).isLE = true) = (a ≤ b) | null | false |
FirstOrder.Language.IsOrdered.recOn | Mathlib.ModelTheory.Order | {L : FirstOrder.Language} →
{motive : L.IsOrdered → Sort u_1} →
(t : L.IsOrdered) → ((leSymb : L.Relations 2) → motive { leSymb := leSymb }) → motive t | null | false |
DomAddAct.mk_vadd_indicatorConstLp._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {M : Type u_2} {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : VAdd M α]
[MeasureTheory.VAddInvariantMeasure M α μ] (c : M) {s : Set α},
MeasurableSet s → μ s ≠ ⊤ → μ ((fun x => c +ᵥ x) ⁻¹' s) ≠ ⊤ | null | false |
HasEnoughRootsOfUnity.finite_rootsOfUnity | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) [NeZero n] [HasEnoughRootsOfUnity M n], Finite ↥(rootsOfUnity n M) | If `M` satisfies `HasEnoughRootsOfUnity`, then the group of `n`th roots of unity
in `M` is finite. | true |
_private.Mathlib.Order.Filter.Map.0.Filter.mem_comap_prodMk._simp_1_5 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.