name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
indepFun_pi_of_prod_bcf | Mathlib.Probability.Independence.BoundedContinuousFunction | ∀ {Ω : Type u_1} {T : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {F : T → Type u_5} {G : Type u_6}
[inst : (t : T) → TopologicalSpace (F t)] [inst_1 : (t : T) → MeasurableSpace (F t)] [∀ (t : T), BorelSpace (F t)]
[∀ (t : T), HasOuterApproxClosed (F t)] [inst_4 : TopologicalSpace G] [inst_5 : ... | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rci.size_eq_size_roi._proof_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} [inst : Std.Rxi.HasSize α] (l : α), Std.Rxi.HasSize.size l = 0 → Std.Rxi.HasSize.size l > 0 → False | null | false |
exists_continuous_sum_one_of_isOpen_isCompact | Mathlib.Topology.PartitionOfUnity | ∀ {X : Type v} [inst : TopologicalSpace X] [T2Space X] [LocallyCompactSpace X] {n : ℕ} {t : Set X} {s : Fin n → Set X},
(∀ (i : Fin n), IsOpen (s i)) →
IsCompact t →
t ⊆ ⋃ i, s i →
∃ f,
(∀ (i : Fin n), tsupport ⇑(f i) ⊆ s i) ∧
Set.EqOn (∑ i, ⇑(f i)) 1 t ∧
(∀ (i : ... | A variation of **Urysohn's lemma**.
In a locally compact T2 space `X`, for a compact set `t` and a finite family of open sets `{s i}_i`
such that `t ⊆ ⋃ i, s i`, there is a family of compactly supported continuous functions `{f i}_i`
supported in `s i`, `∑ i, f i x = 1` on `t` and `0 ≤ f i x ≤ 1`. | true |
AlgebraicGeometry.IsSchemeTheoreticallyDominant.rec | Mathlib.AlgebraicGeometry.Morphisms.SchemeTheoreticallyDominant | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsSchemeTheoreticallyDominant f → Sort u} →
((ker_eq_bot : AlgebraicGeometry.Scheme.Hom.ker f = ⊥) → motive ⋯) →
(t : AlgebraicGeometry.IsSchemeTheoreticallyDominant f) → motive t | null | false |
OmegaCompletePartialOrder.ContinuousHom.mk | Mathlib.Order.OmegaCompletePartialOrder | {α : Type u_2} →
{β : Type u_3} →
[inst : OmegaCompletePartialOrder α] →
[inst_1 : OmegaCompletePartialOrder β] →
(toOrderHom : α →o β) →
(∀ (c : OmegaCompletePartialOrder.Chain α),
toOrderHom.toFun (OmegaCompletePartialOrder.ωSup c) = OmegaCompletePartialOrder.ωSup (c.map to... | null | true |
Set.add_mem_Ico_iff_right | Mathlib.Algebra.Order.Interval.Set.Group | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] {a b c d : α},
a + b ∈ Set.Ico c d ↔ b ∈ Set.Ico (c - a) (d - a) | null | true |
Matroid.eRk_union_ground | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X : Set α), M.eRk (X ∪ M.E) = M.eRank | null | true |
Std.Tactic.BVDecide.BVExpr.decEq._proof_160 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (n : ℕ)
(lhs : Std.Tactic.BVDecide.BVExpr w) (rhs : Std.Tactic.BVDecide.BVExpr n),
¬llhs.arithShiftRight lrhs = lhs.shiftRight rhs | null | false |
Pi.Lex.instCompleteLinearOrderLexForall._proof_15 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedLT ι] (a : Lex ((i : ι) → α i)), ⊤ \ a = ￢a | null | false |
Matrix.of.eq_1 | Mathlib.Data.Matrix.Reflection | ∀ {m : Type u_2} {n : Type u_3} {α : Type v}, Matrix.of = Equiv.refl (m → n → α) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_maxKey!_eq_maxKey._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
CauSeq.Completion.Cauchy.divisionRing._proof_9 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x : ℚ≥0) (x_1 : CauSeq.Completion.Cauchy abv),
x • x_1 = ↑x * x_1 | null | false |
hasProd_one_add_of_hasSum_prod | Mathlib.Topology.Algebra.InfiniteSum.Ring | ∀ {ι : Type u_1} {α : Type u_3} [inst : CommSemiring α] [inst_1 : TopologicalSpace α] {f : ι → α} {a : α},
HasSum (fun x => ∏ i ∈ x, f i) a → HasProd (fun x => 1 + f x) a | null | true |
GroupExtension.Section.mul_mul_mul_inv_mem_range_inl | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ : S.Section) (g₁ g₂ : G), σ g₁ * σ g₂ * (σ (g₁ * g₂))⁻¹ ∈ S.inl.range | null | true |
MeasureTheory.instSigmaFiniteQuotientOrbitRelOfHasFundamentalDomainOfQuotientMeasureEqMeasurePreimageVolume | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasureTheory.MeasureSpace α]
[Countable G] [MeasureTheory.SMulInvariantMeasure G α MeasureTheory.volume] [MeasurableConstSMul G α]
[MeasureTheory.SigmaFinite MeasureTheory.volume] [MeasureTheory.HasFundamentalDomain G α MeasureTheo... | If a measure `μ` on a quotient satisfies `QuotientMeasureEqMeasurePreimage` with respect to a
sigma-finite measure, then it is itself `SigmaFinite`. | true |
_private.Mathlib.CategoryTheory.Abelian.Projective.Dimension.0.CategoryTheory.ShortComplex.ShortExact.projectiveDimension_X₁_succ_le_sup._simp_1_2 | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] (X : C) (n : ℕ),
(CategoryTheory.projectiveDimension X ≤ ↑n) = CategoryTheory.HasProjectiveDimensionLE X n | null | false |
Lean.Elab.Command.instMonadLiftTIOCommandElabM | Lean.Elab.Command | MonadLiftT IO Lean.Elab.Command.CommandElabM | null | true |
riemannZeta_conj | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ (s : ℂ), riemannZeta ((starRingEnd ℂ) s) = (starRingEnd ℂ) (riemannZeta s) | **Conjugation symmetry of the Riemann zeta function**: `ζ (conj s) = conj (ζ s)`.
Since `ζ` has real Dirichlet coefficients, `conj (ζ (conj z)) = ζ z` holds termwise for
`1 < re z`, and the identity principle propagates this to all `s ≠ 1`; the junk value `ζ 1` is
real, so the identity also holds at `s = 1`. | true |
AffineMap.differentiableAt | Mathlib.Analysis.Calculus.Deriv.AffineMap | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 →ᵃ[𝕜] E) {x : 𝕜}, DifferentiableAt 𝕜 (⇑f) x | null | true |
GetElem? | Init.GetElem | (coll : Type u) → (idx : Type v) → outParam (Type w) → outParam (coll → idx → Prop) → Type (max (max u v) w) | The classes `GetElem` and `GetElem?` implement lookup notation,
specifically `xs[i]`, `xs[i]?`, `xs[i]!`, and `xs[i]'p`.
Both classes are indexed by types `coll`, `idx`, and `elem` which are
the collection, the index, and the element types.
A single collection may support lookups with multiple index
types. The relatio... | true |
pow_lt_pow_right₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} {m n : ℕ} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 1 < a → m < n → a ^ m < a ^ n | null | true |
AddMonCat.coe_comp | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddMonCat} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | null | true |
NumberField.instCommRingRingOfIntegers._aux_20 | Mathlib.NumberTheory.NumberField.Basic | (K : Type u_1) → [inst : Field K] → ℕ → NumberField.RingOfIntegers K → NumberField.RingOfIntegers K | null | false |
Lean.Elab.InlayHint.textEdits._inherited_default | Lean.Elab.InfoTree.InlayHints | Array Lean.Elab.InlayHintTextEdit | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go.eq_def | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {newWidth : ℕ} {aig : Std.Sat.AIG α} {w : ℕ}
(input : aig.RefVec w) (start curr : ℕ) (hcurr : curr ≤ newWidth) (s : aig.RefVec curr),
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go input start curr hcurr s =
if h : curr < newWidth then
have fa... | null | true |
Polynomial.recOnHorner._proof_10 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u_2} [inst : Semiring R] {M : Polynomial R → Sort u_1}, M (0 * Polynomial.X) = M 0 | null | false |
sup_eq_of_max | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup β] [inst_1 : OrderBot β] {D : α → β} {s : Finset α}
[inst_2 : Nonempty α] {b : β}, b ∈ Set.range D → Function.invFun D b ∈ s → (∀ a ∈ s, D a ≤ b) → s.sup D = b | null | true |
LinearMap.IsRefl.liftQ₂._proof_4 | Mathlib.LinearAlgebra.Quotient.Bilinear | ∀ {R : Type u_2} {S : Type u_3} {M : Type u_1} {P : Type u_4} [inst : AddCommGroup M] [inst_1 : CommRing R]
[inst_2 : CommRing S] [inst_3 : Module R M] [inst_4 : AddCommGroup P] [inst_5 : Module S P] {I₁ I₂ : R →+* S}
(f : M →ₛₗ[I₁] M →ₛₗ[I₂] P) (N : Submodule R M), f.IsRefl → N ≤ f.ker → N ≤ f.flip.ker | null | false |
Cardinal.fact_isRegular_aleph0 | Mathlib.SetTheory.Cardinal.Regular | Fact Cardinal.aleph0.IsRegular | null | true |
Finset.finsuppAntidiagEquivSubtype._proof_2 | Mathlib.Algebra.Order.Antidiag.FinsuppEquiv | ∀ {ι : Type u_2} {μ : Type u_1} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] (s : Finset ι) (n : μ)
(f : { P // (P.sum fun x => id) = n }), ((↑f).extendDomain.sum fun x x_1 => x_1) = n | null | false |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxi.Iterator.instIteratorLoop.loop.wf.induct_unfolding | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] (γ : Type u) (Pl : α → γ → ForInStep γ → Prop)
(wf : Std.IteratorLoop.WellFounded (Std.Rxi.Iterator α) Id Pl) (LargeEnough : α → Prop)
(hl : ∀ (a b : α), Std.PRange.UpwardE... | null | true |
_private.Lean.Data.Array.0.Lean.Array.filterPairsM.match_1 | Lean.Data.Array | (motive : Bool × Bool → Sort u_1) → (x : Bool × Bool) → ((keepi keepj : Bool) → motive (keepi, keepj)) → motive x | null | false |
invertibleOfLeftInverse | Mathlib.Algebra.Group.Invertible.Defs | {α : Type u} → [inst : Monoid α] → [IsDedekindFiniteMonoid α] → (a b : α) → b * a = 1 → Invertible a | An element in a Dedekind-finite monoid is invertible if it has a left inverse. | true |
_private.Mathlib.RingTheory.SimpleModule.Basic.0.IsSemisimpleRing.exists_linearEquiv_ideal_of_isSimpleModule.match_1_3 | Mathlib.RingTheory.SimpleModule.Basic | ∀ (R : Type u_1) [inst : Ring R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)) → Prop) (x : ∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)),
(∀ (J : Ideal R) (left : J.IsMaximal) (e : M ≃ₗ[R] R ⧸ J), motive ⋯) → motive x | null | false |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.parseTagged.match_5 | Lean.Data.Json.FromToJson.Basic | (motive : Option (Array Lean.Name) → Sort u_1) →
(fieldNames? : Option (Array Lean.Name)) →
((fieldNames : Array Lean.Name) → motive (some fieldNames)) → (Unit → motive none) → motive fieldNames? | null | false |
Set.preimage_preimage | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {g : β → γ} {f : α → β} {s : Set γ},
f ⁻¹' g ⁻¹' s = (fun x => g (f x)) ⁻¹' s | null | true |
HomotopicalAlgebra.LeftHomotopyClass.whitehead | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
[HomotopicalAlgebra.IsCofibrant X] [HomotopicalAlgebra.IsCofibrant Y] [HomotopicalAlgebra.IsFibrant X]
[HomotopicalAlgebra.IsFibrant Y] (f : X ⟶ Y) [HomotopicalAlgebra.WeakEquivalence f],
∃ g,
Homo... | null | true |
nontrivial_iff | Mathlib.Basic.Nontrivial.Defs | ∀ {α : Type u_1}, Nontrivial α ↔ ∃ x y, x ≠ y | null | true |
AlgebraicGeometry.Scheme.Cover.instCategoryI₀Pullback₁._aux_1 | Mathlib.AlgebraicGeometry.Cover.Directed | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{X : AlgebraicGeometry.Scheme} →
[inst : P.IsStableUnderBaseChange] →
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) →
[CategoryTheory.Category.{u_1, u_2} 𝒰.I₀] →
{Y : AlgebraicGeometry.Sche... | null | false |
CategoryTheory.Functor.FullyFaithful.homEquiv.eq_1 | Mathlib.CategoryTheory.Sites.Point.Skyscraper | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C},
hF.homEquiv = { toFun := F.map, invFun := hF.preimage, left_inv := ⋯, right_inv := ⋯ } | null | true |
CategoryTheory.overEquivOfIsInitial | Mathlib.CategoryTheory.Comma.Over.StrictInitial | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Limits.HasStrictInitialObjects C] →
(X : C) → CategoryTheory.Limits.IsInitial X → (CategoryTheory.Over X ≌ CategoryTheory.Discrete PUnit.{w + 1}) | If `C` has strict initial objects and `X` is an initial object, the category
`Over X` is equivalent to a point. | true |
LieAlgebra.rootSpaceWeightSpaceProductAux._proof_6 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_2) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) (M : Type u_1) [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M],
SMulMemClass (LieSubmodule R (↥H) M) R M | null | false |
ProbabilityTheory.Kernel.lintegral_id | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} [MeasurableSingletonClass α] {f : α → ENNReal} (a : α),
∫⁻ (a : α), f a ∂ProbabilityTheory.Kernel.id a = f a | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionAssocNatIso_hom_app_app_app | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (X X_1 : C) (X_2 : D),
(((CategoryTheory.MonoidalCategory.MonoidalLeftAction.... | null | true |
CategoryTheory.ObjectProperty.isoClosure_eq_self | Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderIsomorphisms], P.isoClosure = P | null | true |
Lean.Grind.CommRing.Expr.toPolyC.go.match_4.congr_eq_7 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (x : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lea... | null | true |
Lean.Lsp.ApplyWorkspaceEditParams.mk.sizeOf_spec | Lean.Data.Lsp.Basic | ∀ (label? : Option String) (edit : Lean.Lsp.WorkspaceEdit),
sizeOf { label? := label?, edit := edit } = 1 + sizeOf label? + sizeOf edit | null | true |
sInf_mem_lowerBounds | Mathlib.Order.CompleteLattice.Defs | ∀ {α : Type u_1} [inst : CompleteSemilatticeInf α] {s : Set α}, sInf s ∈ lowerBounds s | null | true |
PartialFun.instCoeSortType | Mathlib.CategoryTheory.Category.PartialFun | CoeSort PartialFun (Type u_1) | null | true |
MvPolynomial.eval₂_comp_left | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] {S₂ : Type u_2}
[inst_2 : CommSemiring S₂] (k : S₁ →+* S₂) (f : R →+* S₁) (g : σ → S₁) (p : MvPolynomial σ R),
k (MvPolynomial.eval₂ f g p) = MvPolynomial.eval₂ (k.comp f) (⇑k ∘ g) p | null | true |
_private.Mathlib.Algebra.Lie.Basis.Prod.0.LieAlgebra.Basis.prodCartanEquiv._proof_15 | Mathlib.Algebra.Lie.Basis.Prod | ∀ {ι₁ : Type u_4} {ι₂ : Type u_5} {L₁ : Type u_1} {L₂ : Type u_2} [inst : Finite ι₁] [inst_1 : Finite ι₂] (eι : ι₁ ≃ ι₂)
[inst_2 : LieRing L₁] [inst_3 : LieRing L₂] {R : Type u_3} [inst_4 : CommRing R] [inst_5 : LieAlgebra R L₁]
{H₁ : LieSubalgebra R L₁} (b₁ : LieAlgebra.Basis ι₁ H₁) [inst_6 : LieAlgebra R L₂] {H₂ ... | null | false |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.finitenessRelation | Init.Data.String.Pattern.Basic | {ρ : Type} →
(pat : ρ) →
(s : String.Slice) →
[inst : String.Slice.Pattern.ForwardPattern pat] →
[String.Slice.Pattern.StrictForwardPattern pat] →
Std.Iterators.FinitenessRelation (String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s) Id | null | true |
Subtype.orderBot._proof_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u_1} {p : α → Prop} [inst : LE α] [inst_1 : OrderBot α] (x : { x // p x }), ⊥ ≤ ↑x | null | false |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiNat.dist_triangle_nonarch._simp_1_4 | Mathlib.Topology.MetricSpace.PiNat | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 0 < a → ∀ (n : ℕ), (0 < a ^ n) = True | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.EMatchTheoremIds | Lean.Meta.Tactic.Grind.EMatchAction | Type | null | true |
Std.DTreeMap.Internal.Impl.Equiv.getKey_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} (hk : k ∈ t₁), t₁.getKey k hk = t₂.getKey k ⋯ | null | true |
IsDiscreteValuationRing.toWithBotNat_eq_bot_iff | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] (x : R),
IsDiscreteValuationRing.toWithBotNat x = ⊥ ↔ x = 0 | null | true |
_private.Mathlib.Analysis.Normed.Affine.AddTorsorBases.0.AffineBasis.centroid_mem_interior_convexHull._simp_1_5 | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {α : Sort u_1}, (∀ (a : α), True) = True | null | false |
Std.OrientedCmp.of_gt_iff_lt | Init.Data.Order.PackageFactories | ∀ {α : Type u} {cmp : α → α → Ordering},
(∀ (a b : α), cmp a b = Ordering.gt ↔ cmp b a = Ordering.lt) → Std.OrientedCmp cmp | null | true |
Subsemiring._sizeOf_inst | Mathlib.Algebra.Ring.Subsemiring.Defs | (R : Type u) → {inst : NonAssocSemiring R} → [SizeOf R] → SizeOf (Subsemiring R) | null | false |
Lean.Meta.Grind.CheckResult.none | Lean.Meta.Tactic.Grind.CheckResult | Lean.Meta.Grind.CheckResult | No progress | true |
ContDiffMapSupportedInClass.map_zero_on_compl | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {B : Type u_5} {E : outParam (Type u_6)} {F : outParam (Type u_7)} {inst : NormedAddCommGroup E}
{inst_1 : NormedAddCommGroup F} {inst_2 : NormedSpace ℝ E} {inst_3 : NormedSpace ℝ F} {n : outParam ℕ∞}
{K : outParam (TopologicalSpace.Compacts E)} {inst_4 : FunLike B E F} [self : ContDiffMapSupportedInClass B E F n... | null | true |
Unitization.instModule._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {S : Type u_3} {R : Type u_1} {A : Type u_2} [inst : Semiring S] [inst_1 : AddCommMonoid R] [inst_2 : AddCommMonoid A]
[inst_3 : Module S R] [inst_4 : Module S A] (r s : S) (x : Unitization R A), (r + s) • x = r • x + s • x | null | false |
_private.Mathlib.Algebra.BigOperators.Module.0.Finset.sum_range_by_parts'._abel_1_1 | Mathlib.Algebra.BigOperators.Module | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : ℕ → R) (g : ℕ → M)
(n : ℕ),
(∑ i ∈ Finset.range n, f i) • g n + f n • g n -
∑ x ∈ Finset.range n,
((∑ i ∈ Finset.range x, f i) • g (x + 1) + f x • g (x + 1) -
((∑ i ∈ Finset.range x, f ... | null | false |
HomologicalComplex.truncLE'XIso | Mathlib.Algebra.Homology.Embedding.TruncLE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embeddi... | The isomorphism `(K.truncLE' e).X i ≅ K.X i'` when `e.f i = i'`
and `e.BoundaryLE i` does not hold. | true |
AffineSubspace.SSameSide.trans | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y z : P}, s.SSameSide x y → s.SSameSide y z → s.SSameSide x z | null | true |
CategoryTheory.Functor.ReflectsEffectiveEpiFamilies.rec | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.ReflectsEffectiveEpiFamilies → Sort u_3} →
((reflects :
∀ {α : Type u} {B : C} (X... | null | false |
Set.image_inv_Iio | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a : α),
Inv.inv '' Set.Iio a = Set.Ioi a⁻¹ | null | true |
sin_pi_mul_ne_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {x : ℂ}, x ∈ Complex.integerComplement → Complex.sin (↑Real.pi * x) ≠ 0 | `sin π z` is non vanishing on the complement of the integers in `ℂ`. | true |
Std.WP.ReaderT.wpInst._proof_1 | Std.WP.Monad.Instances | ∀ {m : Type u_2 → Type u_4} {EPred : Type u_3} {α ρ : Type u_2} {Pred : Type u_1} [inst : Std.WP.Assertion Pred]
[inst_1 : Std.WP.Assertion EPred] [inst_2 : Std.WP.WP (m α) α Pred EPred] (x : ReaderT ρ m α)
(post post' : α → ρ → Pred) (epost epost' : EPred),
Lean.Order.PartialOrder.rel epost epost' →
Lean.Ord... | null | false |
CommMonCat.forget₂_full | Mathlib.Algebra.Category.MonCat.Basic | (CategoryTheory.forget₂ CommMonCat MonCat).Full | Ensure that `forget₂ CommMonCat MonCat` automatically reflects isomorphisms. | true |
Preord.ofHom_hom | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (f : X ⟶ Y), Preord.ofHom (Preord.Hom.hom f) = f | null | true |
FinBoolAlg.Iso.mk._proof_4 | Mathlib.Order.Category.FinBoolAlg | ∀ {α β : FinBoolAlg} (e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg) (a b : ↑α.1), e (a ⊓ b) = e a ⊓ e b | null | false |
_private.Batteries.Data.Array.Pairwise.0.Array.pairwise_push._simp_1_2 | Batteries.Data.Array.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) | null | false |
MeasureTheory.VectorMeasure.restrict_add | Mathlib.MeasureTheory.VectorMeasure.Operations | ∀ {α : Type u_1} {mα : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
[inst_2 : ContinuousAdd M] (v w : MeasureTheory.VectorMeasure α M) (i : Set α),
(v + w).restrict i = v.restrict i + w.restrict i | null | true |
Equiv.finite_iff | Mathlib.Basic.Finite.Defs | ∀ {α : Sort u_1} {β : Sort u_2} (f : α ≃ β), Finite α ↔ Finite β | null | true |
ConditionallyCompleteLinearOrderBot.toDecidableEq._inherited_default | Mathlib.Order.ConditionallyCompleteLattice.Defs | {α : Type u_2} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
(∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) →
(∀ (a b : α), le a b → le b a → a = b) → DecidableLE α → DecidableEq α | null | false |
ModularForm.qExpansion_smul | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {k : ℤ} {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] {Γ : Subgroup (GL (Fin 2) ℝ)} {h : ℝ},
0 < h →
h ∈ Γ.strictPeriods →
∀ (a : ℂ) (f : F) [ModularFormClass F Γ k],
UpperHalfPlane.qExpansion h (a • ⇑f) = a • UpperHalfPlane.qExpansion h ⇑f | null | true |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.morphismRestrict_app._simp_1_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
TopCat.PrelocalPredicate.sheafify_inductionOn | Mathlib.Topology.Sheaves.LocalPredicate | ∀ {X : TopCat} {T : ↑X → Type u_2} (P : TopCat.PrelocalPredicate T) (op : {x : ↑X} → T x → T x),
(∀ {U : TopologicalSpace.Opens ↑X} {a : (x : ↥U) → T ↑x},
P.pred a → ∀ (p : ↥U), ∃ W i, ↑p ∈ W ∧ P.pred fun x => op (a (i x))) →
∀ {U : TopologicalSpace.Opens ↑X} {a : (x : ↥U) → T ↑x}, P.sheafify.pred a → P.she... | For a unary operation (e.g. `x ↦ -x`) defined at each stalk, if a prelocal predicate is closed
under the operation on each open set (possibly by refinement), then the sheafified predicate is
also closed under the operation. See `sheafify_inductionOn'` for the version without refinement. | true |
Submonoid.instInfSet._proof_1 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] (s : Set (Submonoid M)) {a : M}, a ∈ ⋂ t ∈ s, ↑t → ∀ i ∈ s, a ∈ i | null | false |
instLawfulIdentityInt32HAddOfNat | Init.Data.SInt.Lemmas | Std.LawfulIdentity (fun x1 x2 => x1 + x2) 0 | null | true |
ArchimedeanClass.instLinearOrderedAddCommGroupWithTop._proof_4 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : Field R] [inst_2 : IsOrderedRing R] (n : ℕ) (x : ArchimedeanClass R),
Int.negSucc n • x = -(↑n.succ • x) | null | false |
Polynomial.Chebyshev.S | Mathlib.RingTheory.Polynomial.Chebyshev | (R : Type u_1) → [inst : CommRing R] → ℤ → Polynomial R | `S n` is the `n`th rescaled Chebyshev polynomial of the second kind (also known as a
Vieta–Fibonacci polynomial), given by $S_n(2x) = U_n(x)$. See
`Polynomial.Chebyshev.S_comp_two_mul_X`. | true |
Std.Do.Spec.forIn'_roo | Std.Do.Triple.SpecLemmas | ∀ {α β : Type u} {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps]
[inst_2 : LT α] [inst_3 : DecidableLT α] [inst_4 : Std.PRange.UpwardEnumerable α] [inst_5 : Std.Rxo.IsAlwaysFinite α]
[inst_6 : Std.PRange.LawfulUpwardEnumerable α] [inst_7 : Std.PRange.LawfulUpwardEnumera... | null | true |
Subsemigroup.mem_closure | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] {s : Set M} {x : M}, x ∈ Subsemigroup.closure s ↔ ∀ (S : Subsemigroup M), s ⊆ ↑S → x ∈ S | null | true |
Lake.BuildTrace.caption | Lake.Build.Trace | Lake.BuildTrace → String | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
CategoryTheory.Limits.PreservesPullback.iso_hom | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullb... | null | true |
_private.Mathlib.Data.List.Chain.0.List.exists_isChain_ne_nil_of_relationReflTransGen._proof_1_3 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {a : α} (l : List α), ¬(a :: l).length - 1 = 0 → (a :: l).length - 2 < l.length | null | false |
CategoryTheory.Equivalence.cancel_unit_left._simp_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D) {X Y : C} (f f' : e.inverse.obj (e.functor.obj Y) ⟶ X),
(CategoryTheory.CategoryStruct.comp (e.unit.app Y) f = CategoryTheory.CategoryStruct.comp (e.unit.app Y) f') =
(f = f') | null | false |
cauchySeq_range_of_norm_bounded | Mathlib.Analysis.Normed.Group.InfiniteSum | ∀ {E : Type u_3} [inst : SeminormedAddCommGroup E] {f : ℕ → E} {g : ℕ → ℝ},
(CauchySeq fun n => ∑ i ∈ Finset.range n, g i) →
(∀ (i : ℕ), ‖f i‖ ≤ g i) → CauchySeq fun n => ∑ i ∈ Finset.range n, f i | A version of the **direct comparison test** for conditionally convergent series.
See `cauchySeq_finset_of_norm_bounded` for the same statement about absolutely convergent ones. | true |
lp.norm_eq_card_dsupport | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_3} {E : α → Type u_4} [inst : (i : α) → NormedAddCommGroup (E i)] (f : ↥(lp E 0)), ‖f‖ = ↑⋯.toFinset.card | null | true |
CategoryTheory.Functor.Elements.isColimitCoconeπOpCompShrinkYonedaObj._proof_1 | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
(F : CategoryTheory.Functor C (Type u_1)) (X : C)
(x :
(((CategoryTheory.Functor.Elements.π F).op.comp
(CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.obj X)).coconeTypesEquiv.symm
... | null | false |
ContinuousAlgEquiv.trans._proof_1 | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_4} {A : Type u_1} {B : Type u_3} {C : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Semiring C]
[inst_6 : TopologicalSpace C] [inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : Algebra R C] (e₁ :... | null | false |
Lean.Elab.Tactic.Try.TrySuggestionEntry._sizeOf_1 | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.TrySuggestionEntry → ℕ | null | false |
Lean.Grind.Linarith.instBEqPoly.beq._sparseCasesOn_1.else_eq | Init.Grind.Ordered.Linarith | ∀ {motive : Lean.Grind.Linarith.Poly → Sort u} (t : Lean.Grind.Linarith.Poly)
(nil : motive Lean.Grind.Linarith.Poly.nil) («else» : Nat.hasNotBit 1 t.ctorIdx → motive t)
(h : Nat.hasNotBit 1 t.ctorIdx), Lean.Grind.Linarith.instBEqPoly.beq._sparseCasesOn_1 t nil «else» = «else» h | null | false |
CategoryTheory.Lax.LaxTrans.Hom.noConfusionType | Mathlib.CategoryTheory.Bicategory.Modification.Lax | Sort u →
{B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{η θ : F ⟶ G} →
CategoryTheory.Lax.LaxTrans.Hom η θ →
{B' : Type u₁} →
... | null | false |
StarRingEquiv.noConfusion | Mathlib.Algebra.Star.StarRingHom | {P : Sort u} →
{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} →
{t : A ≃⋆+* B} →
{A' : Type u_1} →
... | null | false |
SmoothBumpCovering.IsSubordinate.toSmoothPartitionOfUnity | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH}
[inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M]
[inst_4 : ChartedSpace H M] [inst_5 : FiniteDimensional ℝ E] {s : Set M} [inst_6 : T2Space M]
[inst_7 : IsMani... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.