name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Int.tdiv_nonpos_of_nonneg_of_nonpos | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → b ≤ 0 → a.tdiv b ≤ 0 | null | true |
ContinuousNeg.rec | Mathlib.Topology.Algebra.Group.Defs | {G : Type u} →
[inst : TopologicalSpace G] →
[inst_1 : Neg G] →
{motive : ContinuousNeg G → Sort u_1} →
((continuous_neg : Continuous fun a => -a) → motive ⋯) → (t : ContinuousNeg G) → motive t | null | false |
AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._proof_19 | Mathlib.AlgebraicGeometry.Sites.ElladicCohomology | ∀ (X : AlgebraicGeometry.Scheme) (ℓ : ℕ) [inst : Fact (Nat.Prime ℓ)] (n : ℕ),
autoParam (∀ (a : X.EllAdicCohomology ℓ n), 0 • a = 0) SubNegMonoid.zsmul_zero'._autoParam | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeInductiveDecl.mk.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{decl : Lean.Declaration} →
{indFvars : Array Lean.Expr} →
{numParams : ℤ} →
{rs : Array Lean.Elab.Command.PreElabHeaderResult} →
{decl' : Lean.Declaration} →
{indFvars' : Array Lean.Expr} →
{numParams' : ℤ} →
{rs' : Array Lean.Elab.... | null | false |
AlgebraicGeometry.Scheme.pretopology.congr_simp | Mathlib.AlgebraicGeometry.Sites.Pretopology | ∀ (P P_1 : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) (e_P : P = P_1) [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative], AlgebraicGeometry.Scheme.pretopology P = AlgebraicGeometry.Scheme.pretopology P_1 | null | true |
CFC.rpow_mul_rpow_neg | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] {a : A} (x : ℝ),
autoParam (IsStrictlyPositive a) CFC.rpow... | null | true |
CategoryTheory.kleisliCatEquivKleisli._proof_7 | Mathlib.CategoryTheory.Monad.Types | ∀ (m : Type u_1 → Type u_1) [inst : Monad m] [inst_1 : LawfulMonad m] (X : CategoryTheory.KleisliCat m),
CategoryTheory.CategoryStruct.comp
({ obj := fun X => { of := X }, map := fun {X Y} f => { of := TypeCat.ofHom f }, map_id := ⋯, map_comp := ⋯ }.map
((CategoryTheory.NatIso.ofComponents (fun X => Cat... | null | false |
HasProd.congr_cofinite₀ | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {K : Type u_4} [inst : CommGroupWithZero K] [inst_1 : TopologicalSpace K] {f g : α → K}
[SeparatelyContinuousMul K] {c : K},
HasProd f c →
∀ {s : Finset α}, (∀ a ∈ s, f a ≠ 0) → (∀ a ∉ s, f a = g a) → HasProd g (c * ((∏ i ∈ s, g i) / ∏ i ∈ s, f i)) | null | true |
_private.Mathlib.Data.Set.Subsingleton.0.Set.nontrivial_iff_pair_subset.match_1_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u_1} {s : Set α} (motive : (∃ x y, x ≠ y ∧ {x, y} ⊆ s) → Prop) (H : ∃ x y, x ≠ y ∧ {x, y} ⊆ s),
(∀ (w w_1 : α) (hxy : w ≠ w_1) (h : {w, w_1} ⊆ s), motive ⋯) → motive H | null | false |
_private.Mathlib.Topology.Homotopy.LocallyContractible.0.instStronglyLocallyContractibleSpaceProd.match_9 | Mathlib.Topology.Homotopy.LocallyContractible | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (x : X) (y : Y) (Ux : Set X)
(Uy : Set Y)
(motive :
(match (x, y) with
| (x, y) =>
match (Ux, Uy) with
| (Ux, Uy) => (Ux ∈ nhds x ∧ ContractibleSpace ↑Ux) ∧ Uy ∈ nhds y ∧ ContractibleSpace ↑Uy) →
... | null | false |
Finite.Set.finite_range | Mathlib.Data.Set.Finite.Range | ∀ {α : Type u} {ι : Sort w} (f : ι → α) [Finite ι], Finite ↑(Set.range f) | null | true |
Inclusion.IExpr.mk.sizeOf_spec | Mathlib.Tactic.Inclusion.Core.Types | ∀ (iType : Inclusion.IType) (expr : Lean.Expr), sizeOf { iType := iType, expr := expr } = 1 + sizeOf iType + sizeOf expr | null | true |
Submodule.smithNormalFormOfLE._proof_8 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {ι : Type u_3} {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsDomain R] [inst_4 : IsPrincipalIdealRing R] [inst_5 : Finite ι] (b : Module.Basis ι R M)
(N O : Submodule R M) (N_le_O : N ≤ O),
∃ o,
∃ (hno : Classical.choose ⋯ ≤ o),
∃ bO bN a... | null | false |
Ordinal.card_iSup_le_lift | Mathlib.SetTheory.Cardinal.Ordinal | ∀ {ι : Type u} {c : Cardinal.{v}} {f : ι → Ordinal.{v}},
Cardinal.lift.{v, u} (Cardinal.mk ι) ≤ Cardinal.lift.{u, v} c → (∀ (i : ι), (f i).card ≤ c) → (⨆ i, f i).card ≤ c | null | true |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.isLimitFiniteSubproductsCone | Mathlib.CategoryTheory.Limits.Constructions.Filtered | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{α : Type w} →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
(f : α → C) →
[CategoryTheory.Limits.HasLimitsOfShape (Finset (CategoryTheory.Discrete α))ᵒᵖ C] →
[inst_3 : CategoryTheory.Limits.HasProduct f] →
... | The cone `finiteSubproductsCone` is a limit cone. | true |
BoxIntegral.unitPartition.mem_prepartition_iff | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} {n : ℕ} [inst : NeZero n] [inst_1 : Fintype ι] {B I : BoxIntegral.Box ι},
I ∈ BoxIntegral.unitPartition.prepartition n B ↔
∃ ν ∈ BoxIntegral.unitPartition.admissibleIndex n B, BoxIntegral.unitPartition.box n ν = I | null | true |
inner_conj_symm | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x y : E), (starRingEnd 𝕜) (inner 𝕜 y x) = inner 𝕜 x y | null | true |
Submonoid.isLocalizationMap_of_group | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G] {S : Submonoid M} {f : M → G},
Function.Injective f → (∀ (g : G), ∃ x, ∃ y ∈ S, g = f x / f y) → S.IsLocalizationMap f | null | true |
Multiset.map_univ_coe | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] (m : Multiset α), Multiset.map (fun x => x.fst) Finset.univ.val = m | null | true |
Quotient.hrecOn | Init.Core | {α : Sort u} →
{s : Setoid α} →
{motive : Quotient s → Sort v} →
(q : Quotient s) → (f : (a : α) → motive ⟦a⟧) → (∀ (a b : α), a ≈ b → f a ≍ f b) → motive q | A dependent recursion principle for `Quotient` that uses [heterogeneous
equality](https://lean-lang.org/doc/reference/4.35.0/find/?domain=Verso.Genre.Manual.section&name=HEq), analogous to a [recursor](https://lean-lang.org/doc/reference/4.35.0/find/?domain=Verso.Genre.Manual.section&name=recursors) for
a structure.
`... | true |
Std.Http.Protocol.H1.Machine.failed | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Machine dir → Bool | Returns `true` if the reader is in a failed state.
| true |
Mathlib.Tactic.BicategoryLike.Mor₁.tgt._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Obj | null | false |
SSet.Truncated.HomotopyCategory.BinaryProduct.functorCompInverseIso_hom_app | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ {X Y : SSet.Truncated 2}
(x : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge.tensor._proof_1 }))
(y : Y.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge.tensor._proof_1 })),
(SSet.Truncated.HomotopyCategory.BinaryProduct.functorCompInverseIso X Y).hom.app
... | null | true |
Lean.Compiler.LCNF.MonadCodeBind.rec | Lean.Compiler.LCNF.Bind | {m : Type → Type} →
{motive : Lean.Compiler.LCNF.MonadCodeBind m → Sort u} →
((codeBind :
{pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu →
(Lean.FVarId → m (Lean.Compiler.LCNF.Code pu)) → m (Lean.Compiler.LCNF.Code pu)) →
motive { codeBind := codeBind }) ... | null | false |
Nat.nth_apply_eq_orderIsoOfNat | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} (hf : (Set.ofPred p).Infinite) (n : ℕ), Nat.nth p n = ↑((Nat.Subtype.orderIsoOfNat (Set.ofPred p)) n) | When `s` is an infinite set, `nth` agrees with `Nat.Subtype.orderIsoOfNat`. | true |
_private.Mathlib.Data.Set.Function.0.Set.bijOn_singleton._simp_1_2 | Mathlib.Data.Set.Function | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Lean.Parser.Term.configItem.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
Array.mkSlice_roi_eq_mkSlice_roo | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {lo : ℕ},
Std.Roi.Sliceable.mkSlice xs (lo<...*) = Std.Roo.Sliceable.mkSlice xs (lo<...xs.size) | null | true |
ProjectiveSpectrum | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] → [inst_2 : AddSubmonoidClass σ A] → (𝒜 : ℕ → σ) → [GradedRing 𝒜] → Type u_1 | The projective spectrum of a graded commutative ring is the subtype of all homogeneous ideals
that are prime and do not contain the irrelevant ideal. | true |
instRingWithIdealFilter._proof_46 | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] (x : IdealFilter A),
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | null | false |
mdifferentiableAt_add_left | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : Add G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] [ContMDiffAdd I 1 G] {... | null | true |
Ordnode.merge_nil_right | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (t : Ordnode α), Ordnode.nil.merge t = t | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_insert_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Lean.Sym.ite_true | Init.Sym.Lemmas | ∀ {α : Sort u} (c : Prop) {inst : Decidable c} (a b : α) {ht : c}, (if c then a else b) = a | null | true |
AlgHom.FinitePresentation.of_finiteType | Mathlib.RingTheory.FinitePresentation | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [IsNoetherianRing A] {f : A →ₐ[R] B},
f.FiniteType ↔ f.FinitePresentation | null | true |
MeasureTheory.measure_preimage_add_right | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddRightInvariant] (g : G) (A : Set G), μ ((fun h => h + g) ⁻¹' A) = μ A | null | true |
LinearMap.IsPerfPair.restrictScalars_of_field | Mathlib.LinearAlgebra.PerfectPairing.Restrict | ∀ {K : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : AddCommGroup M] [inst_4 : AddCommGroup N] [inst_5 : Module L M] [inst_6 : Module L N] [inst_7 : Module K M]
[inst_8 : Module K N] [inst_9 : IsScalarTower K L M] (p : M →ₗ[L] N →ₗ[L] L) ... | Simultaneously restrict both the domains and scalars of a perfect pairing with coefficients in a
field. | true |
Std.Internal.Order.instPartialOrderProp._proof_2 | Std.Internal.Order.PropLattice | ∀ {x y : Prop}, (x → y) → (y → x) → x = y | null | false |
Std.ExtTreeMap.maxKey.congr_simp | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t t_1 : Std.ExtTreeMap α β cmp)
(e_t : t = t_1) (h : t ≠ ∅), t.maxKey h = t_1.maxKey ⋯ | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.withNewLocalInstancesImpAux | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → Array Lean.Expr → ℕ → n α → n α | null | true |
Lean.Meta.Sym.ExprPtr.mk.inj | Lean.Meta.Sym.ExprPtr | ∀ {expr expr_1 : Lean.Expr}, { expr := expr } = { expr := expr_1 } → expr = expr_1 | null | true |
RestrictedProduct.instZSMul._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → SubNegMonoid (R i)] [∀ (i : ι), AddSubgroupClass (S i) (R i)]
(x : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (n : ℤ), ∀ᶠ (x_1 : ι) in 𝓕, n • x x_1 ∈ ↑(B... | null | false |
ComplexShape.down' | Mathlib.Algebra.Homology.ComplexShape | {α : Type u_2} → [inst : Add α] → [IsRightCancelAdd α] → α → ComplexShape α | The `ComplexShape` allowing differentials from `X (j+a)` to `X j`.
(For example when `a = 1`, a homology theory indexed by `ℕ` or `ℤ`)
| true |
CategoryTheory.Limits.pushoutCoconeOfLeftIso_ι_app_none | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
[inst_1 : CategoryTheory.IsIso f], (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).ι.app none = g | null | true |
LinearMap.lTensor_ker_subtype_tensorKerEquiv_symm | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N]... | null | true |
lt_compl_self._simp_2 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a : α} [Nontrivial α], (a < aᶜ) = (a = ⊥) | null | false |
MulSemiringActionHomClass.toMulSemiringActionHom._proof_6 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_4} [inst : Monoid M] {N : Type u_5} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_2} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_1} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S] {F : Type u_3}
[inst_6 : FunLike F R S] [inst_7 : MulSemiringActionSemiHomClass F (⇑φ) R S] (... | null | false |
String.Pos.Raw.byteIdx_unoffsetBy | Init.Data.String.PosRaw | ∀ {p offset : String.Pos.Raw}, (p.unoffsetBy offset).byteIdx = p.byteIdx - offset.byteIdx | null | true |
Std.Sat.AIG.RefVec.fold.go_decl_eq._unary | Std.Sat.AIG.RefVecOperator.Fold | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ}
(f : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f]
(_x : (aig : Std.Sat.AIG α) ×' (_ : aig.Ref) ×' (_ : ℕ) ×' aig.RefVec len) (idx : ℕ) (h1 : idx < _x.1.decls... | null | false |
one_div_lt_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < 0 → b < 0 → (1 / a < b ↔ 1 / b < a) | null | true |
Finset.ite_prod_one | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] (p : Prop) [inst_1 : Decidable p] (s : Finset ι) (f : ι → M),
(if p then ∏ x ∈ s, f x else 1) = ∏ x ∈ s, if p then f x else 1 | null | true |
DifferentiableWithinAt.insert' | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : 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] {f : E → F} {x : E} {s : Set E} [T1Space E] {y : E},
DifferentiableWithi... | **Alias** of the reverse direction of `differentiableWithinAt_insert`. | true |
SemidirectProduct.lift | Mathlib.GroupTheory.SemidirectProduct | {N : Type u_1} →
{G : Type u_2} →
{H : Type u_3} →
[inst : Group N] →
[inst_1 : Group G] →
[inst_2 : Group H] →
{φ : G →* MulAut N} →
(fn : N →* H) →
(fg : G →* H) →
(∀ (g : G),
fn.comp (MulEquiv.toMonoidHom ... | Define a group hom `N ⋊[φ] G →* H`, by defining maps `N →* H` and `G →* H` | true |
List.getLast_replicate_succ | Mathlib.Data.List.Basic | ∀ {α : Type u} (m : ℕ) (a : α), (List.replicate (m + 1) a).getLast ⋯ = a | null | true |
FiberBundleCore.localTriv_symm_apply | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i : ι) (p : B × F),
↑(Z.localTriv i).symm p = ⟨p.1, Z.coordChange i (Z.indexAt p.1) p.1 p.2⟩ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_insert_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Finset.sum_range_tsub | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [inst_2 : Sub M] [OrderedSub M] [AddLeftMono M]
[AddLeftReflectLE M] [ExistsAddOfLE M] {f : ℕ → M},
Monotone f → ∀ (n : ℕ), ∑ i ∈ Finset.range n, (f (i + 1) - f i) = f n - f 0 | A telescoping sum along `{0, ..., n-1}` of an `ℕ`-valued function reduces to the difference of
the last and first terms when the function we are summing is monotone. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.isPath_iff_isSubwalk_imp_nil._proof_1_6 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (i j : ℕ),
min j i ≤ p.length → min j i < p.support.length | null | false |
Set.Finite.exists_finset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → ∃ s', ∀ (a : α), a ∈ s' ↔ a ∈ s | null | true |
CategoryTheory.isPreconnected_op | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.IsPreconnected J],
CategoryTheory.IsPreconnected Jᵒᵖ | If `J` is preconnected, then `Jᵒᵖ` is preconnected as well. | true |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Functor C D) [inst_3 : CategoryTheory.ComonObj A] {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (A.map f) Categ... | null | false |
Module.Presentation.cokernel_relation | Mathlib.Algebra.Module.Presentation.Cokernel | ∀ {A : Type u} [inst : Ring A] {M₁ : Type v₁} {M₂ : Type v₂} [inst_1 : AddCommGroup M₁] [inst_2 : Module A M₁]
[inst_3 : AddCommGroup M₂] [inst_4 : Module A M₂] (pres₂ : Module.Presentation A M₂) {f : M₁ →ₗ[A] M₂} {ι : Type w₁}
{g₁ : ι → M₁} (data : pres₂.CokernelData f g₁) (hg₁ : Submodule.span A (Set.range g₁) = ... | null | true |
SubAddAction.SMulMemClass.subtype._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_3} {M : Type u_1} [inst : AddMonoid R] [inst_1 : AddAction R M] {A : Type u_2} [inst_2 : SetLike A M]
[hA : VAddMemClass A R M] (S' : A) (x : R) (x_1 : ↥S'), ↑(x +ᵥ x_1) = ↑(x +ᵥ x_1) | null | false |
Real.smoothTransition.one_of_one_le | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ∀ {x : ℝ}, 1 ≤ x → x.smoothTransition = 1 | null | true |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.toPrenex.match_1.eq_2 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(t₁ t₂ : L.Term (α ⊕ Fin x)) (h_1 : (x : ℕ) → motive x FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(h_3 ... | null | true |
isStablyFiniteRing_iff | Mathlib.Data.Matrix.Mul | ∀ (R : Type u_7) [inst : MulOne R] [inst_1 : AddCommMonoid R],
IsStablyFiniteRing R ↔ ∀ (n : ℕ), IsDedekindFiniteMonoid (Matrix (Fin n) (Fin n) R) | null | true |
CompareReals.instCommRingQ._proof_7 | Mathlib.Topology.UniformSpace.CompareReals | ∀ (a : CompareReals.Q), a + 0 = a | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.let.parenthesizer_141 | Lean.Parser.Term | IO Unit | null | false |
TopCommRingCat.forgetToTopCatCommRing | Mathlib.Topology.Category.TopCommRingCat | (R : TopCommRingCat) → CommRing ↑((CategoryTheory.forget₂ TopCommRingCat TopCat).obj R) | null | true |
_private.Mathlib.Topology.Compactness.CompactSystem.0.IsCompactSystem.insert_univ._proof_1_2 | Mathlib.Topology.Compactness.CompactSystem | ∀ {α : Type u_1} {S : Set (Set α)} (s : ℕ → Set α),
(∀ (i : ℕ), s i ∈ insert Set.univ S) →
∀ (h₀ : ∃ n, s n ∈ S) (x : α),
(∀ (i : ℕ), x ∈ s i) ↔ ∀ (i : ℕ), x ∈ (fun i => if s i ∈ S then s i else s (Nat.find h₀)) i | null | false |
_private.Std.Time.Time.PlainTime.0.Std.Time.instDecidableEqPlainTime.decEq.match_1 | Std.Time.Time.PlainTime | (motive : Std.Time.PlainTime → Std.Time.PlainTime → Sort u_1) →
(x x_1 : Std.Time.PlainTime) →
((a : Std.Time.Hour.Ordinal) →
(a_1 : Std.Time.Minute.Ordinal) →
(a_2 : Std.Time.Second.Ordinal true) →
(a_3 : Std.Time.Nanosecond.Ordinal) →
(b : Std.Time.Hour.Ordinal) →
... | null | false |
instBialgebraCarrierUnopCommAlgCatOfMonObjOpposite._proof_10 | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u_1} [inst : CommRing R] (A : (CommAlgCat R)ᵒᵖ) [inst_1 : CategoryTheory.MonObj A],
(Algebra.TensorProduct.map (CommAlgCat.Hom.hom CategoryTheory.MonObj.one.unop) (AlgHom.id R ↑(Opposite.unop A))).comp
(CommAlgCat.Hom.hom CategoryTheory.MonObj.mul.unop) =
↑(Algebra.TensorProduct.lid R ↑(Opposite... | null | false |
_private.Lean.Meta.Tactic.Grind.CollectParams.0.Lean.Meta.Grind.collectParams.match_1 | Lean.Meta.Tactic.Grind.CollectParams | (motive : Bool × Array Lean.Meta.Grind.TParam × Array Lean.Meta.Grind.TParam → Sort u_1) →
(x : Bool × Array Lean.Meta.Grind.TParam × Array Lean.Meta.Grind.TParam) →
((fst : Bool) → (params anchors : Array Lean.Meta.Grind.TParam) → motive (fst, params, anchors)) → motive x | null | false |
AddAction.zmultiplesQuotientStabilizerEquiv._proof_4 | Mathlib.Data.ZMod.QuotientGroup | ∀ {α : Type u_2} {β : Type u_1} [inst : AddGroup α] (a : α) [inst_1 : AddAction α β] (b : β),
AddSubgroup.zmultiples ↑(Function.minimalPeriod (fun x => a +ᵥ x) b) ≤
AddSubgroup.comap ((zmultiplesHom ↥(AddSubgroup.zmultiples a)) ⟨a, ⋯⟩)
(AddAction.stabilizer (↥(AddSubgroup.zmultiples a)) b) | null | false |
UInt32.toNat_toBitVec | Init.Data.UInt.Lemmas | ∀ (x : UInt32), x.toBitVec.toNat = x.toNat | null | true |
Int32.toInt_toInt64 | Init.Data.SInt.Lemmas | ∀ (x : Int32), x.toInt64.toInt = x.toInt | null | true |
_private.Mathlib.Topology.Sheaves.EtaleSpace.0.TopCat.Presheaf.EtaleSpace.homeomorph._simp_10 | Mathlib.Topology.Sheaves.EtaleSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ},
Filter.Tendsto f a (Filter.comap g c) = Filter.Tendsto (g ∘ f) a c | null | false |
PointedCone.Face.toPointedCone_le_toPointedCone._simp_1 | Mathlib.Geometry.Convex.Cone.Face.Lattice | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {C : PointedCone R M} {F₁ F₂ : C.Face}, (↑F₁ ≤ ↑F₂) = (F₁ ≤ F₂) | null | false |
CategoryTheory.ObjectProperty.full_ιOfLE | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P P' : CategoryTheory.ObjectProperty C} (h : P ≤ P'),
(CategoryTheory.ObjectProperty.ιOfLE h).Full | null | true |
NonemptyFinLinOrd.dualEquiv._proof_3 | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ (X : NonemptyFinLinOrd),
CategoryTheory.CategoryStruct.comp
(NonemptyFinLinOrd.dual.map
((CategoryTheory.NatIso.ofComponents (fun X => NonemptyFinLinOrd.Iso.mk (OrderIso.dualDual ↑X.toLinOrd))
@NonemptyFinLinOrd.dualEquiv._proof_1).hom.app
X))
((CategoryTheory.NatIso.of... | null | false |
Std.HashMap.getElem!_filter' | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] [inst : Inhabited β]
{f : α → β → Bool} {k : α}, (Std.HashMap.filter f m)[k]! = (Option.filter (f k) m[k]?).get! | Simpler variant of `getElem!_filter` when `LawfulBEq` is available. | true |
Lean.Server.RequestCancellation.ctorIdx | Lean.Server.RequestCancellation | Lean.Server.RequestCancellation → ℕ | null | false |
_private.Mathlib.Basic.Rel.Cover.0.SetRel.IsCover.nonempty.match_1_1 | Mathlib.Basic.Rel.Cover | ∀ {X : Type u_1} {U : SetRel X X} {N : Set X} (_x : X) (motive : (∃ y ∈ N, (_x, y) ∈ U) → Prop)
(x : ∃ y ∈ N, (_x, y) ∈ U), (∀ (y : X) (hy : y ∈ N) (right : (_x, y) ∈ U), motive ⋯) → motive x | null | false |
IO.Error.instToString | Init.System.IOError | ToString IO.Error | null | true |
CategoryTheory.Bicategory.Adjunction.isAbsoluteLeftKan._proof_1 | Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {u : b ⟶ a}
(adj : CategoryTheory.Bicategory.Adjunction f u) {x : B} (h : a ⟶ x)
(s :
CategoryTheory.Bicategory.LeftExtension f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) h)),
CategoryTheory.Categor... | null | false |
DerivedCategory.singleFunctorsPostcompQIso | Mathlib.Algebra.Homology.DerivedCategory.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : HasDerivedCategory C] →
DerivedCategory.singleFunctors C ≅ (CochainComplex.singleFunctors C).postcomp DerivedCategory.Q | The isomorphism
`DerivedCategory.singleFunctors C ≅ (CochainComplex.singleFunctors C).postcomp Q`. | true |
MonoidWithZeroHom.snd.eq_1 | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ (G₀ : Type u_1) (H₀ : Type u_2) [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀],
MonoidWithZeroHom.snd G₀ H₀ = WithZero.lift' ((Units.coeHom H₀).comp (MonoidHom.snd G₀ˣ H₀ˣ)) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_zero._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ⊤ = none | null | false |
Std.DHashMap.Equiv.casesOn | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{x : BEq α} →
{x_1 : Hashable α} →
{m₁ m₂ : Std.DHashMap α β} →
{motive : m₁.Equiv m₂ → Sort u_1} →
(t : m₁.Equiv m₂) → ((inner : m₁.inner.Equiv m₂.inner) → motive ⋯) → motive t | null | false |
_private.Std.Do.WP.Sound.0.Std.Do.instWPSoundOptionTExceptPUnitPureOfLawfulMonad.match_11 | Std.Do.WP.Sound | ∀ {α : Type u_1} {P : α → Prop}
(motive :
{ a //
match a with
| some a => P a
| none => True } →
Prop)
(x :
{ a //
match a with
| some a => P a
| none => True }),
(∀ (r : Option α)
(property :
match r with
| some a => P a
| none... | null | false |
Units.instMul | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → Mul αˣ | Units of a monoid have an induced multiplication. | true |
CategoryTheory.MorphismProperty.instIsStableUnderBaseChangeTop | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], ⊤.IsStableUnderBaseChange | null | true |
AlgebraNorm.ctorIdx | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
{inst : SeminormedCommRing R} → {S : Type u_2} → {inst_1 : Ring S} → {inst_2 : Algebra R S} → AlgebraNorm R S → ℕ | null | false |
CategoryTheory.MorphismProperty.LeftFraction₃.mk.inj | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {W : CategoryTheory.MorphismProperty C} {X Y Y' : C}
{f f' f'' : X ⟶ Y'} {s : Y ⟶ Y'} {hs : W s} {Y'_1 : C} {f_1 f'_1 f''_1 : X ⟶ Y'_1} {s_1 : Y ⟶ Y'_1} {hs_1 : W s_1},
{ Y' := Y', f := f, f' := f', f'' := f'', s := s, hs := hs } =
{ Y' := Y'_1, f... | null | true |
Set.iUnion_subset_iff._simp_1 | Mathlib.Data.Set.Lattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t | null | false |
Subalgebra.copy._proof_4 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (s : Set A) (hs : s = ↑S), 0 ∈ (S.copy s hs).carrier | null | false |
FractionalIdeal.ringEquivOfRingEquiv.congr_simp | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_5} {S : Type u_6} (K : Type u_7) (L : Type u_8) [inst : CommRing R] [inst_1 : IsDomain R]
[inst_2 : CommRing S] [inst_3 : IsDomain S] [inst_4 : CommRing K] [inst_5 : CommRing L] [inst_6 : Algebra R K]
[inst_7 : Algebra S L] [inst_8 : IsFractionRing R K] [inst_9 : IsFractionRing S L] (f f_1 : R ≃+* S),... | null | true |
Lean.Kernel.Diagnostics.mk.noConfusion | Lean.Environment | {P : Sort u} →
{unfoldCounter : Lean.PHashMap Lean.Name ℕ} →
{enabled : Bool} →
{unfoldCounter' : Lean.PHashMap Lean.Name ℕ} →
{enabled' : Bool} →
{ unfoldCounter := unfoldCounter, enabled := enabled } =
{ unfoldCounter := unfoldCounter', enabled := enabled' } →
(... | null | false |
AlgebraicGeometry.bialgSpec | Mathlib.AlgebraicGeometry.Group.Affine | (R : CommRingCat) →
CategoryTheory.Functor (CommBialgCat ↑R)ᵒᵖ (CategoryTheory.Mon (CategoryTheory.Over (AlgebraicGeometry.Spec R))) | `Spec` as a functor from `R`-bialgebras to monoid schemes over `Spec R`. | true |
OrderDual.instNonAssocRing._proof_3 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : NonAssocRing R], autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.