name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Applicative.seqRight._default | Init.Prelude | {f : Type u → Type v} →
({α β : Type u} → (α → β) → f α → f β) →
({α β : Type u} → α → f β → f α) →
({α β : Type u} → f (α → β) → (Unit → f α) → f β) → {α β : Type u} → f α → (Unit → f β) → f β |
groupCohomology.exists_mul_galRestrict_of_norm_eq_one | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K L : Type} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L]
[inst_4 : IsGalois K L] [IsCyclic Gal(L/K)] {g : Gal(L/K)} {A : Type u_1} {B : Type u_2} [inst_6 : CommRing A]
[inst_7 : CommRing B] [inst_8 : Algebra A B] [inst_9 : Algebra A L] [inst_10 : Algebra A K] [inst_11 : Algebra B L]
[inst_12 : IsScalarTower A B L] [inst_13 : IsScalarTower A K L] [inst_14 : IsFractionRing A K] [IsDomain A]
[inst_16 : IsIntegralClosure B A L],
(∀ (x : Gal(L/K)), x ∈ Subgroup.zpowers g) →
∀ {η : B}, (Algebra.norm K) ((algebraMap B L) η) = 1 → ∃ ε, ε ≠ 0 ∧ η * ((galRestrict A K L B) g) ε = ε |
Nat.Primrec.below.comp | Mathlib.Computability.Primrec.Basic | ∀ {motive : (a : ℕ → ℕ) → Nat.Primrec a → Prop} {f g : ℕ → ℕ} (a : Nat.Primrec f) (a_1 : Nat.Primrec g),
Nat.Primrec.below a → motive f a → Nat.Primrec.below a_1 → motive g a_1 → Nat.Primrec.below ⋯ |
_private.Init.Data.UInt.Lemmas.0.USize.lt_of_lt_of_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a ≤ b) = (a.toNat ≤ b.toNat) |
CategoryTheory.Pretopology.toGrothendieck | Mathlib.CategoryTheory.Sites.Pretopology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
CategoryTheory.Pretopology C → CategoryTheory.GrothendieckTopology C |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.Context._sizeOf_1 | Lean.Meta.IndPredBelow | Lean.Meta.IndPredBelow.Context✝ → ℕ |
Lean.Omega.Fin.lt_or_gt_of_ne | Init.Omega.Int | ∀ {n : ℕ} {i j : Fin n}, i ≠ j → i < j ∨ i > j |
Field.lift_rank_mul_lift_sepDegree_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.Tower | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [Algebra.IsSeparable F E],
Cardinal.lift.{w, v} (Module.rank F E) * Cardinal.lift.{v, w} (Field.sepDegree E K) =
Cardinal.lift.{v, w} (Field.sepDegree F K) |
Matrix.blockDiagonalAddMonoidHom | Mathlib.Data.Matrix.Block | (m : Type u_2) →
(n : Type u_3) →
(o : Type u_4) →
(α : Type u_12) → [DecidableEq o] → [inst : AddZeroClass α] → (o → Matrix m n α) →+ Matrix (m × o) (n × o) α |
_private.Mathlib.CategoryTheory.Triangulated.TriangleShift.0.CategoryTheory.Pretriangulated.Triangle.shiftFunctor._simp_1 | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) |
QuaternionAlgebra.instStarRing._proof_3 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : CommRing R] (a b : QuaternionAlgebra R c₁ c₂ c₃), star (a + b) = star a + star b |
Lean.Lsp.DidChangeWatchedFilesParams.mk.injEq | Lean.Data.Lsp.Workspace | ∀ (changes changes_1 : Array Lean.Lsp.FileEvent),
({ changes := changes } = { changes := changes_1 }) = (changes = changes_1) |
_private.Init.Data.List.Basic.0.List.lengthTRAux.match_1.splitter | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → ℕ → Sort u_2) →
(x : List α) →
(x_1 : ℕ) →
((n : ℕ) → motive [] n) → ((head : α) → (as : List α) → (n : ℕ) → motive (head :: as) n) → motive x x_1 |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.NewDecl.below.noConfusion | Lean.Meta.IndPredBelow | {P : Sort u} →
{decl : Lean.LocalDecl} →
{indName : Lean.Name} →
{vars : Array Lean.FVarId} →
{decl' : Lean.LocalDecl} →
{indName' : Lean.Name} →
{vars' : Array Lean.FVarId} →
Lean.Meta.IndPredBelow.NewDecl.below✝ decl indName vars =
Lean.Meta.IndPredBelow.NewDecl.below✝¹ decl' indName' vars' →
(decl = decl' → indName = indName' → vars = vars' → P) → P |
Action.instConcreteCategoryHomSubtypeV._proof_7 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (G : Type u_3) [inst_1 : Monoid G]
{FV : V → V → Type u_5} {CV : V → Type u_4} [inst_2 : (X Y : V) → FunLike (FV X Y) (CV X) (CV Y)]
[inst_3 : CategoryTheory.ConcreteCategory V FV] {X Y Z : Action V G} (x : X ⟶ Y) (x_1 : Y ⟶ Z) (x_2 : CV X.V),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp x.hom x_1.hom)) x_2 =
(CategoryTheory.ConcreteCategory.hom x_1.hom) ((CategoryTheory.ConcreteCategory.hom x.hom) x_2) |
SemiNormedGrp._sizeOf_1 | Mathlib.Analysis.Normed.Group.SemiNormedGrp | SemiNormedGrp → ℕ |
Matrix.SpecialLinearGroup.coe_int_neg | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
[inst_3 : Fact (Even (Fintype.card n))] (g : Matrix.SpecialLinearGroup n ℤ),
(Matrix.SpecialLinearGroup.map (Int.castRingHom R)) (-g) = -(Matrix.SpecialLinearGroup.map (Int.castRingHom R)) g |
Subgroup.saturated_iff_npow | Mathlib.GroupTheory.Subgroup.Saturated | ∀ {G : Type u_1} [inst : Monoid G] {H : Submonoid G}, H.PowSaturated ↔ ∀ (n : ℕ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H |
UpperSet.erase._proof_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] (s : UpperSet α) (a : α), IsUpperSet (↑s \ ↑(LowerSet.Iic a)) |
HVertexOperator.coeff._proof_5 | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_2} [inst : PartialOrder Γ] {R : Type u_1} {W : Type u_3} [inst_1 : CommRing R] [inst_2 : AddCommGroup W]
[inst_3 : Module R W], SMulCommClass R R (HahnModule Γ R W) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.maxKey!_modify._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) |
CategoryTheory.GrothendieckTopology.W_of_preservesSheafification | Mathlib.CategoryTheory.Sites.PreservesSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_1}
{B : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_1} A] [inst_2 : CategoryTheory.Category.{v_2, u_2} B]
(F : CategoryTheory.Functor A B) [J.PreservesSheafification F] {P₁ P₂ : CategoryTheory.Functor Cᵒᵖ A} (f : P₁ ⟶ P₂),
J.W f → J.W (CategoryTheory.Functor.whiskerRight f F) |
DFinsupp.instDecidableEq.match_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → DecidableEq (β i)] (f g : Π₀ (i : ι), β i)
(motive : (f.support = g.support ∧ ∀ i ∈ f.support, f i = g i) → Prop)
(x : f.support = g.support ∧ ∀ i ∈ f.support, f i = g i),
(∀ (h₁ : f.support = g.support) (h₂ : ∀ i ∈ f.support, f i = g i), motive ⋯) → motive x |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.isoMk₅._proof_5 | Mathlib.CategoryTheory.ComposableArrows.Basic | ¬2 + 1 ≤ 5 → False |
Std.DHashMap.Const.get_alter_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β} {h : k ∈ Std.DHashMap.Const.alter m k f},
Std.DHashMap.Const.get (Std.DHashMap.Const.alter m k f) k h = (f (Std.DHashMap.Const.get? m k)).get ⋯ |
_private.Mathlib.Data.Nat.Choose.Sum.0.Nat.sum_range_choose_halfway._proof_1_1 | Mathlib.Data.Nat.Choose.Sum | ∀ (m : ℕ), m + 1 ≤ 2 * m + 1 + 1 |
Complex.sin.eq_1 | Mathlib.Analysis.Complex.Trigonometric | ∀ (z : ℂ), Complex.sin z = (Complex.exp (-z * Complex.I) - Complex.exp (z * Complex.I)) * Complex.I / 2 |
CategoryTheory.SimplicialObject.Augmented.w₀_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject.Augmented C} (f : X ⟶ Y)
{Z : C} (h : ((CategoryTheory.SimplicialObject.const C).obj Y.right).obj (Opposite.op (SimplexCategory.mk 0)) ⟶ Z),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.SimplicialObject.Augmented.drop.map f).app (Opposite.op (SimplexCategory.mk 0)))
(CategoryTheory.CategoryStruct.comp (Y.hom.app (Opposite.op (SimplexCategory.mk 0))) h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (X.hom.app (Opposite.op (SimplexCategory.mk 0)))
(CategoryTheory.SimplicialObject.Augmented.point.map f))
h |
InvolutiveNeg.recOn | Mathlib.Algebra.Group.Defs | {A : Type u_2} →
{motive : InvolutiveNeg A → Sort u} →
(t : InvolutiveNeg A) →
([toNeg : Neg A] → (neg_neg : ∀ (x : A), - -x = x) → motive { toNeg := toNeg, neg_neg := neg_neg }) → motive t |
Polynomial.Splits.X._simp_1 | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Semiring R], Polynomial.X.Splits = True |
contDiffOn_congr | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f f₁ : E → F} {n : WithTop ℕ∞}, (∀ x ∈ s, f₁ x = f x) → (ContDiffOn 𝕜 n f₁ s ↔ ContDiffOn 𝕜 n f s) |
translate_add' | Mathlib.Algebra.Group.Translate | ∀ {α : Type u_2} {G : Type u_5} [inst : AddCommGroup G] (a b : G) (f : G → α),
translate (a + b) f = translate b (translate a f) |
compHausToTop.createsLimits | Mathlib.Topology.Category.CompHaus.Basic | CategoryTheory.CreatesLimits compHausToTop |
_private.Mathlib.CategoryTheory.GradedObject.Unitor.0.CategoryTheory.GradedObject.mapBifunctor_triangle._simp_1_1 | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h |
HomologicalComplex.HomologySequence.snakeInput._proof_27 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
CategoryTheory.ShortComplex.π₃.PreservesZeroMorphisms |
Lean.Elab.Tactic.Conv.evalNestedTactic | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.Tactic |
Lean.Elab.Tactic.Conv.evalFirst._regBuiltin.Lean.Elab.Tactic.Conv.evalFirst_1 | Lean.Elab.Tactic.Conv.Basic | IO Unit |
Lean.Elab.Term.Do.Alt.noConfusionType | Lean.Elab.Do.Legacy | Sort u → {σ : Type} → Lean.Elab.Term.Do.Alt σ → {σ' : Type} → Lean.Elab.Term.Do.Alt σ' → Sort u |
Lean.Elab.Term.Do.ToTerm.returnToTerm | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Elab.Term.Do.ToTerm.M Lean.Syntax |
MeasureTheory.FiniteMeasure.normalize_eq_inv_mass_smul_of_nonzero | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : Nonempty Ω] {m0 : MeasurableSpace Ω} (μ : MeasureTheory.FiniteMeasure Ω),
μ ≠ 0 → μ.normalize.toFiniteMeasure = μ.mass⁻¹ • μ |
Lean.PrettyPrinter.Formatter.Context | Lean.PrettyPrinter.Formatter | Type |
List.SortedLE.of_map_toDual | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {l : List α}, l.SortedLE → (List.map (⇑OrderDual.toDual) l).SortedGE |
Finset.sum_singleton | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] (f : ι → M) (a : ι), ∑ x ∈ {a}, f x = f a |
Nat.mul_le_add_right | Init.Data.Nat.Lemmas | ∀ {m k n : ℕ}, k * m ≤ m + n ↔ (k - 1) * m ≤ n |
Std.DTreeMap.get?_inter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α}, (t₁ ∩ t₂).get? k = if k ∈ t₂ then t₁.get? k else none |
MeasureTheory.StronglyAdapted.integrable_upcrossingsBefore | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {a b : ℝ} {f : ℕ → Ω → ℝ} {N : ℕ}
{ℱ : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.StronglyAdapted ℱ f →
a < b → MeasureTheory.Integrable (fun ω => ↑(MeasureTheory.upcrossingsBefore a b f N ω)) μ |
Lean.Lsp.DocumentSymbol.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{sym sym' : Lean.Lsp.DocumentSymbolAux Lean.Lsp.DocumentSymbol} →
Lean.Lsp.DocumentSymbol.mk sym = Lean.Lsp.DocumentSymbol.mk sym' → (sym = sym' → P) → P |
Fin.reverseInduction._proof_3 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (i : Fin (n + 1)), ↑i ≤ 0 → ¬↑i = 0 → False |
Filter.isBoundedUnder_const | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} [Std.Refl r] {l : Filter β} {a : α},
Filter.IsBoundedUnder r l fun x => a |
CategoryTheory.Localization.Monoidal.instLiftingLocalizedMonoidalToMonoidalCategoryCompTensorRightObjFunctorFlipTensorBifunctor | Mathlib.CategoryTheory.Localization.Monoidal.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] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : W.IsMonoidal] →
[inst_4 : L.IsLocalization W] →
{unit : D} →
(ε : L.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ unit) →
(Y : C) →
CategoryTheory.Localization.Lifting
(CategoryTheory.Localization.Monoidal.toMonoidalCategory L W ε) W
((CategoryTheory.MonoidalCategory.tensorRight Y).comp
(CategoryTheory.Localization.Monoidal.toMonoidalCategory L W ε))
((CategoryTheory.Localization.Monoidal.tensorBifunctor L W ε).flip.obj
((CategoryTheory.Localization.Monoidal.toMonoidalCategory L W ε).obj Y)) |
WithTop.Ioc_coe_top | Mathlib.Order.Interval.Finset.Defs | ∀ (α : Type u_1) [inst : PartialOrder α] [inst_1 : OrderTop α] [inst_2 : LocallyFiniteOrder α] (a : α),
Finset.Ioc ↑a ⊤ = Finset.insertNone (Finset.Ioi a) |
Std.Internal.UV.System.PasswdInfo._sizeOf_1 | Std.Internal.UV.System | Std.Internal.UV.System.PasswdInfo → ℕ |
UInt32.reduceOfNat._regBuiltin.UInt32.reduceOfNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2998934274._hygCtx._hyg.340 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
CStarMatrix.conjTranspose_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Star A] (M : CStarMatrix m n A) (i : n) (j : m),
M.conjTranspose i j = star (M j i) |
CategoryTheory.MonoidalOpposite.unmopEquiv_functor_map | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᴹᵒᵖ} (f : X ⟶ Y),
(CategoryTheory.MonoidalOpposite.unmopEquiv C).functor.map f = f.unmop |
CategoryTheory.Iso.retract | Mathlib.CategoryTheory.Retract | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (X ≅ Y) → CategoryTheory.Retract X Y |
Qq.Impl.floatQMatch | Qq.Match | Lean.TSyntax `Lean.Parser.Term.doSeqIndent →
Lean.Term → StateT (List (Lean.TSyntax `Lean.Parser.Term.doSeqItem)) Lean.MacroM Lean.Term |
Lean.instInhabitedNoConfusionInfo.default | Lean.AuxRecursor | Lean.NoConfusionInfo |
_private.Mathlib.Tactic.NormNum.Irrational.0.Tactic.NormNum.evalIrrationalRpow._proof_1 | Mathlib.Tactic.NormNum.Irrational | ∀ (gy : Q(ℕ)), «$gy» =Q 1 |
_private.Mathlib.Analysis.Calculus.ContDiff.Operations.0.ContDiff.div._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : WithTop ℕ∞}, ContDiff 𝕜 n f = ∀ (x : E), ContDiffAt 𝕜 n f x |
MulAction.smul_zpow_movedBy_eq_of_commute | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {g h : G},
Commute g h → ∀ (j : ℤ), h ^ j • (MulAction.fixedBy α g)ᶜ = (MulAction.fixedBy α g)ᶜ |
instAddRightCancelSemigroupColex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : AddRightCancelSemigroup α] → AddRightCancelSemigroup (Colex α) |
_private.Mathlib.Algebra.Group.Submonoid.Operations.0.Submonoid.pi_empty._simp_1_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → MulOneClass (M i)] (I : Set ι) {S : (i : ι) → Submonoid (M i)}
{p : (i : ι) → M i}, (p ∈ Submonoid.pi I S) = ∀ i ∈ I, p i ∈ S i |
Std.HashMap.ofList_cons | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {k : α} {v : β} {tl : List (α × β)},
Std.HashMap.ofList ((k, v) :: tl) = (∅.insert k v).insertMany tl |
Lean.Meta.Grind.AC.DiseqCnstrProof.simp_ac.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Types | ∀ (lhs : Bool) (s : Lean.Grind.AC.Seq) (c₁ : Lean.Meta.Grind.AC.EqCnstr) (c₂ : Lean.Meta.Grind.AC.DiseqCnstr),
sizeOf (Lean.Meta.Grind.AC.DiseqCnstrProof.simp_ac lhs s c₁ c₂) = 1 + sizeOf lhs + sizeOf s + sizeOf c₁ + sizeOf c₂ |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.atLeastTwo_eq_halfAdder | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add | ∀ (lhsBit rhsBit carry : Bool), lhsBit.atLeastTwo rhsBit carry = ((lhsBit ^^ rhsBit) && carry || lhsBit && rhsBit) |
BoundedContinuousFunction.mem_charPoly | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | ∀ {V : Type u_1} {W : Type u_2} [inst : AddCommGroup V] [inst_1 : Module ℝ V] [inst_2 : TopologicalSpace V]
[inst_3 : AddCommGroup W] [inst_4 : Module ℝ W] [inst_5 : TopologicalSpace W] {e : AddChar ℝ Circle}
{L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ} {he : Continuous ⇑e} {hL : Continuous fun p => (L p.1) p.2}
(f : BoundedContinuousFunction V ℂ),
f ∈ BoundedContinuousFunction.charPoly he hL ↔ ∃ w, ⇑f = fun x => ∑ a ∈ w.support, w a * ↑(e ((L x) a)) |
OreLocalization.instSemiring._proof_2 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] (n : ℕ),
(n + 1).unaryCast = n.unaryCast + 1 |
_private.Mathlib.Topology.Connected.Clopen.0.isPreconnected_iff_subset_of_disjoint._simp_1_1 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {s t : Set α}, (¬s ⊆ t) = ∃ a ∈ s, a ∉ t |
MeasureTheory.Measure.pi_Ioc_ae_eq_pi_Icc | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → PartialOrder (α i)] [∀ (i : ι), MeasureTheory.NoAtoms (μ i)] {s : Set ι} {f g : (i : ι) → α i},
(s.pi fun i => Set.Ioc (f i) (g i)) =ᵐ[MeasureTheory.Measure.pi μ] s.pi fun i => Set.Icc (f i) (g i) |
Hyperreal.isSt_iff | Mathlib.Analysis.Real.Hyperreal | ∀ {x : ℝ*} {r : ℝ}, x.IsSt r ↔ 0 ≤ ArchimedeanClass.mk x ∧ ArchimedeanClass.stdPart x = r |
Lean.Meta.Grind.instBEqCongrKey._private_1 | Lean.Meta.Tactic.Grind.Types | {enodeMap : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodeMap → Lean.Meta.Grind.CongrKey enodeMap → Bool |
ContinuousAffineEquiv.symm_apply_eq | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁]
[inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂] [inst_8 : TopologicalSpace P₂]
(e : P₁ ≃ᴬ[k] P₂) {x : P₂} {y : P₁}, e.symm x = y ↔ x = e y |
_private.Std.Data.HashSet.RawLemmas.0.Std.HashSet.Raw.Equiv.symm.match_1_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u_1} {m₁ m₂ : Std.HashSet.Raw α} (motive : m₁.Equiv m₂ → Prop) (x : m₁.Equiv m₂),
(∀ (h : m₁.inner.Equiv m₂.inner), motive ⋯) → motive x |
_private.Init.Data.List.MinMaxIdx.0.List.maxIdxOn_eq_zero_iff._simp_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {le : LE α} {a b : α}, (a ≤ b) = (b ≤ a) |
Quiver.Path.vertices_comp_get_length_eq._auto_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | Lean.Syntax |
Std.HashSet.Equiv.inter_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₂.Equiv m₃ → (m₁ ∩ m₂).Equiv (m₁ ∩ m₃) |
DirectLimit.instAddGroup._proof_12 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → AddGroup (G i)] [∀ (i j : ι) (h : i ≤ j), AddMonoidHomClass (T h) (G i) (G j)] (n : ℕ) (x x_1 : ι)
(x_2 : x ≤ x_1) (x_3 : G x), (f x x_1 x_2) (↑n.succ • x_3) = ↑n.succ • (f x x_1 x_2) x_3 |
Ordinal.type_pUnit | Mathlib.SetTheory.Ordinal.Basic | Ordinal.type emptyRelation = 1 |
_private.Lean.Compiler.LCNF.CompatibleTypes.0.Lean.Compiler.LCNF.InferType.Pure.compatibleTypesFull._sparseCasesOn_6 | Lean.Compiler.LCNF.CompatibleTypes | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
(Nat.hasNotBit 1152 t.ctorIdx → motive t) → motive t |
Equicontinuous | Mathlib.Topology.UniformSpace.Equicontinuity | {ι : Type u_1} →
{X : Type u_3} → {α : Type u_6} → [tX : TopologicalSpace X] → [uα : UniformSpace α] → (ι → X → α) → Prop |
SimpleGraph.binomialRandom_one | Mathlib.Probability.Combinatorics.BinomialRandomGraph.Defs | ∀ (V : Type u_1) [Countable V], SimpleGraph.binomialRandom V 1 = MeasureTheory.Measure.dirac ⊤ |
CommRing.directSumGCommRing | Mathlib.Algebra.DirectSum.Ring | (ι : Type u_1) → {R : Type u_2} → [inst : AddCommMonoid ι] → [inst_1 : CommRing R] → DirectSum.GCommRing fun x => R |
Std.Packages.LinearOrderOfOrdArgs.min_eq | Init.Data.Order.PackageFactories | ∀ {α : Type u} (self : Std.Packages.LinearOrderOfOrdArgs α),
let this := self.ord;
let this_1 := self.le;
let this_2 := self.min;
have this_3 := ⋯;
∀ (a b : α), a ⊓ b = if (compare a b).isLE = true then a else b |
CochainComplex.HomComplex.Cocycle.coe_sub | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} {n : ℤ} (z₁ z₂ : CochainComplex.HomComplex.Cocycle F G n), ↑(z₁ - z₂) = ↑z₁ - ↑z₂ |
Perfection.quotientMulEquiv._proof_5 | Mathlib.RingTheory.Teichmuller | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] (I : Ideal R) [inst_2 : CharP (R ⧸ I) p]
[inst_3 : IsAdicComplete I R],
(Perfection.liftMonoidHom p (Perfection (R ⧸ I) p) (R ⧸ I)).symm
((Perfection.mapMonoidHom p ↑(Ideal.Quotient.mk I)).comp
((Perfection.liftMonoidHom p (Perfection (R ⧸ I) p) R) (Perfection.teichmuller p I))) =
(Perfection.liftMonoidHom p (Perfection (R ⧸ I) p) (R ⧸ I)).symm (MonoidHom.id (Perfection (R ⧸ I) p)) |
toPrev.eq_1 | Mathlib.Algebra.Homology.BifunctorHomotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} (j : ι), toPrev j = AddMonoidHom.mk' (fun f => f j (c.prev j)) ⋯ |
cauchy_davenport_of_isMulTorsionFree | Mathlib.Combinatorics.Additive.CauchyDavenport | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : Group G] [IsMulTorsionFree G] {s t : Finset G},
s.Nonempty → t.Nonempty → s.card + t.card - 1 ≤ (s * t).card |
Std.HashMap.Raw.beq | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → [BEq β] → Std.HashMap.Raw α β → Std.HashMap.Raw α β → Bool |
HEq.ndrecOn | Init.Core | {α : Sort u2} → {a : α} → {motive : {β : Sort u2} → β → Sort u1} → {β : Sort u2} → {b : β} → a ≍ b → motive a → motive b |
Finset.Nontrivial.ne_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, s.Nontrivial → s ≠ {a} |
conjneg_ne_one | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f : G → R},
conjneg f ≠ 1 ↔ f ≠ 1 |
lTensor.inverse_of_rightInverse_apply | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module R Q]
(hfg : Function.Exact ⇑f ⇑g) {h : P → N} (hgh : Function.RightInverse h ⇑g) (y : TensorProduct R Q N),
(lTensor.inverse_of_rightInverse Q hfg hgh) ((LinearMap.lTensor Q g) y) = Submodule.Quotient.mk y |
CategoryTheory.cartesianClosedOfReflective'._proof_3 | Mathlib.CategoryTheory.Monoidal.Closed.Ideal | ∀ {C : Type u_3} {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (i : CategoryTheory.Functor D C)
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.Reflective i]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] (B : D) {X Y : D} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.MonoidalCategory.tensorLeft B).comp i).map f)
(CategoryTheory.asIso (CategoryTheory.CartesianMonoidalCategory.prodComparison i B Y)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.asIso (CategoryTheory.CartesianMonoidalCategory.prodComparison i B X)).hom
((i.comp (CategoryTheory.MonoidalCategory.tensorLeft (i.obj B))).map f) |
Lean.Widget.InfoPopup.rec | Lean.Server.FileWorker.WidgetRequests | {motive : Lean.Widget.InfoPopup → Sort u} →
((type exprExplicit : Option Lean.Widget.CodeWithInfos) →
(doc : Option String) → motive { type := type, exprExplicit := exprExplicit, doc := doc }) →
(t : Lean.Widget.InfoPopup) → motive t |
Lean.Lsp.DiagnosticSeverity.error.sizeOf_spec | Lean.Data.Lsp.Diagnostics | sizeOf Lean.Lsp.DiagnosticSeverity.error = 1 |
LTSeries.last_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (p : LTSeries α) (f : α → β)
(hf : StrictMono f), RelSeries.last (p.map f hf) = f (RelSeries.last p) |
Lean.Meta.Match.Extension.Entry.mk | Lean.Meta.Match.MatcherInfo | Lean.Name → Lean.Meta.MatcherInfo → Lean.Meta.Match.Extension.Entry |
NonUnitalStarSubalgebra.prod | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : StarRing A] →
[inst_3 : Module R A] →
[inst_4 : NonUnitalSemiring B] →
[inst_5 : StarRing B] →
[inst_6 : Module R B] →
NonUnitalStarSubalgebra R A → NonUnitalStarSubalgebra R B → NonUnitalStarSubalgebra R (A × B) |
NonUnitalCommCStarAlgebra.toIsScalarTower | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [self : NonUnitalCommCStarAlgebra A], IsScalarTower ℂ A A |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.