name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Order.GroupWithZero.Basic.0.pow_succ_nonneg.match_1_1 | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
dist_vadd_left | Mathlib.Analysis.Normed.Group.AddTorsor | ∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] (v : V) (x : P), dist (v +ᵥ x) x = ‖v‖ | null | true |
TopologicalSpace.CompactOpens.map | Mathlib.Topology.Sets.Compacts | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(f : α → β) → Continuous f → IsOpenMap f → TopologicalSpace.CompactOpens α → TopologicalSpace.CompactOpens β | The image of a compact open under a continuous open map. | true |
InfiniteGalois.isOpen_and_normal_iff_finite_and_isGalois | Mathlib.FieldTheory.Galois.Infinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] (L : IntermediateField k K)
[IsGalois k K], IsOpen L.fixingSubgroup.carrier ∧ L.fixingSubgroup.Normal ↔ FiniteDimensional k ↥L ∧ IsGalois k ↥L | null | true |
IsPrimitiveRoot.adjoinEquivRingOfIntegers_apply | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n) (a : ↥ℤ[ζ]),
hζ.adjoinEquivRingOfIntegers a = (IsIntegralClosure.lift ℤ (NumberField.RingOfIntegers K) K) a | null | true |
Std.Time.Formats.leanDateTimeWithIdentifierAndNanos | Std.Time.Format | Std.Time.GenericFormat Std.Time.Awareness.any | The leanDateTimeWithIdentifierAndNanos format, which follows the pattern `uuuu-MM-dd'T'HH:mm:ss.SSSSSSSSS'[z]'`
for representing date, time, and time zone. It uses the default value that can be parsed with the
notation of dates.
| true |
CategoryTheory.Abelian.SpectralObject.cyclesIso_inv_cyclesMap._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
Std.DHashMap.Raw.size_alter_eq_sub_one | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
{k : α} {f : Option (β k) → Option (β k)},
m.WF → k ∈ m → (f (m.get? k)).isNone = true → (m.alter k f).size = m.size - 1 | null | true |
Subtype.impEmbedding._proof_1 | Mathlib.Logic.Embedding.Basic | ∀ {α : Type u_1} (p q : α → Prop) (h : ∀ (x : α), p x → q x) (x y : { x // p x }),
(fun x => ⟨↑x, ⋯⟩) x = (fun x => ⟨↑x, ⋯⟩) y → x = y | null | false |
EquivLike.pairwise_comp_iff | Mathlib.Logic.Equiv.Pairwise | ∀ {X : Type u_1} {Y : Type u_2} {F : Sort u_3} [inst : EquivLike F Y X] (f : F) (p : X → X → Prop),
Pairwise (Function.onFun p ⇑f) ↔ Pairwise p | null | true |
ContinuousMapZero.toContinuousMapHom._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : IsTopologicalSemiring R], ↑0 = ↑0 | null | false |
_private.Mathlib.CategoryTheory.Sites.Hypercover.Zero.0.CategoryTheory.PreZeroHypercover.Hom.ext'_iff.match_1_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {S : C} {E : CategoryTheory.PreZeroHypercover S}
{F : CategoryTheory.PreZeroHypercover S} {f g : E.Hom F}
(motive :
(∃ (hs : f.s₀ = g.s₀),
∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)) →
... | null | false |
Ordinal.pred_le_self | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (o : Ordinal.{u_4}), o.pred ≤ o | null | true |
Squarefree.moebius_eq | Mathlib.RingTheory.UniqueFactorizationDomain.Moebius | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α},
Squarefree a → UniqueFactorizationMonoid.moebius a = (-1) ^ (UniqueFactorizationMonoid.factors a).card | null | true |
Semiquot.mem_pure._simp_1 | Mathlib.Data.Semiquot | ∀ {α : Type u_1} {a b : α}, (a ∈ pure b) = (a = b) | null | false |
Ordnode.Valid'.rotateL_lemma₁ | Mathlib.Data.Ordmap.Ordset | ∀ {a b c : ℕ}, 3 * a ≤ b + c → c ≤ 3 * b → a ≤ 3 * b | null | true |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor?._sparseCasesOn_5 | Lean.Meta.Tactic.Grind.PropagateInj | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
PNat.find_eq_one._simp_1 | Mathlib.Data.PNat.Find | ∀ {p : ℕ+ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), (PNat.find h = 1) = p 1 | null | false |
Polynomial.eval₂_homogenize_of_eq_one | Mathlib.Algebra.Polynomial.Homogenize | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] {p : Polynomial R} {n : ℕ},
p.natDegree ≤ n →
∀ (f : R →+* S) (g : Fin 2 → S), g 1 = 1 → MvPolynomial.eval₂ f g (p.homogenize n) = Polynomial.eval₂ f (g 0) p | null | true |
groupHomology.H0π_comp_map_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (x : ↑A),
(CategoryTheory.ConcreteCategory.hom (groupHomology.map f φ 0))
((CategoryTheory.ConcreteCategory.hom (groupHomology.H0π A)) x) =
(Categ... | null | true |
WeakPseudoEMetricSpace.mk.noConfusion | Mathlib.Topology.EMetricSpace.Defs | {α : Type u} →
{τ : TopologicalSpace α} →
{P : Sort u_1} →
{toEDist : EDist α} →
{edist_self : ∀ (x : α), edist x x = 0} →
{edist_comm : ∀ (x y : α), edist x y = edist y x} →
{edist_triangle : ∀ (x y z : α), edist x z ≤ edist x y + edist y z} →
{topology_le : (uni... | null | false |
Std.DHashMap.Internal.Raw₀.getKeyD_insertMany_emptyWithCapacity_list_of_contains_eq_false | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)} {k fallback : α},
(List.map Sigma.fst l).contains k = false →
(↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertMany l)).getKeyD k fallback = fallback | null | true |
_private.Mathlib.Algebra.Order.Group.Unbundled.Int.0.Int.ediv_eq_zero_of_lt_abs.match_1_1 | Mathlib.Algebra.Order.Group.Unbundled.Int | ∀ {a : ℤ} (motive : (b x : ℤ) → x = ↑b.natAbs → a < x → Prop) (b x : ℤ) (x_1 : x = ↑b.natAbs) (H2 : a < x),
(∀ (n : ℕ) (H2 : a < ↑(↑n).natAbs), motive (Int.ofNat n) ↑(↑n).natAbs ⋯ H2) →
(∀ (n : ℕ) (H2 : a < ↑(Int.negSucc n).natAbs), motive (Int.negSucc n) ↑(Int.negSucc n).natAbs ⋯ H2) →
motive b x x_1 H2 | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceXOr.declare_73._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.868347138._hygCtx._hyg.27 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
AddSubmonoid.coe_multiset_sum | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_3} [inst : AddCommMonoid M] (S : AddSubmonoid M) (m : Multiset ↥S),
↑m.sum = (Multiset.map Subtype.val m).sum | null | true |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.Basic.0.irreducible_iff_prime_of_existsUnique_irreducible_factors.match_1_3 | Mathlib.RingTheory.UniqueFactorizationDomain.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (p : α) (fa fb : Multiset α)
(motive : (∃ b ∈ fa + fb, Associated p b) → Prop) (x : ∃ b ∈ fa + fb, Associated p b),
(∀ (q : α) (hqf : q ∈ fa + fb) (hq : Associated p q), motive ⋯) → motive x | null | false |
_private.Aesop.Frontend.Command.0.Aesop.Frontend.Parser._aux_Aesop_Frontend_Command___elabRules_Aesop_Frontend_Parser_addRules_1.match_1 | Aesop.Frontend.Command | (motive : Aesop.GlobalRuleSetMember × Array Aesop.RuleSetName → Sort u_1) →
(x : Aesop.GlobalRuleSetMember × Array Aesop.RuleSetName) →
((rule : Aesop.GlobalRuleSetMember) → (rsNames : Array Aesop.RuleSetName) → motive (rule, rsNames)) → motive x | null | false |
CategoryTheory.ObjectProperty.IsStrongGenerator.isDense_colimitsCardinalClosure_ι | Mathlib.CategoryTheory.Presentable.StrongGenerator | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular]
[CategoryTheory.Limits.HasColimitsOfSize.{w, w, v, u} C] [CategoryTheory.LocallySmall.{w, v, u} C]
{P : CategoryTheory.ObjectProperty C} [CategoryTheory.ObjectProperty.Small.{w, v, u} P],
P.IsStrongGenerator → ... | null | true |
DirectSum.toAddMonoid | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
[DecidableEq ι] →
{γ : Type u₁} → [inst_2 : AddCommMonoid γ] → ((i : ι) → β i →+ γ) → (DirectSum ι fun i => β i) →+ γ | `toAddMonoid φ` is the natural homomorphism from `⨁ i, β i` to `γ`
induced by a family `φ` of homomorphisms `β i → γ`. | true |
CategoryTheory.Limits.isTerminalEquivUnique._proof_8 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete PEmpty.{1}) C) (Y : C),
Function.LeftInverse (fun u => { lift := fun s => default, fac := ⋯, uniq := ⋯ }) fun t X =>
{
default :=
t.lift
{ pt := X,
π := { app :... | null | false |
Sigma.Lex.boundedOrder | Mathlib.Order.Sigma | {ι : Type u_1} →
{α : ι → Type u_2} →
[inst : PartialOrder ι] →
[inst_1 : BoundedOrder ι] →
[inst_2 : (i : ι) → Preorder (α i)] → [OrderBot (α ⊥)] → [OrderTop (α ⊤)] → BoundedOrder (Σₗ (i : ι), α i) | The lexicographical linear order on a sigma type. | true |
Representation.finsuppLEquivFreeAsModule._proof_4 | Mathlib.RepresentationTheory.Basic | ∀ (k : Type u_1) (G : Type u_2) [inst : CommSemiring k] [inst_1 : Monoid G] (α : Type u_3),
Function.LeftInverse (Representation.free k G α).asModuleEquiv.symm.toAddEquiv.invFun
(Representation.free k G α).asModuleEquiv.symm.toAddEquiv.toFun | null | false |
Std.DTreeMap.Internal.Cell.ofOption | Std.Data.DTreeMap.Internal.Cell | {α : Type u} → {β : α → Type v} → [inst : Ord α] → (k : α) → Option (β k) → Std.DTreeMap.Internal.Cell α β (compare k) | Internal implementation detail of the tree map | true |
Order.Ideal.PrimePair.I_isPrime | Mathlib.Order.PrimeIdeal | ∀ {P : Type u_1} [inst : Preorder P] (IF : Order.Ideal.PrimePair P), IF.I.IsPrime | null | true |
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.exists_linearEquiv_eq_graph._simp_1_2 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {x : M₂}, (x ∈ f.range) = ∃ y, f y = x | null | false |
_private.Lean.LibrarySuggestions.Basic.0.Lean.Expr.FoldRelevantConstantsImpl.argKinds.match_1 | Lean.LibrarySuggestions.Basic | (motive : Lean.Expr → Sort u_1) →
(__do_lift : Lean.Expr) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) → ((x : Lean.Expr) → motive x) → motive __do_lift | null | false |
ENat.WithBot.add_le_add_one_left_iff | Mathlib.Data.ENat.Monoid | ∀ {a b : WithBot ℕ∞}, 1 + a ≤ 1 + b ↔ a ≤ b | null | true |
RBTree.RBNode.isOrdered_iff' | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {L R : Option α} [Std.TransCmp cmp] {t : RBTree.RBNode α},
RBTree.RBNode.isOrdered cmp t L R = true ↔
(∀ a ∈ L, RBTree.RBNode.All (fun x => RBTree.RBNode.cmpLT cmp a x) t) ∧
(∀ a ∈ R, RBTree.RBNode.All (fun x => RBTree.RBNode.cmpLT cmp x a) t) ∧
(∀ a ∈ L, ∀ ... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._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 |
Pi.mulZeroOneClass._proof_2 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroOneClass (α i)] (a : (i : ι) → α i), a * 1 = a | null | false |
IsStronglyTranscendental.iff_of_isLocalization | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] {M : Submonoid S},
M ≤ nonZeroDivisors S →
∀ [IsLocalization M T] [IsScalarTower R S T] {x : S},
IsStronglyTranscendental R ((... | null | true |
CommBialgCat.Hom | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} → [inst : CommRing R] → CommBialgCat R → CommBialgCat R → Type v | The type of morphisms in `CommBialgCat R`. | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.hom_inv_actionHomLeft | 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.MonoidalRightAction C D] {x y : D} (f : x ≅ y) (z : C),
CategoryTheory.CategoryStruct.comp (CategoryT... | null | true |
CategoryTheory.InjectiveResolution.extMk_hom | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.InjectiveResolution Y)
[inst_3 : HasDerivedCategory C] {n : ℕ} (f : X ⟶ R.cocomplex.X n) (m : ℕ) (hm : n + 1 = m)
(hf : CategoryTheory.CategoryStruct.comp f... | null | true |
Action.diagonalOneIsoLeftRegular | Mathlib.CategoryTheory.Action.Concrete | (G : Type u_1) → [inst : Monoid G] → Action.diagonal G 1 ≅ Action.leftRegular G | We have `Fin 1 → G ≅ G` as `G`-sets, with `G` acting by left multiplication. | true |
Int.le_iff_lt_or_eq | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b ↔ a < b ∨ a = b | null | true |
CategoryTheory.Idempotents.instIsIdempotentCompleteCosimplicialObject | Mathlib.CategoryTheory.Idempotents.SimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.IsIdempotentComplete C],
CategoryTheory.IsIdempotentComplete (CategoryTheory.CosimplicialObject C) | null | true |
LieHom._sizeOf_1 | Mathlib.Algebra.Lie.Basic | {R : Type u_1} →
{L : Type u_2} →
{L' : Type u_3} →
{inst : CommRing R} →
{inst_1 : LieRing L} →
{inst_2 : LieAlgebra R L} →
{inst_3 : LieRing L'} →
{inst_4 : LieAlgebra R L'} → [SizeOf R] → [SizeOf L] → [SizeOf L'] → (L →ₗ⁅R⁆ L') → ℕ | null | false |
Lean.Elab.AutoBoundImplicitContext.mk | Lean.Elab.AutoBound | Bool → Lean.PArray Lean.Expr → Lean.Elab.AutoBoundImplicitContext | null | true |
Graph.map | Mathlib.Combinatorics.Graph.Maps | {α : Type u_1} → {α' : Type u_2} → {β : Type u_4} → (α → α') → Graph α β → Graph α' β | Map `G : Graph α β` to a `Graph α' β` with the same edge set by applying a function `f : α → α'`
to each vertex. Edges between identified vertices become loops. | true |
Vector.zipWith_replicate | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {α_1 : Type u_3} {f : α → β → α_1} {a : α} {b : β} {n : ℕ},
Vector.zipWith f (Vector.replicate n a) (Vector.replicate n b) = Vector.replicate n (f a b) | null | true |
Filter.Eventually.ne_of_gt | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {f g : α → β},
(∀ᶠ (x : α) in l, g x < f x) → ∀ᶠ (x : α) in l, f x ≠ g x | null | true |
_private.Mathlib.RingTheory.OrderOfVanishing.Basic.0.Ideal.mulQuot_injective._simp_1_2 | Mathlib.RingTheory.OrderOfVanishing.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂}, Function.Injective ⇑f = (f.ker = ⊥) | null | false |
IsSelfAdjoint.conjugate' | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Semigroup R] [inst_1 : StarMul R] {x : R},
IsSelfAdjoint x → ∀ (z : R), IsSelfAdjoint (star z * x * z) | null | true |
_private.Mathlib.Order.SetAccumulate.0.Set.partialSups_eq_accumulate._simp_1_2 | Mathlib.Order.SetAccumulate | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
_private.Mathlib.RingTheory.Unramified.Locus.0.Algebra.unramifiedLocus_eq_compl_support._simp_1_2 | Mathlib.RingTheory.Unramified.Locus | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{p : PrimeSpectrum R}, (p ∉ Module.support R M) = Subsingleton (LocalizedModule p.asIdeal.primeCompl M) | null | false |
String.Pos.Raw.instLinearOrderPackage._proof_1 | Init.Data.String.OrderInstances | let this := inferInstance;
let this_1 :=
let this := inferInstance;
inferInstance;
∀ (a b : String.Pos.Raw), a < b ↔ a ≤ b ∧ ¬b ≤ a | null | false |
ZNum.decidableLT | Mathlib.Data.Num.Basic | DecidableLT ZNum | null | true |
CompHausLike.LocallyConstant.sigmaComparison_comp_sigmaIso | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
{Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (↑Q.toTop) Z) (a : Function.Fiber ⇑r)
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P]
(X : CategoryTheory.Functor (CompHausLike P)ᵒᵖ ... | null | true |
Array.range'_append_1 | Init.Data.Array.Range | ∀ {s m n : ℕ}, Array.range' s m ++ Array.range' (s + m) n = Array.range' s (m + n) | null | true |
Finset.prod_prod_Ioi_mul_eq_prod_prod_off_diag | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : LinearOrder α] [inst_2 : Fintype α]
[inst_3 : LocallyFiniteOrderTop α] [LocallyFiniteOrderBot α] (f : α → α → M),
∏ i, ∏ j > i, f j i * f i j = ∏ i, ∏ j ∈ {i}ᶜ, f j i | null | true |
NonUnitalNonAssocRing.toHasDistribNeg._proof_3 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (a : α), - -a = a | null | false |
FundamentalGroupoid.instSubsingletonHomPUnit | Mathlib.AlgebraicTopology.FundamentalGroupoid.PUnit | ∀ {x y : FundamentalGroupoid PUnit.{u_1 + 1}}, Subsingleton (x ⟶ y) | null | true |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.Monotone.tendsto_le_alternating_series._simp_1_2 | Mathlib.Analysis.SpecificLimits.Normed | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b c : α}, (a - c ≤ b) = (a ≤ b + c) | null | false |
Submonoid.LocalizationMap.mulEquivOfMulEquiv | Mathlib.GroupTheory.MonoidLocalization.Maps | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{N : Type u_2} →
[inst_1 : CommMonoid N] →
{P : Type u_3} →
[inst_2 : CommMonoid P] →
S.LocalizationMap N →
{T : Submonoid P} →
{Q : Type u_4} →
[ins... | Given Localization maps `f : M →* N, k : P →* U` for Submonoids `S, T` respectively, an
isomorphism `j : M ≃* P` such that `j(S) = T` induces an isomorphism of localizations `N ≃* U`. | true |
Lean.Meta.Grind.Arith.Cutsat.canBeEvaluated | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | Lean.Expr → Lean.Meta.Grind.GoalM Bool | Returns `true` if numerals of the embedded type `α` can be evaluated, i.e., their
embedded (`Fin.val`/`toNat`/`toInt`) value can be computed directly. Such numerals are
not given embedding-accessor applications. Currently this means the modulus of `α` is
known, but future embedded types may be evaluable without one.
| true |
_private.Mathlib.Dynamics.TopologicalEntropy.NetEntropy.0.Dynamics.coverMincard_le_netMaxcard._simp_1_5 | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
Submodule.finiteDimensional_iSup | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Sort u_1}
[Finite ι] (S : ι → Submodule K V) [∀ (i : ι), FiniteDimensional K ↥(S i)], FiniteDimensional K ↥(⨆ i, S i) | The submodule generated by a supremum of finite-dimensional submodules, indexed by a finite
sort is finite-dimensional. | true |
LieSubmodule.ext | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), (∀ (m : M), m ∈ N ↔ m ∈ N') → N = N' | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_le._proof_1_1 | Init.Data.BitVec.Lemmas | ¬1 < 2 → False | null | false |
Lean.StructureDescr.fields | Lean.Structure | Lean.StructureDescr → Array Lean.StructureFieldInfo | The fields should be in the order that they appear in the structure's constructor. | true |
FirstOrder.Language.DirectLimit.inductionOn | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {ι : Type v} [inst : Preorder ι] {G : ι → Type w} [inst_1 : (i : ι) → L.Structure (G i)]
{f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)} [inst_2 : IsDirectedOrder ι]
[inst_3 : DirectedSystem G fun i j h => ⇑(f i j h)] [inst_4 : Nonempty ι]
{C : FirstOrder.Language.DirectLimit G f → P... | null | true |
mul_mem_ball_iff_norm | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedCommGroup E] {a b : E} {r : ℝ}, a * b ∈ Metric.ball a r ↔ ‖b‖ < r | null | true |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.instDecidableEqIterator.decEq.match_1.splitter | Batteries.Data.String.Lemmas | (motive : String.Legacy.Iterator → String.Legacy.Iterator → Sort u_1) →
(x x_1 : String.Legacy.Iterator) →
((a : String) →
(a_1 : String.Pos.Raw) →
(b : String) → (b_1 : String.Pos.Raw) → motive { s := a, i := a_1 } { s := b, i := b_1 }) →
motive x x_1 | null | true |
CategoryTheory.Limits.Types.TypeMax.colimitCocone | Mathlib.CategoryTheory.Limits.Types.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J (Type (max v u))) → CategoryTheory.Limits.Cocone F | (internal implementation) the colimit cocone of a functor,
implemented as a quotient of a sigma type
| true |
ContinuousLinearMap.lTensor_eq_mapL | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} (E : Type u_2) {G : Type u_4} {H : Type u_5} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup G] [inst_4 : InnerProductSpace 𝕜 G]
[inst_5 : NormedAddCommGroup H] [inst_6 : InnerProductSpace 𝕜 H] (g : G →L[𝕜] H),
ContinuousLinear... | null | true |
_private.Std.Data.Iterators.Lemmas.Equivalence.HetT.0.Std.Iterators.HetT.pmap_map._simp_1_1 | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type v} {x y : Std.Iterators.HetT m α},
(x = y) =
∃ (h : x.Property = y.Property),
∀ (β : Type w) (f : (a : α) → x.Property a → m β), x.prun f = y.prun fun a ha => f a ⋯ | null | false |
CategoryTheory.Localization.inverts | Mathlib.CategoryTheory.Localization.Predicate | ∀ {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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [L.IsLocalization W], W.IsInvertedBy L | null | true |
Set.iUnion₂_inter | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_6} (s : (i : ι) → κ i → Set α) (t : Set α),
(⋃ i, ⋃ j, s i j) ∩ t = ⋃ i, ⋃ j, s i j ∩ t | null | true |
_private.Mathlib.Order.WithBot.0.WithBot.noMaxOrder.match_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] (a : α) (motive : (∃ b, a < b) → Prop) (x : ∃ b, a < b),
(∀ (b : α) (hba : a < b), motive ⋯) → motive x | null | false |
CategoryTheory.Functor.OplaxRightLinear.noConfusion | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {P : Sort u} →
{D : Type u_1} →
{D' : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} D} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} D'} →
{F : CategoryTheory.Functor D D'} →
{C : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} →
... | null | false |
TopologicalSpace.instWellFoundedLTClosedsOfNoetherianSpace | Mathlib.Topology.NoetherianSpace | ∀ {α : Type u_1} [inst : TopologicalSpace α] [TopologicalSpace.NoetherianSpace α],
WellFoundedLT (TopologicalSpace.Closeds α) | null | true |
_private.Mathlib.Order.Setoid.Partition.0.IndexedPartition.piecewise_preimage.match_1_1 | Mathlib.Order.Setoid.Partition | ∀ {ι : Type u_2} {α : Type u_1} {s : ι → Set α} {β : Type u_3} (f : ι → α → β) (t : Set β) (x : α)
(motive : x ∈ ⋃ i, s i ∩ f i ⁻¹' t → Prop) (x_1 : x ∈ ⋃ i, s i ∩ f i ⁻¹' t),
(∀ (a : Set α) (i : ι) (hi : (fun i => s i ∩ f i ⁻¹' t) i = a) (ha : x ∈ a), motive ⋯) → motive x_1 | null | false |
Finset.erase_val | Mathlib.Data.Finset.Erase | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α), (s.erase a).val = s.val.erase a | null | true |
BddDistLat.Iso.mk._proof_3 | Mathlib.Order.Category.BddDistLat | ∀ {α β : BddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat),
CategoryTheory.CategoryStruct.comp
(BddDistLat.ofHom
(let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }))
(BddDistLat.ofHom
(let __src := {... | null | false |
SSet.Subcomplex.N.opEquiv._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | ∀ {X : SSet} {A : X.Subcomplex} (x : A.N),
{ toN := SSet.N.opEquiv { toN := SSet.N.opEquiv.symm x.toN, notMem := ⋯ }.toN, notMem := ⋯ } =
{ toN := SSet.N.opEquiv { toN := SSet.N.opEquiv.symm x.toN, notMem := ⋯ }.toN, notMem := ⋯ } | null | false |
SimpleGraph.Walk.ofBoxProdLeft._proof_2 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} {H : SimpleGraph β} {x : α × β} (v : α × β), H.Adj x.2 v.2 ∧ x.1 = v.1 → v.1 = x.1 | null | false |
List.isEqv.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (x : α → α → Bool) (a : α) (as : List α) (b : α) (bs : List α),
(a :: as).isEqv (b :: bs) x = (x a b && as.isEqv bs x) | null | true |
AffineBasis.instInhabitedPUnit._proof_1 | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {k : Type u_2} [inst : Ring k], affineSpan k (Set.range id) = ⊤ | null | false |
CategoryTheory.Abelian.im | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Abelian C] → CategoryTheory.Functor (CategoryTheory.Arrow C) C | `Abelian.image` as a functor from the arrow category. | true |
MonoidHom.exists_nhds_isBounded | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {G : Type u_1} {H : Type u_2} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : TopologicalSpace G]
[IsTopologicalGroup G] [BorelSpace G] [LocallyCompactSpace G] [inst_6 : MeasurableSpace H]
[inst_7 : SeminormedGroup H] [OpensMeasurableSpace H] (f : G →* H),
Measurable ⇑f → ∀ (x : G), ∃ s ∈ nhds x, Bornol... | null | true |
QuotientGroup.equivQuotientZPowOfEquiv_symm | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {A B : Type u} [inst : CommGroup A] [inst_1 : CommGroup B] (e : A ≃* B) (n : ℤ),
(QuotientGroup.equivQuotientZPowOfEquiv e n).symm = QuotientGroup.equivQuotientZPowOfEquiv e.symm n | null | true |
Measure.eq_prod_of_integral_prod_mul_boundedContinuousFunction | Mathlib.MeasureTheory.Measure.HasOuterApproxClosedProd | ∀ {ι : Type u_1} {T : Type u_4} {X : ι → Type u_5} {mX : (i : ι) → MeasurableSpace (X i)}
[inst : (i : ι) → TopologicalSpace (X i)] [∀ (i : ι), BorelSpace (X i)] [∀ (i : ι), HasOuterApproxClosed (X i)]
{mT : MeasurableSpace T} [inst_3 : TopologicalSpace T] [BorelSpace T] [HasOuterApproxClosed T] [inst_6 : Fintype ι... | null | true |
Lean.Lsp.RpcConnected.casesOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.RpcConnected → Sort u} →
(t : Lean.Lsp.RpcConnected) → ((sessionId : UInt64) → motive { sessionId := sessionId }) → motive t | null | false |
IsApproximateSubgroup.subgroup | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : Group G] {S : Type u_2} [inst_1 : SetLike S G] [SubgroupClass S G] {H : S},
IsApproximateSubgroup 1 ↑H | null | true |
HomotopicalAlgebra.FibrantObject.HoCat.ιCompResolutionNatTrans._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x x_1 : HomotopicalAlgebra.FibrantObject C) (f : x ⟶ x_1),
HomotopicalAlgebra.FibrantObject.toHoCat.map
(CategoryTheory.CategoryStruct.comp f
{ hom := HomotopicalAlgebra.FibrantObject.HoCat.iR... | null | false |
Std.Http.Protocol.H1.Reader.remainingBytes | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Reader dir → ℕ | Gets the number of bytes remaining in the input buffer.
| true |
Sylow.mulEquivIteratedWreathProduct._proof_3 | Mathlib.GroupTheory.RegularWreathProduct | ∀ (n : ℕ) (G : Type u_1) [Finite G], Finite (Fin n → G) | null | false |
LocallyFiniteOrder.toLocallyFiniteOrderBot._proof_2 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : OrderBot α] (a x : α),
x ∈ Finset.Ico ⊥ a ↔ x < a | null | false |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedTotalDegree'_eq_bot_iff._simp_1_4 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Type u_1} {a : α}, (↑a = ⊥) = False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.