name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Module.DirectLimit.lift_of'._proof_1 | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_3} [inst : Semiring R] {ι : Type u_1} [inst_1 : Preorder ι] {G : ι → Type u_2}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] (i j : ι) (hij : i ≤ j) (x : G i),
(Module.DirectLimit.of R ι G f j) ((f i j hi... | null | false |
Rack.PreEnvelGroupRel'.trans.elim | Mathlib.Algebra.Quandle | {R : Type u} →
[inst : Rack R] →
{motive : (a a_1 : Rack.PreEnvelGroup R) → Rack.PreEnvelGroupRel' R a a_1 → Sort u_1} →
{a a_1 : Rack.PreEnvelGroup R} →
(t : Rack.PreEnvelGroupRel' R a a_1) →
t.ctorIdx = 2 →
({a b c : Rack.PreEnvelGroup R} →
(hab : Rack.PreEnve... | null | false |
Sublattice.le_prod_iff | Mathlib.Order.Sublattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] {L : Sublattice α} {M : Sublattice β}
{N : Sublattice (α × β)}, N ≤ L.prod M ↔ N ≤ Sublattice.comap LatticeHom.fst L ∧ N ≤ Sublattice.comap LatticeHom.snd M | null | true |
CategoryTheory.Functor.IsDenseSubsite.hasWeakSheafify_of_isEquivalence | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {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] (J : CategoryTheory.GrothendieckTopology C)
(K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor C D) (A : Type u_3)
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] [ins... | null | true |
SSetPair.instEpiHomologyπOfNatNat | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Relative | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] [inst_1 : CategoryTheory.Limits.HasCoproducts A]
[inst_2 : CategoryTheory.Abelian A] (P : SSetPair) (R : A), CategoryTheory.Epi (P.homologyπ R 0) | null | true |
ImportGraph.Shake.instInhabitedDeclDeclNeedsKind | ImportGraph.Shake.DeclNeeds | Inhabited ImportGraph.Shake.DeclDeclNeedsKind | null | true |
instPreservesFiniteProductsOppositeYonedaPresheafOfPreservesFiniteCoproductsTopCat | Mathlib.Condensed.TopComparison | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (G : CategoryTheory.Functor C TopCat) (X : Type w')
[inst_1 : TopologicalSpace X] [CategoryTheory.Limits.PreservesFiniteCoproducts G],
CategoryTheory.Limits.PreservesFiniteProducts (ContinuousMap.yonedaPresheaf G X) | If `G` preserves finite coproducts (which is the case when `C` is `CompHaus`, `Profinite` or
`Stonean`), then `yonedaPresheaf` preserves finite products, which is required to be a sheaf for
the extensive topology.
| true |
CategoryTheory.Limits.MonoFactorisation.copy_m | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
(F : CategoryTheory.Limits.MonoFactorisation f) (m : F.I ⟶ Y) (e : X ⟶ F.I)
(hm : autoParam (m = F.m) CategoryTheory.Limits.MonoFactorisation.copy._auto_1)
(he : autoParam (e = F.e) CategoryTheory.Limits.MonoFactorisation.copy._auto_3)... | null | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.State.closeError._default | Std.Http.Data.Body.Stream | Option IO.Error | null | false |
Filter.Germ.coeRingHom._proof_3 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {R : Type u_1} [inst : Semiring R] (l : Filter α), (↑(Filter.Germ.coeAddHom l)).toFun 0 = 0 | null | false |
_private.Mathlib.NumberTheory.PythagoreanTriples.0.circleEquivGen._simp_3 | Mathlib.NumberTheory.PythagoreanTriples | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Std.TreeMap.minKeyD_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β}
{fallback : α}, (t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' | null | true |
ENNReal.limsup_const_mul | Mathlib.Order.Filter.ENNReal | ∀ {α : Type u_1} {f : Filter α} [CountableInterFilter f] {u : α → ENNReal} {a : ENNReal},
Filter.limsup (fun x => a * u x) f = a * Filter.limsup u f | null | true |
_private.Mathlib.Tactic.ClickSuggestions.FindPremises.0.Mathlib.Tactic.ClickSuggestions.Entries.addConst._sparseCasesOn_4 | Mathlib.Tactic.ClickSuggestions.FindPremises | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Encodable.decodeSum._sparseCasesOn_1.else_eq | Mathlib.Logic.Encodable.Basic | ∀ {motive : Bool → Sort u} (t : Bool) (false : motive false) («else» : Nat.hasNotBit 1 t.ctorIdx → motive t)
(h : Nat.hasNotBit 1 t.ctorIdx), Encodable.decodeSum._sparseCasesOn_1 t false «else» = «else» h | null | false |
_private.Mathlib.Algebra.Order.SuccPred.PartialSups.0.partialSups_add_one'._simp_1_1 | Mathlib.Algebra.Order.SuccPred.PartialSups | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Add α] [inst_2 : One α] [inst_3 : SuccAddOrder α] (x : α),
x + 1 = Order.succ x | null | false |
_private.Mathlib.Computability.EpsilonNFA.0.εNFA.mem_evalFrom_iff_exists_path._simp_1_3 | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u_1} (l : List (Option α)), (l.reduceOption = []) = ∃ n, l = List.replicate n none | null | false |
IsAtom.of_compl | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {a : α}, IsAtom aᶜ → IsCoatom a | **Alias** of the forward direction of `isAtom_compl`. | true |
CategoryTheory.conjugateEquiv_adjunction_id_symm | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {L R : CategoryTheory.Functor C C} (adj : L ⊣ R)
(α : R ⟶ CategoryTheory.Functor.id C) (c : C),
((CategoryTheory.conjugateEquiv adj CategoryTheory.Adjunction.id).symm α).app c =
CategoryTheory.CategoryStruct.comp (adj.unit.app c) (α.app (L.obj c)) | null | true |
Lean.ParametricAttributeExtra.mk._flat_ctor | Batteries.Lean.AttributeExtra | {α : Type} → Lean.ParametricAttribute α → Std.HashMap Lean.Name α → Lean.ParametricAttributeExtra α | null | false |
_private.Mathlib.RingTheory.Etale.Pi.0.Algebra.FormallyEtale.pi_iff._simp_1_1 | Mathlib.RingTheory.Etale.Pi | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
Algebra.FormallyEtale R A = (Algebra.FormallyUnramified R A ∧ Algebra.FormallySmooth R A) | null | false |
Complex.conjCLE_nnnorm | Mathlib.Analysis.Complex.OperatorNorm | ‖↑Complex.conjCLE‖₊ = 1 | null | true |
Lists'.mem_of_subset | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : Lists α} {l₁ l₂ : Lists' α true}, l₁ ⊆ l₂ → a ∈ l₁ → a ∈ l₂ | null | true |
_private.Mathlib.Analysis.Complex.Arg.0.Complex.sameRay_iff._simp_1_6 | Mathlib.Analysis.Complex.Arg | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
_private.Mathlib.Algebra.Order.Archimedean.Real.Basic.0.Real.exists_isLUB._simp_1_3 | Mathlib.Algebra.Order.Archimedean.Real.Basic | ∀ {α : Type u_1} [inst : LT α] {x y : α}, (x > y) = (y < x) | null | false |
_private.Mathlib.LinearAlgebra.Matrix.ToLinearEquiv.0.Matrix.det_ne_zero_of_sum_col_pos._simp_1_1 | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
(a < s.sup' H f) = ∃ b ∈ s, a < f b | null | false |
LocallyConstant.mapAddMonoidHom.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {Z : Type u_6} [inst_1 : AddZeroClass Y]
[inst_2 : AddZeroClass Z] (f : Y →+ Z),
LocallyConstant.mapAddMonoidHom f = { toFun := LocallyConstant.map ⇑f, map_zero' := ⋯, map_add' := ⋯ } | null | true |
Filter.comap_sup | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {g₁ g₂ : Filter β} {m : α → β},
Filter.comap m (g₁ ⊔ g₂) = Filter.comap m g₁ ⊔ Filter.comap m g₂ | null | true |
IsRelUpperSet.mem_of_le | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {s : Set α} {a b : α} {P : α → Prop} [inst : LE α], IsRelUpperSet s P → a ∈ s → a ≤ b → P b → b ∈ s | null | true |
Pell.yn_modEq_a_sub_one | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (n : ℕ), Pell.yn a1 n ≡ n [MOD a - 1] | null | true |
AddEquiv.prodAssoc.match_1 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_2} {N : Type u_1} {P : Type u_3} (motive : (M × N) × P → Prop) (x : (M × N) × P),
(∀ (fst : M × N) (snd : P), motive (fst, snd)) → motive x | null | false |
UInt8.toUInt32_le._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a.toUInt32 ≤ b.toUInt32) = (a ≤ b) | null | false |
Std.ExtHashMap.getKey!_eq_of_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
[inst_1 : Inhabited α] {k : α}, k ∈ m → m.getKey! k = k | null | true |
AddMemClass.subtype._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} {A : Type u_2} [inst : Add M] [inst_1 : SetLike A M] [hA : AddMemClass A M] (S' : A) (x x_1 : ↥S'),
↑(x + x_1) = ↑(x + x_1) | null | false |
Lean.Elab.Do.Context._sizeOf_inst | Lean.Elab.Do.Basic | SizeOf Lean.Elab.Do.Context | null | false |
bernoulli'_zero | Mathlib.NumberTheory.Bernoulli | bernoulli' 0 = 1 | null | true |
LinearAlgebra.FreeProduct.ringCon'.eq_1 | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ {I : Type u} [inst : DecidableEq I] (R : Type v) [inst_1 : CommSemiring R] (A : I → Type w)
[inst_2 : (i : I) → Semiring (A i)] [inst_3 : (i : I) → Algebra R (A i)],
LinearAlgebra.FreeProduct.ringCon' R A = ringConGen (LinearAlgebra.FreeProduct.rel' R A) | null | true |
lTensor.inverse._proof_1 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_3} {N : Type u_1} {P : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : AddCommGroup P]
[inst_3 : Module R N] [inst_4 : Module R P] {g : N →ₗ[R] P} (hg : Function.Surjective ⇑g),
Function.RightInverse (Function.surjInv hg) ⇑g | null | false |
Polynomial.trinomial_leading_coeff' | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {R : Type u_1} [inst : Semiring R] {k m n : ℕ} {u v w : R},
k < m → m < n → (Polynomial.trinomial k m n u v w).coeff n = w | null | true |
Convert.ExpensiveConfig.partialApp._inherited_default | Mathlib.Tactic.Convert | Bool | null | false |
SemilatSupCat.of.sizeOf_spec | Mathlib.Order.Category.Semilat | ∀ (X : Type u) [isSemilatticeSup : SemilatticeSup X] [isOrderBot : OrderBot X],
sizeOf ↧X = 1 + sizeOf X + sizeOf isSemilatticeSup + sizeOf isOrderBot | null | true |
AddGroupFilterBasis.instInhabited._proof_1 | Mathlib.Topology.Algebra.FilterBasis | ∀ {G : Type u_1} [inst : AddGroup G] {x y : Set G}, x ∈ {{0}} → y ∈ {{0}} → ∃ z ∈ {{0}}, z ⊆ x ∩ y | null | false |
_private.Lean.Elab.Command.0.Lean.Elab.Command.withScope.match_1 | Lean.Elab.Command | (motive : List Lean.Elab.Command.Scope → Sort u_1) →
(x : List Lean.Elab.Command.Scope) →
(Unit → motive []) →
((h : Lean.Elab.Command.Scope) → (t : List Lean.Elab.Command.Scope) → motive (h :: t)) → motive x | null | false |
CategoryTheory.Sheaf.isIso_of_coversTop | Mathlib.CategoryTheory.Sites.LocalProperties | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {K : CategoryTheory.GrothendieckTopology C}
{A : Type u_2} [inst_1 : CategoryTheory.Category.{v_2, u_2} A] {ι : Type u_3} {X : ι → C},
K.CoversTop X →
∀ {F G : CategoryTheory.Sheaf K A} {f : F ⟶ G},
(∀ (i : ι), CategoryTheory.IsIso ((K.overPul... | A sheaf morphism is an isomorphism if it becomes one after pulling back along each
element of a covering family. | true |
Bool.not_rightInverse | Mathlib.Logic.Equiv.Bool | Function.RightInverse not not | null | true |
CategoryTheory.Sheaf.H.δ.congr_simp | Mathlib.CategoryTheory.Sites.SheafCohomology.ExactSequences | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
[inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : CategoryTheory.HasExt (CategoryTheory.Sheaf J AddCommGrpCat)]
{S : CategoryTheory.ShortComplex (CategoryTheory.Sheaf J AddCommGrpCat)} (hS : S.ShortE... | null | true |
Polynomial.coeff_ofNat_mul | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {a k : ℕ} [inst_1 : a.AtLeastTwo],
(OfNat.ofNat a * p).coeff k = OfNat.ofNat a * p.coeff k | null | true |
AddMonoidHom.fst.eq_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_3) (N : Type u_4) [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
AddMonoidHom.fst M N = { toFun := Prod.fst, map_zero' := ⋯, map_add' := ⋯ } | null | true |
Std.DTreeMap.getKey_insertMany_list_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
{l : List ((a : α) × β a)} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l → ∀ {h' : k' ∈ t.insertMany l}, (t.insertMany l).get... | null | true |
Lean.SimplePersistentEnvExtensionDescr.addImportedFn | Lean.EnvExtension | {α σ : Type} → Lean.SimplePersistentEnvExtensionDescr α σ → Array (Array α) → σ | null | true |
Fin.insertNthOrderIso_zero | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_2) [inst : (i : Fin (n + 1)) → LE (α i)],
Fin.insertNthOrderIso α 0 = Fin.consOrderIso α | null | true |
CategoryTheory.Functor.mapAction_map_hom | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} W] (F : CategoryTheory.Functor V W) (G : Type u_3) [inst_2 : Monoid G]
{X Y : Action V G} (f : X ⟶ Y), ((F.mapAction G).map f).hom = F.map f.hom | null | true |
HomologicalComplex.IsSupported.mk._flat_ctor | Mathlib.Algebra.Homology.Embedding.IsSupported | ∀ {ι : 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.Embedding c'},
(∀ (i' : ι'), (∀ (i : ι), e.f i ≠ i') → K.ExactAt i') → K.IsSupported e | null | false |
Prefunctor.symmetrify | Mathlib.Combinatorics.Quiver.Symmetric | {U : Type u_1} →
{V : Type u_2} → [inst : Quiver U] → [inst_1 : Quiver V] → U ⥤q V → Quiver.Symmetrify U ⥤q Quiver.Symmetrify V | A prefunctor canonically defines a prefunctor of the symmetrifications. | true |
OmegaCompletePartialOrder.ContinuousHom.forall_forall_merge' | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(c₀ : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c₁ : OmegaCompletePartialOrder.Chain α) (z : β),
(∀ (j i : ℕ), (c₀ i) (c₁ j) ≤ z) ↔ ∀ (i : ℕ), (c₀ i) (c₁ i) ≤ z | null | true |
_private.Mathlib.Basic.Unique.0.Unique.exists_iff.match_1_1 | Mathlib.Basic.Unique | ∀ {α : Sort u_1} {p : α → Prop} (motive : Exists p → Prop) (x : Exists p), (∀ (a : α) (ha : p a), motive ⋯) → motive x | null | false |
PositiveContinuousLinearMap.instAdd | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Positive | {R : Type u_1} →
{E₁ : Type u_2} →
{E₂ : Type u_3} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid E₁] →
[inst_2 : PartialOrder E₁] →
[inst_3 : AddCommMonoid E₂] →
[inst_4 : PartialOrder E₂] →
[inst_5 : Module R E₁] →
[inst_6 : Mo... | null | true |
Nat.instHasUniqueRoots | Mathlib.Algebra.Group.Nat.Defs | HasUniqueRoots ℕ | null | true |
FreeAddGroup.lift._proof_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddGroup β] (f : α → β),
(fun g => ⇑g ∘ FreeAddGroup.of) ((fun f => AddMonoidHom.mk' (Quot.lift (FreeAddGroup.Lift.aux f) ⋯) ⋯) f) = f | null | false |
_private.Lean.Parser.Basic.0.Lean.Parser.longestMatchFn._sparseCasesOn_1 | Lean.Parser.Basic | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Rep.resMap._proof_2 | Mathlib.RepresentationTheory.Rep.Res | ∀ {k : Type u_2} [inst : Semiring k] {G : Type u_3} [inst_1 : Monoid G] {X Y : Rep.{u_1, u_2, u_3} k G},
LinearMapClass (X.ρ.IntertwiningMap Y.ρ) k ↑X ↑Y | null | false |
Left.mul_lt_one' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : MulOneClass α] [inst_1 : Preorder α] [MulLeftMono α], b < c → a < 1 → b * a < c | Assumes left covariance.
The lemma assuming right covariance is `Right.mul_lt_one'`. | true |
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.rightAnnihilator | Lean.Compiler.LCNF.Simp.ConstantFold | {α : Type} →
[Lean.Compiler.LCNF.Simp.ConstantFold.Literal α] →
[BEq α] →
(annihilator zero : α) →
(op : α → α → α) →
autoParam (∀ (x : α), op x annihilator = zero)
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.rightAnnihilator._auto_1 →
Lean.Compiler.LCNF.Simp.Cons... | Provide a folder for an operation with a right annihilator.
| true |
String.Legacy.Iterator.nextn._sunfold | Init.Data.String.Iterator | String.Legacy.Iterator → ℕ → String.Legacy.Iterator | null | false |
MulHom.ofDense.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_3} {N : Type u_4} [inst : Semigroup M] [inst_1 : Semigroup N] {s : Set M} (f : M → N)
(hs : Subsemigroup.closure s = ⊤) (hmul : ∀ (x y : M), y ∈ s → f (x * y) = f x * f y),
MulHom.ofDense f hs hmul = { toFun := f, map_mul' := ⋯ } | null | true |
CategoryTheory.SingleFunctors.instIsIsoFunctorHom | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {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] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] {F G : CategoryTheory.SingleFunctors C D A} (f : F ⟶ G)
[CategoryTheory.IsIso f] (n : A), CategoryTheory.IsIso ... | null | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesEIso_inv_τ₂ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
List.Subperm.idxInj._proof_3 | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [ReflBEq α] {xs ys : List α},
xs.Subperm ys → ∀ (i : Fin xs.length), List.idxOfNth xs[↑i] ys (List.countBefore xs[i] xs ↑i) < ys.length | null | false |
Lean.SubExpr.GoalsLocation.mk | Lean.SubExpr | Lean.MVarId → Lean.SubExpr.GoalLocation → Lean.SubExpr.GoalsLocation | null | true |
Nat.eq_sq_add_sq_iff_eq_sq_mul | Mathlib.NumberTheory.SumTwoSquares | ∀ {n : ℕ}, (∃ x y, n = x ^ 2 + y ^ 2) ↔ ∃ a b, n = a ^ 2 * b ∧ IsSquare (-1) | A natural number `n` is a sum of two squares if and only if `n = a^2 * b` with natural
numbers `a` and `b` such that `-1` is a square modulo `b`. | true |
ae_lt_of_lt_essInf | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : ConditionallyCompleteLinearOrder β] {x : β} {f : α → β},
x < essInf f μ →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) (MeasureTheory.ae μ) f) ae_lt_of_lt_essInf._auto_1 →
∀ᵐ (y : α) ∂μ, x < f y | null | true |
String.contains_iff | Batteries.Data.String.Lemmas | ∀ (s : String) (c : Char), String.Legacy.contains s c = true ↔ c ∈ s.toList | null | true |
CategoryTheory.Adjunction.CoreHomEquiv.mk.noConfusion | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
{P : Sort u} →
{homEquiv : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ ... | null | false |
CompleteLat.casesOn | Mathlib.Order.Category.CompleteLat | {motive : CompleteLat → Sort u} →
(t : CompleteLat) → ((carrier : Type u_1) → [str : CompleteLattice carrier] → motive ↧carrier) → motive t | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.isTopologicallyNilpotent_of_constantCoeff._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_1} {R : Type u_2} [inst : TopologicalSpace R] [inst_1 : Semiring R] {ι : Type u_3}
(f : ι → MvPowerSeries σ R) (u : Filter ι) (g : MvPowerSeries σ R),
Filter.Tendsto f u (nhds g) =
∀ (d : σ →₀ ℕ), Filter.Tendsto (fun i => (MvPowerSeries.coeff d) (f i)) u (nhds ((MvPowerSeries.coeff d) g)) | null | false |
Module.annihilator_eq_bot | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_4} {M : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.annihilator R M = ⊥ ↔ FaithfulSMul R M | null | true |
AlgebraicGeometry.LocallyRingedSpace.evaluation_eq_zero_iff_notMem_basicOpen | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ (X : AlgebraicGeometry.LocallyRingedSpace) {U : TopologicalSpace.Opens ↑X.toTopCat} (x : ↥U)
(f : ↑(X.presheaf.obj (Opposite.op U))),
(CategoryTheory.ConcreteCategory.hom (X.evaluation x)) f = 0 ↔ ↑x ∉ X.toRingedSpace.basicOpen f | null | true |
ModularForm | Mathlib.NumberTheory.ModularForms.Basic | Subgroup (GL (Fin 2) ℝ) → ℤ → Type | These are `SlashInvariantForm`'s that are holomorphic and bounded at infinity. | true |
Cardinal.lift_iSup | Mathlib.SetTheory.Cardinal.Basic | ∀ {ι : Type v} {f : ι → Cardinal.{w}},
BddAbove (Set.range f) → Cardinal.lift.{u, w} (iSup f) = ⨆ i, Cardinal.lift.{u, w} (f i) | The lift of a supremum is the supremum of the lifts. | true |
_private.Mathlib.Tactic.NormNum.NatFib.0.Mathlib.Meta.NormNum.proveNatFibAux.match_1 | Mathlib.Tactic.NormNum.NatFib | (en : Q(ℕ)) →
(motive : (ea' : Q(ℕ)) × (eb' : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsFibAux «$en» «$ea'» «$eb'») → Sort u_1) →
(x : (ea' : Q(ℕ)) × (eb' : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsFibAux «$en» «$ea'» «$eb'»)) →
((ea eb : Q(ℕ)) → (H : Q(Mathlib.Meta.NormNum.IsFibAux «$en» «$ea» «$eb»)) → motive ⟨ea, ⟨eb, H⟩... | null | false |
ConvexCone.instAddCommSemigroup._proof_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (x x_1 x_2 : ConvexCone R M), x + x_1 + x_2 = x + (x_1 + x_2) | null | false |
CategoryTheory.BraidedCategory.tensorLeftIsoTensorRight | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] →
(X : C) → CategoryTheory.MonoidalCategory.tensorLeft X ≅ CategoryTheory.MonoidalCategory.tensorRight X | In a braided monoidal category, the functors `tensorLeft X` and
`tensorRight X` are isomorphic. | true |
List.isSome_minOn?_iff | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {f : α → β} {xs : List α},
(List.minOn? f xs).isSome = true ↔ xs ≠ [] | null | true |
Lean.Elab.Tactic.BVDecide.BVDecideConfig.mk._flat_ctor | Std.Tactic.BVDecide.Syntax | ℕ →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool → Bool → ℕ → Bool → Lean.Elab.Tactic.BVDecide.SolverMode → Lean.Elab.Tactic.BVDecide.BVDecideConfig | null | false |
_private.Lean.Language.Basic.0.Lean.Language.withHeaderExceptions.match_1 | Lean.Language.Basic | {α : Type} →
(motive : Except IO.Error α → Sort u_1) →
(__do_lift : Except IO.Error α) →
((e : IO.Error) → motive (Except.error e)) → ((a : α) → motive (Except.ok a)) → motive __do_lift | null | false |
CategoryTheory.MorphismProperty.multiplicativeClosure.below | Mathlib.CategoryTheory.MorphismProperty.Composition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{motive : ⦃X Y : C⦄ → (x : X ⟶ Y) → W.multiplicativeClosure x → Prop} →
{X Y : C} → {x : X ⟶ Y} → W.multiplicativeClosure x → Prop | null | true |
LinearIsometry.isEmbedding | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E₂ : Type u_5} {F : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E₂] [inst_3 : Module R₂ E₂] [inst_4 : NormedAddCommGroup F]
[inst_5 : Module R F] (f : F →ₛₗᵢ[σ₁₂] E₂), Topology.IsEmbedding ⇑f | null | true |
Sublocale.carrier.instCompleteLattice._proof_9 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {S : Sublocale X} (s : Set ↥S), IsGLB s (sInf s) | null | false |
Std.ExtTreeSet.get!_inter_of_not_mem_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α]
{k : α}, k ∉ t₁ → (t₁ ∩ t₂).get! k = default | null | true |
Int.Internal.Linear.cooper_dvd_left_split_dvd1 | Init.Data.Int.Linear | ∀ (ctx : Int.Internal.Linear.Context) (p₁ p₂ p₃ : Int.Internal.Linear.Poly) (d : ℤ) (k : ℕ) (a : ℤ)
(p' : Int.Internal.Linear.Poly),
Int.Internal.Linear.cooper_dvd_left_split ctx p₁ p₂ p₃ d k →
Int.Internal.Linear.cooper_dvd_left_split_dvd1_cert p₁ p' a ↑k = true → a ∣ Int.Internal.Linear.Poly.denote' ctx p' | null | true |
AnalyticOnNhd.is_constant_or_isOpen | Mathlib.Analysis.Complex.OpenMapping | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {U : Set E} {g : E → ℂ},
AnalyticOnNhd ℂ g U → IsPreconnected U → (∃ w, ∀ z ∈ U, g z = w) ∨ ∀ s ⊆ U, IsOpen s → IsOpen (g '' s) | The *open mapping theorem* for holomorphic functions, global version: if a function `g : E → ℂ`
is analytic on a connected set `U`, then either it is constant on `U`, or it is open on `U` (in the
sense that it maps any open set contained in `U` to an open set in `ℂ`). | true |
CochainComplex.HomComplex.Cocycle.isKernel._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m : ℤ) (hm : n + 1 = m) (s : CategoryTheory.Limits.Fork ((K.HomComplex L).d n m) 0),
CategoryTheory.CategoryStruct.comp
(AddCommGrpCat.ofHom
{ toFun := fun x => ⟨(Catego... | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.WorkItem.mk._flat_ctor | Init.Data.Format.Basic | Std.Format → ℤ → ℕ → Std.Format.WorkItem✝ | null | false |
CategoryTheory.Localization.Construction.LocQuiver.ctorIdx | Mathlib.CategoryTheory.Localization.Construction | {C : Type uC} →
{inst : CategoryTheory.Category.{uC', uC} C} →
{W : CategoryTheory.MorphismProperty C} → CategoryTheory.Localization.Construction.LocQuiver W → ℕ | null | false |
_private.Mathlib.RingTheory.Smooth.AdicCompletion.0.Algebra.FormallySmooth.liftAdicCompletionAux | Mathlib.RingTheory.Smooth.AdicCompletion | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing A] →
[inst_2 : Algebra R A] →
{S : Type u_3} →
[inst_3 : CommRing S] →
[inst_4 : Algebra R S] →
(I : Ideal S) → (A →ₐ[R] S ⧸ I) → [Algebra.FormallySmooth R A] → (m : ℕ) → A ... | (Implementation): Lift `A →ₐ[R] S ⧸ I` inductively to `A →ₐ[R] S ⧸ I ^ m` using formal
smoothness.
| true |
LieSubmodule.mk._flat_ctor | 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] →
(carrier : Set M) →
(∀ {a b : M}, a ∈ carrier → b ∈ carri... | null | false |
Int.isCompl_even_odd | Mathlib.Algebra.Order.Ring.Int | IsCompl {n | Even n} {n | Odd n} | null | true |
MeasureTheory.L1.SimpleFunc.setToL1SCLM._proof_2 | Mathlib.MeasureTheory.Integral.SetToL1.SimpleFunc | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
{T : Set α → E →L[ℝ] F} {C : ℝ},
MeasureTheory.DominatedFinMeasAdditive μ T C →
∀ (c : ℝ) (f ... | null | false |
CompHausLike.coproductIsColimit._proof_2 | Mathlib.Topology.Category.CompHausLike.Cartesian | ∀ {P : TopCat → Prop} (X Y : CompHausLike P) [inst : CompHausLike.HasProp P (↑X.toTop ⊕ ↑Y.toTop)]
(s : CategoryTheory.Limits.BinaryCofan X Y),
CategoryTheory.CategoryStruct.comp (CompHausLike.ofHom P { toFun := Sum.inl, continuous_toFun := ⋯ })
(CompHausLike.ofHom P
{ toFun := Sum.elim ⇑(CategoryTheo... | null | false |
_private.Mathlib.Lean.MessageData.ForExprs.0.Lean.MessageData.forExprsIn.go.match_7 | Mathlib.Lean.MessageData.ForExprs | (motive : Option Lean.PPContext → Sort u_1) →
(x : Option Lean.PPContext) →
((ppCtx : Lean.PPContext) → motive (some ppCtx)) → ((x : Option Lean.PPContext) → motive x) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.