name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Iterators.Types.ArrayIterator._sizeOf_1 | Std.Data.Iterators.Producers.Monadic.Array | {α : Type w} → [SizeOf α] → Std.Iterators.Types.ArrayIterator α → ℕ | null | false |
Finset.univ_finset_eq_singleton_empty_iff._simp_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_3}, (Set.univ = {∅}) = IsEmpty α | null | false |
BitVec.getElem_setWidth_eq_decide_getElem | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (m : ℕ) (x : BitVec n) (i : ℕ) (h : i < m), (BitVec.setWidth m x)[i] = decide (∃ (h : i < n), x[i] = true) | null | true |
IsScalarTower.restrictScalars | Mathlib.Algebra.Algebra.RestrictScalars | ∀ (R : Type u_1) (S : Type u_2) (M : Type u_3) [inst : Semiring S] [inst_1 : AddCommMonoid M] [inst_2 : CommSemiring R]
[inst_3 : Algebra R S] [inst_4 : Module S M], IsScalarTower R S M | `Module.restrictScalars` forms a scalar tower. | true |
CategoryTheory.DifferentialObject.Hom.recOn | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddMonoidWithOne S] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
{X Y : CategoryTheory.DifferentialObject S C} →
{motive : X.H... | null | false |
CategoryTheory.ShortComplex.cyclesMapIso_inv | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) [inst_2 : S₁.HasLeftHomology] [inst_3 : S₂.HasLeftHomology],
(CategoryTheory.ShortComplex.cyclesMapIso e).inv = CategoryTheory.ShortComplex.cyclesM... | null | true |
Finset.factorization_lcm | Mathlib.Algebra.GCDMonoid.FinsetLemmas | ∀ {ι : Type u_1} {f : ι → ℕ} {s : Finset ι},
(∀ k ∈ s, f k ≠ 0) → ∀ (p : ℕ), (s.lcm f).factorization p = s.sup fun a => (f a).factorization p | An analogue of `Nat.factorization_lcm` for `Finset.lcm`. | true |
CategoryTheory.Triangulated.TStructure.eTruncLTGEIsoGELT | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | The commutation natural isomorphism
`t.eTruncGE.obj a ⋙ t.eTruncLT.obj b ≅ t.eTruncLT.obj b ⋙ t.eTruncGE.obj a`
for all `a` and `b` in `EInt`. | true |
Std.DTreeMap.Internal.Impl.Const.alterₘ | Std.Data.DTreeMap.Internal.Model | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
[Std.OrientedOrd α] →
α →
(Option β → Option β) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) → t.Balanced → Std.DTreeMap.Internal.Impl α fun x => β | Model implementation of the `alter` function.
Internal implementation detail of the tree map
| true |
groupHomology.toCycles | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) → (i j : ℕ) → (groupHomology.inhomogeneousChains A).X i ⟶ groupHomology.cycles A j | This is the map from `i`-chains to `j`-cycles induced by the differential in the complex of
inhomogeneous chains. | true |
LSeries.eq_of_LSeries_eventually_eq | Mathlib.NumberTheory.LSeries.Injectivity | ∀ {f g : ℕ → ℂ},
LSeries.abscissaOfAbsConv f < ⊤ →
LSeries.abscissaOfAbsConv g < ⊤ →
((fun x => LSeries f ↑x) =ᶠ[Filter.atTop] fun x => LSeries g ↑x) → ∀ {n : ℕ}, n ≠ 0 → f n = g n | If the `LSeries` of `f` and of `g` converge somewhere and agree on large real arguments,
then `f n = g n` whenever `n ≠ 0`. | true |
Std.DHashMap.Raw.all | Std.Data.DHashMap.RawDef | {α : Type u} → {β : α → Type v} → Std.DHashMap.Raw α β → ((a : α) → β a → Bool) → Bool | Checks if all elements satisfy the predicate, short-circuiting if a predicate fails. | true |
_private.Std.Time.Time.Unit.Basic.0.Std.Time.Millisecond.Offset.ofHours._proof_1 | Std.Time.Time.Unit.Basic | 3600 / ↑3600000 = 1 / 1000 | null | false |
Fin.castPred_lt_castPred | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {i j : Fin (n + 1)} (h : i < j) (hj : j ≠ Fin.last n), i.castPred ⋯ < j.castPred hj | A version of the right-to-left implication of `castPred_lt_castPred_iff`
that deduces `i ≠ last n` from `i < j`. | true |
_private.Mathlib.Algebra.Order.BigOperators.Group.Finset.0.Multiset.finsetSum_eq_sup_iff_disjoint._simp_1_6 | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {b c : Prop} {α : Sort u_1}, (∀ (a : α), b ∧ c) = ((∀ (a : α), b) ∧ ∀ (a : α), c) | null | false |
add_comm | Mathlib.Algebra.Group.Semigroup | ∀ {G : Type u_1} [inst : AddCommMagma G] (a b : G), a + b = b + a | null | true |
Ordnode.eraseMax._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Ordnode α | null | false |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobiMatrix._proof_1_3 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (m k : ℕ) (i i_1 : Fin m),
(if i_1 < i then 0
else if h : ↑i_1 - ↑i < k then MvPolynomial.X (Sum.inr ⟨↑i_1 - ↑i, ⋯⟩) else if ↑i_1 - ↑i = k then 1 else 0) =
if i ≤ i_1 ∧ ↑i_1 ≤ ↑i + k then
if h : ↑i_1 - ↑i < k then MvPolynomial.X (Sum.inr ⟨↑i_1 - ↑i, h⟩) else if ↑i_1 ... | null | false |
cantorToTernary._proof_1 | Mathlib.Topology.Instances.CantorSet | NeZero (2 + 1) | null | false |
Lean.Meta.Grind.Arith.CollectDecVars.State.ctorIdx | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Meta.Grind.Arith.CollectDecVars.State → ℕ | null | false |
AddSubgroup.le_prod_iff | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] {H : AddSubgroup G} {K : AddSubgroup N}
{J : AddSubgroup (G × N)},
J ≤ H.prod K ↔ AddSubgroup.map (AddMonoidHom.fst G N) J ≤ H ∧ AddSubgroup.map (AddMonoidHom.snd G N) J ≤ K | null | true |
Int8.toInt64_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int8), (a ^^^ b).toInt64 = a.toInt64 ^^^ b.toInt64 | null | true |
Localization.awayEquivAdjoin._proof_1 | Mathlib.RingTheory.Localization.Away.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (r : R), IsUnit ((AdjoinRoot.of (Polynomial.C r * Polynomial.X - 1)) r) | null | false |
AddSubgroup.ofAddUnitsEquivType.eq_1 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubgroup (AddUnits M)),
S.ofAddUnitsEquivType =
{ toFun := fun x => ⟨S.addUnit_of_mem_ofAddUnits ⋯, ⋯⟩, invFun := fun x => ⟨↑↑x, ⋯⟩, left_inv := ⋯, right_inv := ⋯,
map_add' := ⋯ } | null | true |
IsMax.of_succ_le | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α}, Order.succ a ≤ a → IsMax a | **Alias** of the forward direction of `Order.succ_le_iff_isMax`. | true |
Finset.sum_Icc_of_even_eq_range | Mathlib.Algebra.BigOperators.Group.Finset.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] {f : ℤ → α},
Function.Even f → ∀ (N : ℕ), ∑ m ∈ Finset.Icc (-↑N) ↑N, f m = 2 • ∑ m ∈ Finset.range (N + 1), f ↑m - f 0 | null | true |
Valuation.isOpen_closedBall | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] {Γ₀ : Type u_3} [inst_2 : LinearOrderedCommGroupWithZero Γ₀]
[_t : TopologicalSpace R] [IsValuativeTopology R] {v : Valuation R Γ₀} [v.Compatible] {r : (↑v).ValueGroup₀},
r ≠ 0 → IsOpen {x | v.restrict x ≤ r} | For any valuation `v` compatible with the valuative relation on `R`, the closed `r`-ball
around zero `{x | v.restrict x ≤ r}` is open in the valuative topology. | true |
Nat.multichoose._unary._proof_1 | Mathlib.Data.Nat.Choose.Basic | WellFounded (invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 | null | false |
Lean.TagAttributeExtra.getDecls | Batteries.Lean.AttributeExtra | Lean.TagAttributeExtra → Lean.Environment → Array Lean.Name | Get the list of declarations tagged with the tag attribute `attr`. | true |
AbsoluteValue.trivial.eq_1 | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {R : Type u_4} [inst : Semiring R] [inst_1 : DecidablePred fun x => x = 0] [inst_2 : NoZeroDivisors R] {S : Type u_5}
[inst_3 : Semiring S] [inst_4 : PartialOrder S] [inst_5 : IsOrderedRing S] [inst_6 : Nontrivial S],
AbsoluteValue.trivial =
{ toFun := fun x => if x = 0 then 0 else 1, map_mul' := ⋯, nonneg' :... | null | true |
Lean.Lsp.ResolveSupport.ctorIdx | Lean.Data.Lsp.Basic | Lean.Lsp.ResolveSupport → ℕ | null | false |
Nat.Internal.Linear.Expr.brecOn.eq | Init.Data.Nat.Internal.Linear | ∀ {motive : Nat.Internal.Linear.Expr → Sort u} (t : Nat.Internal.Linear.Expr)
(F_1 : (t : Nat.Internal.Linear.Expr) → Nat.Internal.Linear.Expr.below t → motive t),
Nat.Internal.Linear.Expr.brecOn t F_1 = F_1 t (Nat.Internal.Linear.Expr.brecOn.go t F_1).2 | null | true |
Int.sub_neg_of_lt | Init.Data.Int.Order | ∀ {a b : ℤ}, a < b → a - b < 0 | null | true |
IsDedekindDomain.HeightOneSpectrum.adicCompletion.coe_valueGroupOrderIso_coe | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R)
(a : ↥(↑(IsDedekindDomain.HeightOneSpectrum.adicCompletion.valuation K v)).valueGroup),
(IsDedekindDomain.HeightOneSp... | **Alias** of `IsDedekindDomain.HeightOneSpectrum.adicCompletion.valueGroupOrderMonoidIso_coe`. | true |
Mathlib.Tactic.Ring.Common.ExBaseNat.evalPos._unsafe_rec | Mathlib.Tactic.Ring.Common | {a : Q(ℕ)} → Mathlib.Tactic.Ring.Common.ExBaseNat a → Option Q(0 < «$a») | null | false |
TopologicalSpace.Opens.IsBasis | Mathlib.Topology.Sets.Opens | {α : Type u_2} → [inst : TopologicalSpace α] → Set (TopologicalSpace.Opens α) → Prop | A set of `opens α` is a basis if the set of corresponding sets is a topological basis. | true |
AddSubgroup.comap_sup_comap_le | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] (H K : AddSubgroup N) (f : G →+ N),
AddSubgroup.comap f H ⊔ AddSubgroup.comap f K ≤ AddSubgroup.comap f (H ⊔ K) | null | true |
Lean.Lsp.instFromJsonCommand.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.Command | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeContext.mk.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{elabs : Array Lean.Elab.Command.InductiveElabStep2} →
{mctx : Lean.MetavarContext} →
{levelParams : List Lean.Name} →
{params : Array Lean.Expr} →
{lctx : Lean.LocalContext} →
{localInsts : Lean.LocalInstances} →
{replaceIndFVars : Lean.Expr → Lean... | null | false |
isCountablyCompact_iUnion | Mathlib.Topology.Compactness.CountablyCompact | ∀ {E : Type u_2} [inst : TopologicalSpace E] {ι : Sort u_4} {f : ι → Set E} [Finite ι],
(∀ (i : ι), IsCountablyCompact (f i)) → IsCountablyCompact (⋃ i, f i) | A finite union of countably compact sets is countably compact. | true |
WithBot.subtypeOrderIso._proof_10 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : DecidablePred fun x => x = ⊥]
(a : WithBot { a // a ≠ ⊥ }),
{ toFun := fun a => WithBot.unbotD ⊥ (WithBot.map Subtype.val a), invFun := fun a => if h : a = ⊥ then ⊥ else ↑⟨a, h⟩,
left_inv := ⋯, right_inv := ⋯ }
⊥ ≤
{ to... | null | false |
AddSubmonoid.mk_eq_top | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : AddZeroClass M] (toSubsemigroup : AddSubsemigroup M) (zero_mem' : 0 ∈ toSubsemigroup.carrier),
{ toAddSubsemigroup := toSubsemigroup, zero_mem' := zero_mem' } = ⊤ ↔ toSubsemigroup = ⊤ | null | true |
RingNorm.toAddGroupNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → [inst : NonUnitalNonAssocRing R] → RingNorm R → AddGroupNorm R | null | true |
Lean.Lsp.WorkspaceEdit.mk.inj | Lean.Data.Lsp.Basic | ∀ {changes? : Option (Std.TreeMap Lean.Lsp.DocumentUri Lean.Lsp.TextEditBatch compare)}
{documentChanges? : Option (Array Lean.Lsp.DocumentChange)}
{changeAnnotations? : Option (Std.TreeMap String Lean.Lsp.ChangeAnnotation compare)}
{changes?_1 : Option (Std.TreeMap Lean.Lsp.DocumentUri Lean.Lsp.TextEditBatch com... | null | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.noConfusion | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{J : Type w} →
{inst_1 : LinearOrder J} →
{inst_2 : OrderBot J} →
{F : CategoryTheory.Functor J C} →
{c : CategoryTheory.Limits.Cocone F} →
{X Y : C} →
{p... | null | false |
_private.Mathlib.Data.List.Sublists.0.List.Pairwise.sublists'._simp_1_5 | Mathlib.Data.List.Sublists | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b | null | false |
Topology.IsOpenEmbedding.matrix_map | Mathlib.Topology.Instances.Matrix | ∀ {m : Type u_11} {n : Type u_12} {R : Type u_13} {S : Type u_14} [inst : TopologicalSpace R]
[inst_1 : TopologicalSpace S] {f : R → S} [Finite m] [Finite n],
Topology.IsOpenEmbedding f → Topology.IsOpenEmbedding fun x => x.map f | null | true |
Lean.Parser.Command.macroRhs.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | null | true |
_private.Mathlib.Basic.Denumerable.0.Nat.Subtype.toFunAux.eq_1 | Mathlib.Basic.Denumerable | ∀ {s : Set ℕ} [inst : DecidablePred fun x => x ∈ s] (x : ↑s),
Nat.Subtype.toFunAux✝ x = List.countP (fun x => decide (x ∈ s)) (List.range ↑x) | null | true |
Representation.prod_apply_apply | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring k] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : Module k V] [inst_4 : AddCommMonoid W] [inst_5 : Module k W]
(ρV : Representation k G V) (ρW : Representation k G W) (g : G) (i : V × W),
((ρV.prod ρW) g) i = ((ρV g) i.1, (ρW... | null | true |
Lean.Elab.Term.Do.Alt.mk._flat_ctor | Lean.Elab.Do.Legacy | {σ : Type} → Lean.Syntax → Array Lean.Elab.Term.Do.Var → Lean.Syntax → σ → Lean.Elab.Term.Do.Alt σ | null | false |
StarRingEquiv.refl_symm | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_1} [inst : Add A] [inst_1 : Mul A] [inst_2 : Star A], StarRingEquiv.refl.symm = StarRingEquiv.refl | null | true |
Topology.RelCWComplex.FiniteType.mk | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] {C D : Set X} [inst_1 : Topology.RelCWComplex C D],
(∀ (n : ℕ), Finite (Topology.RelCWComplex.cell C n)) → Topology.RelCWComplex.FiniteType C | null | true |
groupHomology.single_mem_cycles₁_iff | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} (g : G) (a : ↑A),
(fun₀ | g => a) ∈ groupHomology.cycles₁ A ↔ (A.ρ g) a = a | null | true |
Lean.Plugin | Lean.Setup | Type | A Lean plugin. Plugins are shared libraries with an initialization function. | true |
Set.vadd_set_mono | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : VAdd α β] {s t : Set β} {a : α}, s ⊆ t → a +ᵥ s ⊆ a +ᵥ t | null | true |
Subgroup.quotientEquivProdOfLE_symm_apply | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s t : Subgroup α} (h_le : s ≤ t) (a : (α ⧸ t) × ↥t ⧸ s.subgroupOf t),
(Subgroup.quotientEquivProdOfLE h_le).symm a = Quotient.map' (fun b => Quotient.out a.1 * ↑b) ⋯ a.2 | null | true |
_private.Mathlib.GroupTheory.Nilpotent.0.Subgroup.ascending_central_series_le_upper.match_1_1 | Mathlib.GroupTheory.Nilpotent | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
Lean.Meta.instBEqInfoCacheKey.beq | Lean.Meta.Basic | Lean.Meta.InfoCacheKey → Lean.Meta.InfoCacheKey → Bool | null | true |
Nat.Partrec.Code.evaln._unary._proof_1 | Mathlib.Computability.PartrecCode | WellFounded (invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 | null | false |
NonUnitalSubring.prodEquiv._proof_2 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S]
(s : NonUnitalSubring R) (t : NonUnitalSubring S) (x x_1 : ↥(s.prod t)),
(Equiv.Set.prod ↑s ↑t).toFun (x * x_1) = (Equiv.Set.prod ↑s ↑t).toFun (x * x_1) | null | false |
Mathlib.Tactic.Order.AtomicFact.isSup.inj | Mathlib.Tactic.Order.CollectFacts | ∀ {lhs rhs res lhs_1 rhs_1 res_1 : ℕ},
Mathlib.Tactic.Order.AtomicFact.isSup lhs rhs res = Mathlib.Tactic.Order.AtomicFact.isSup lhs_1 rhs_1 res_1 →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ res = res_1 | null | true |
HahnSeries.recOn | Mathlib.RingTheory.HahnSeries.Basic | {Γ : Type u_1} →
{R : Type u_2} →
[inst : PartialOrder Γ] →
[inst_1 : Zero R] →
{motive : HahnSeries Γ R → Sort u} →
(t : HahnSeries Γ R) →
((coeff : Γ → R) →
(isPWO_support' : (Function.support coeff).IsPWO) →
motive { coeff := coeff, isPWO_su... | null | false |
Finset.image_add_left_Ioc | Mathlib.Algebra.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [IsOrderedCancelAddMonoid α] [ExistsAddOfLE α]
[inst_4 : LocallyFiniteOrder α] [inst_5 : DecidableEq α] (a b c : α),
Finset.image (fun x => c + x) (Finset.Ioc a b) = Finset.Ioc (c + a) (c + b) | null | true |
Topology.IsQuotientMap.of_comp_iff | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
Topology.IsQuotientMap f → (Topology.IsQuotientMap (g ∘ f) ↔ Topology.IsQuotientMap g) | null | true |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.Convex.smul_vadd_mem_of_mem_nhds_of_mem_asymptoticCone.match_1_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} (motive : k × V → Prop) (h : k × V), (∀ (t : k) (u : V), motive (t, u)) → motive h | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.rightact._regBuiltin.Lean.Parser.Term.rightact.declRange_5 | Lean.Parser.Term | IO Unit | null | false |
CategoryTheory.instIsCardinalFilteredToTypeOrd | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ (κ : Cardinal.{w}) [hκ : Fact κ.IsRegular], CategoryTheory.IsCardinalFiltered κ.ord.ToType κ | null | true |
Homeomorph.coe_prodComm | Mathlib.Topology.Constructions.SumProd | ∀ (X : Type u) (Y : Type v) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
⇑(Homeomorph.prodComm X Y) = Prod.swap | null | true |
QuotSMulTop.equivQuotTensor._proof_1 | Mathlib.RingTheory.QuotSMulTop | ∀ {R : Type u_1} [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M | null | false |
lightProfiniteToLightCondSetIsoTopCatToLightCondSet._proof_1 | Mathlib.Condensed.Light.Functors | ∀ (X : LightProfinite) (S : LightProfiniteᵒᵖ)
(f :
((CategoryTheory.sheafToPresheaf (CategoryTheory.coherentTopology LightProfinite) (Type u_1)).obj
(lightProfiniteToLightCondSet.obj X)).obj
S),
Continuous ⇑(CategoryTheory.ConcreteCategory.hom f.hom) | null | false |
CategoryTheory.Bicategory.Adjunction.homEquiv₁._proof_5 | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {b c d : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : b ⟶ d} {h : c ⟶ d}
(γ : g ⟶ CategoryTheory.CategoryStruct.comp l h),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor g).inv
(CategoryTheory... | null | false |
CategoryTheory.GrothendieckTopology.pointBotFunctor | Mathlib.CategoryTheory.Sites.Point.Presheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.LocallySmall.{w, v, u} C] → CategoryTheory.Functor C ⊥.Point | The functor `C ⥤ Point.{w} (⊥ : GrothendieckTopology C)` which sends
`X : C` to the point corresponding to `X`. | true |
Set.BijOn.subset_left | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} {r : Set α},
Set.BijOn f s t → r ⊆ s → Set.BijOn f r (f '' r) | null | true |
hasDerivWithinAt_iff_isLittleO | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
HasDerivWithinAt f f' s x ↔ (fun x' => f x' - f x - (x' - x) • f') =o[nhdsWithin x s] fun x' => x' - x | null | true |
CompHaus.limitConeIsLimit._proof_2 | Mathlib.Topology.Category.CompHaus.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CompHaus)
(S : CategoryTheory.Limits.Cone F) (m : S.pt ⟶ (CompHaus.limitCone F).pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp m ((CompHaus.limitCone F).π.app j) = S.π.app j) →
∀ (j : J),
CategoryTheory.CategoryStr... | null | false |
nnnorm_ofDual | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_3} [inst : NNNorm E] (x : Eᵒᵈ), ‖OrderDual.ofDual x‖₊ = ‖x‖₊ | null | true |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.exists_bucket_of_uset._proof_1_5 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Hashable α] (self : Array (Std.DHashMap.Internal.AssocList α β)) (i : USize)
(hi : i.toNat < self.size) (h₀ : 0 < self.size) (l₁ l₂ : List (Std.DHashMap.Internal.AssocList α β)),
l₁.length = i.toNat →
∀ (k : α),
(↑(Std.DHashMap.Internal.mkIdx self.size ⋯ (hash k... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_filter_iff._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 |
HurwitzZeta.hurwitzOddFEPair._proof_9 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : UnitAddCircle) (r : ℝ),
(fun x => (Complex.ofReal ∘ HurwitzZeta.sinKernel a) x - 0) =O[Filter.atTop] fun x => x ^ r | null | false |
Fintype.coe_finsetEquivSet | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_1} [inst : Fintype α], ⇑Fintype.finsetEquivSet = SetLike.coe | null | true |
SBtw.recOn | Mathlib.Order.Circular | {α : Type u_1} →
{motive : SBtw α → Sort u} → (t : SBtw α) → ((sbtw : α → α → α → Prop) → motive { sbtw := sbtw }) → motive t | null | false |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ioc_succ_singleton._proof_1_1 | Mathlib.Order.Interval.Finset.Nat | ∀ (b : ℕ), Finset.Ioc b (b + 1) = {b + 1} | null | false |
_private.Init.Data.Array.Lemmas.0.Array.size_reverse.go | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (as : Array α) (i : ℕ) (j : Fin as.size), (Array.reverse.loop as i j).size = as.size | null | true |
_private.Mathlib.Topology.Instances.AddCircle.Defs.0.AddCircle.liftIoc_eq_liftIco._simp_1_1 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
ContinuousAffineMap.instMetricSpace._proof_1 | Mathlib.Analysis.Normed.Affine.ContinuousAffineMap | ∀ {V : Type u_1} [inst : NormedAddCommGroup V], IsTopologicalAddTorsor V | null | false |
CategoryTheory.Functor.ranges_directed | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C]
(F : CategoryTheory.Functor C (Type u_1)) (j : C),
Directed (fun x1 x2 => x1 ⊇ x2) fun f => Set.range ⇑(CategoryTheory.ConcreteCategory.hom (F.map f.snd)) | null | true |
Std.DTreeMap.Internal.Impl.modify._f | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.LawfulEqOrd α] →
(k : α) →
(β k → β k) →
(t : Std.DTreeMap.Internal.Impl α β) → Std.DTreeMap.Internal.Impl.below t → Std.DTreeMap.Internal.Impl α β | null | false |
_private.Mathlib.MeasureTheory.Function.AEMeasurableOrder.0.MeasureTheory.aemeasurable_of_exist_almost_disjoint_supersets._proof_1_1 | Mathlib.MeasureTheory.Function.AEMeasurableOrder | ∀ {α : Type u_2} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) {β : Type u_1} [inst : CompleteLinearOrder β]
(s : Set β) (f : α → β) (u v : β → β → Set α),
(∀ (p q : β),
MeasurableSet (u p q) ∧
MeasurableSet (v p q) ∧
{x | f x < p} ⊆ u p q ∧ {x | q < f x} ⊆ v p q ∧ (p ∈ s → q ∈ s → p... | null | false |
List.Cursor.tail.eq_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} (s : l.Cursor) (h : 0 < s.suffix.length),
s.tail h = { «prefix» := s.prefix ++ [s.current h], suffix := s.suffix.tail, property := ⋯ } | null | true |
CategoryTheory.MonoidalClosed.whiskerLeft_curry'_ihom_ev_app | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
[inst_2 : CategoryTheory.Closed X] (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalClosed.curry' f))
((CategoryTheo... | null | true |
PosNum.commMonoid._proof_6 | Mathlib.Data.Num.Lemmas | ∀ (a : PosNum), a * 1 = a | null | false |
Std.ExtHashMap.getD_diff_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β}, k ∉ m₁ → (m₁ \ m₂).getD k fallback = fallback | null | true |
Std.DTreeMap.Raw.maxKeyD_insert | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β k} {fallback : α},
(t.insert k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Nondegenerate.0.LinearIndependent.sum_smul_of_nondegenerate._simp_1_3 | Mathlib.LinearAlgebra.Matrix.Nondegenerate | ∀ {α : Type u_5} {M : Type u_9} {N : Type u_10} [inst : SMul M N] [inst_1 : SMul N α] [inst_2 : SMul M α]
[IsScalarTower M N α] (x : M) (y : N) (z : α), x • y • z = (x • y) • z | null | false |
AlgebraicGeometry.Scheme.Cover.pushforwardIso | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
[P.RespectsIso] →
[P.ContainsIdentities] →
[P.IsStableUnderComposition] →
{X Y : AlgebraicGeometry.Scheme} →
AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X →
(f : X ⟶ Y) →
... | The pushforward of a cover along an isomorphism. | true |
CategoryTheory.Oplax.LaxTrans.Modification.instInhabited | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η : F ⟶ G} → Inhabited (CategoryTheory.Oplax.LaxTrans.Modification η η) | null | true |
Set.Pairwise.imp_on | Mathlib.Logic.Pairwise | ∀ {α : Type u_1} {r p : α → α → Prop} {s : Set α}, s.Pairwise r → (s.Pairwise fun ⦃a b⦄ => r a b → p a b) → s.Pairwise p | null | true |
_private.Mathlib.Data.List.Defs.0.List.map₂Left'.match_1.eq_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_1} {β : Type u_2} (motive : List α → List β → Sort u_3) (bs : List β) (h_1 : (bs : List β) → motive [] bs)
(h_2 : (a : α) → (as : List α) → motive (a :: as) [])
(h_3 : (a : α) → (as : List α) → (b : β) → (bs : List β) → motive (a :: as) (b :: bs)),
(match [], bs with
| [], bs => h_1 bs
| a :... | null | true |
MDifferentiableOn.congr_mono | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.