name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Rep.coe_res_obj_ρ | Mathlib.RepresentationTheory.Rep | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Monoid G] {H : Type u} [inst_2 : Monoid H] (f : G →* H) (A : Rep k H)
(g : G), (Rep.ρ ((Action.res (ModuleCat k) f).obj A)) g = A.ρ (f g) |
_private.Mathlib.GroupTheory.Goursat.0.Subgroup.goursat._simp_1_15 | Mathlib.GroupTheory.Goursat | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
CategoryTheory.CostructuredArrow.isoMk._proof_1 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {T : D} {S : CategoryTheory.Functor C D}
{f f' : CategoryTheory.CostructuredArrow S T}, f.right = f'.right |
Cardinal.mk_freeAbelianGroup | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u) [Nonempty α], Cardinal.mk (FreeAbelianGroup α) = max (Cardinal.mk α) Cardinal.aleph0 |
_private.Batteries.Data.AssocList.0.Batteries.AssocList.foldlM.match_1.eq_2 | Batteries.Data.AssocList | ∀ {δ : Type u_4} {α : Type u_1} {β : Type u_2} (motive : δ → Batteries.AssocList α β → Sort u_3) (d : δ) (a : α) (b : β)
(es : Batteries.AssocList α β) (h_1 : (d : δ) → motive d Batteries.AssocList.nil)
(h_2 : (d : δ) → (a : α) → (b : β) → (es : Batteries.AssocList α β) → motive d (Batteries.AssocList.cons a b es)),
(match d, Batteries.AssocList.cons a b es with
| d, Batteries.AssocList.nil => h_1 d
| d, Batteries.AssocList.cons a b es => h_2 d a b es) =
h_2 d a b es |
Lean.FindMVar.visit | Lean.Util.FindMVar | (Lean.MVarId → Bool) → Lean.Expr → Lean.FindMVar.Visitor |
MeasureTheory.SimpleFunc.finite_range | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β), (Set.range ⇑f).Finite |
Std.HashMap.Raw.instInterOfBEqOfHashable | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → Inter (Std.HashMap.Raw α β) |
Lean.Syntax.SepArray._sizeOf_1 | Init.SizeOf | {sep : String} → Lean.Syntax.SepArray sep → ℕ |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.turanGraph_eq_top._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {a b : Prop}, (a = b) = (a ↔ b) |
MeasureTheory.Martingale.congr_simp | Mathlib.Probability.Martingale.BorelCantelli | ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : CompleteSpace E] (f f_1 : ι → Ω → E),
f = f_1 →
∀ (ℱ ℱ_1 : MeasureTheory.Filtration ι m0),
ℱ = ℱ_1 →
∀ (μ μ_1 : MeasureTheory.Measure Ω),
μ = μ_1 → MeasureTheory.Martingale f ℱ μ = MeasureTheory.Martingale f_1 ℱ_1 μ_1 |
_private.Mathlib.Data.Option.Basic.0.Option.pmap_bind_id_eq_pmap_join._proof_1_2 | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {x : Option (Option α)} (val : Option α), some val = x → x = some val |
Std.Internal.List.minKey!_eraseKey_eq_iff_beq_minKey!_eq_false | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α},
(Std.Internal.List.eraseKey k l).isEmpty = false →
(Std.Internal.List.minKey! (Std.Internal.List.eraseKey k l) = Std.Internal.List.minKey! l ↔
(k == Std.Internal.List.minKey! l) = false) |
liminf_min._auto_5 | Mathlib.Order.LiminfLimsup | Lean.Syntax |
AlgebraicGeometry.QuasiSeparated.quasiCompact_diagonal._autoParam | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | Lean.Syntax |
List.forall₂_refl | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {Rₐ : α → α → Prop} [Std.Refl Rₐ] (l : List α), List.Forall₂ Rₐ l l |
CategoryTheory.Precoherent.mk | Mathlib.CategoryTheory.Sites.Coherent.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C],
(∀ {B₁ B₂ : C} (f : B₂ ⟶ B₁) (α : Type) [Finite α] (X₁ : α → C) (π₁ : (a : α) → X₁ a ⟶ B₁),
CategoryTheory.EffectiveEpiFamily X₁ π₁ →
∃ β,
∃ (_ : Finite β),
∃ X₂ π₂,
CategoryTheory.EffectiveEpiFamily X₂ π₂ ∧
∃ i ι,
∀ (b : β),
CategoryTheory.CategoryStruct.comp (ι b) (π₁ (i b)) = CategoryTheory.CategoryStruct.comp (π₂ b) f) →
CategoryTheory.Precoherent C |
FreeAbelianGroup.support_neg | Mathlib.Algebra.FreeAbelianGroup.Finsupp | ∀ {X : Type u_1} (a : FreeAbelianGroup X), (-a).support = a.support |
_private.Mathlib.LinearAlgebra.ExteriorPower.Basic.0.exteriorPower.presentation.relations.match_1.eq_3 | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ (R : Type u_1) (ι : Type u_2) (M : Type u_3) (motive : exteriorPower.presentation.Rels R ι M → Sort u_4) (m : ι → M)
(i j : ι) (hm : m i = m j) (hij : i ≠ j)
(h_1 : (m : ι → M) → (i : ι) → (x y : M) → motive (exteriorPower.presentation.Rels.add m i x y))
(h_2 : (m : ι → M) → (i : ι) → (r : R) → (x : M) → motive (exteriorPower.presentation.Rels.smul m i r x))
(h_3 :
(m : ι → M) →
(i j : ι) → (hm : m i = m j) → (hij : i ≠ j) → motive (exteriorPower.presentation.Rels.alt m i j hm hij)),
(match exteriorPower.presentation.Rels.alt m i j hm hij with
| exteriorPower.presentation.Rels.add m i x y => h_1 m i x y
| exteriorPower.presentation.Rels.smul m i r x => h_2 m i r x
| exteriorPower.presentation.Rels.alt m i j hm hij => h_3 m i j hm hij) =
h_3 m i j hm hij |
_private.Mathlib.Combinatorics.Quiver.Path.Weight.0.PSigma.casesOn._arg_pusher | Mathlib.Combinatorics.Quiver.Path.Weight | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → rel t y → β_1 y) → motive t) t mk fun y h => f y) =
PSigma.casesOn t fun fst snd => mk fst snd fun y h => f y |
Stream'.WSeq.coeList | Mathlib.Data.WSeq.Basic | {α : Type u} → Coe (List α) (Stream'.WSeq α) |
_private.Mathlib.Combinatorics.SimpleGraph.ConcreteColorings.0.SimpleGraph.cycleGraph.tricoloring._simp_10 | Mathlib.Combinatorics.SimpleGraph.ConcreteColorings | ∀ {n : ℕ}, Even n = (n % 2 = 0) |
USize.toUInt8_add | Init.Data.UInt.Lemmas | ∀ (a b : USize), (a + b).toUInt8 = a.toUInt8 + b.toUInt8 |
Lean.Omega.IntList.sdiv_nil | Init.Omega.IntList | ∀ {g : ℤ}, Lean.Omega.IntList.sdiv [] g = [] |
SeminormedRing.noConfusion | Mathlib.Analysis.Normed.Ring.Basic | {P : Sort u} →
{α : Type u_5} →
{t : SeminormedRing α} →
{α' : Type u_5} → {t' : SeminormedRing α'} → α = α' → t ≍ t' → SeminormedRing.noConfusionType P t t' |
Array.foldr_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → β} {init : β}, Array.foldr f init #[] = init |
Denumerable.nat._proof_1 | Mathlib.Logic.Denumerable | ∀ (x : ℕ), ∃ a ∈ Encodable.decode x, Encodable.encode a = x |
_private.Mathlib.NumberTheory.Padics.Hensel.0.calc_eval_z'._proof_3 | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {z : ℤ_[p]},
‖↑((Polynomial.aeval z) F) / ↑((Polynomial.aeval z) (Polynomial.derivative F))‖ ≤ 1 →
‖↑((Polynomial.aeval z) (Polynomial.derivative F)) *
(↑((Polynomial.aeval z) F) / ↑((Polynomial.aeval z) (Polynomial.derivative F)))‖ ≤
1 |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_weight_mul_Lp_of_nonneg._simp_1_3 | Mathlib.Analysis.MeanInequalities | ∀ {α : Type u_1} {s : Finset α} {f : α → ENNReal}, (∑ x ∈ s, f x = ⊤) = ∃ a ∈ s, f a = ⊤ |
AddLECancellable.add_le_add_iff_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Add α] [AddLeftMono α] {a b c : α},
AddLECancellable a → (a + b ≤ a + c ↔ b ≤ c) |
Representation.linHom.invariantsEquivRepHom._proof_5 | Mathlib.RepresentationTheory.Invariants | ∀ {k : Type u_1} [inst : CommRing k] {G : Type u_1} [inst_1 : Group G] (X Y : Rep k G)
(x x_1 : ↥(X.ρ.linHom Y.ρ).invariants) (g : G),
CategoryTheory.CategoryStruct.comp (X.ρ g) (ModuleCat.ofHom ↑(x + x_1)) =
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom ↑(x + x_1)) (Y.ρ g) |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds.0.Real.lt_tan._simp_1_5 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulStrictMono R] [MulPosStrictMono R]
[AddLeftStrictMono R] [AddLeftReflectLT R] {a : R}, (0 < a * a) = (a ≠ 0) |
Lean.IR.FnBody.body | Lean.Compiler.IR.Basic | Lean.IR.FnBody → Lean.IR.FnBody |
Int.Linear.Poly.norm | Init.Data.Int.Linear | Int.Linear.Poly → Int.Linear.Poly |
Module.Basis.extend._proof_3 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_2} {V : Type u_1} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
(hs : LinearIndepOn K id s), ⊤ ≤ Submodule.span K (Set.range ((hs.extend ⋯).restrict id)) |
MeasureTheory.analyticSet_range_of_polishSpace | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_3} [inst_1 : TopologicalSpace β] [PolishSpace β] {f : β → α},
Continuous f → MeasureTheory.AnalyticSet (Set.range f) |
Nat.toList_rio_eq_nil_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...n).toList = [] ↔ n = 0 |
CategoryTheory.Bicategory.LeftLift.IsAbsKan | Mathlib.CategoryTheory.Bicategory.Kan.IsKan | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} → {f : b ⟶ a} → {g : c ⟶ a} → CategoryTheory.Bicategory.LeftLift f g → Type (max (max u v) w) |
Std.DTreeMap.Internal.Impl.toListModel_balanceₘ | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
(Std.DTreeMap.Internal.Impl.balanceₘ k v l r).toListModel = l.toListModel ++ ⟨k, v⟩ :: r.toListModel |
CategoryTheory.Lax.StrongTrans.mkOfLax | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
(η : CategoryTheory.Lax.LaxTrans F G) → η.StrongCore → CategoryTheory.Lax.StrongTrans F G |
HomologicalComplex.cyclesIsoSc'_hom_iCycles | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i j k : ι) (hi : c.prev j = i) (hk : c.next j = k)
[inst_2 : K.HasHomology j] [inst_3 : (K.sc' i j k).HasHomology],
CategoryTheory.CategoryStruct.comp (K.cyclesIsoSc' i j k hi hk).hom (K.sc' i j k).iCycles = K.iCycles j |
Std.DTreeMap.Internal.Impl.contains_insert!_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {k : α} {v : β k}, Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.insert! k v t) = true |
_private.Mathlib.Data.Ordmap.Ordset.0.Ordnode.Valid'.node4L_lemma₃._proof_1_1 | Mathlib.Data.Ordmap.Ordset | ∀ {b c d : ℕ}, 2 * d ≤ b + c + 1 → b ≤ 3 * c → d ≤ 3 * c |
MulOpposite.instNatCast.eq_1 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NatCast R], MulOpposite.instNatCast = { natCast := fun n => MulOpposite.op ↑n } |
ENNReal.toReal_eq_toReal_iff | Mathlib.Data.ENNReal.Basic | ∀ (x y : ENNReal), x.toReal = y.toReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0 |
BitVec.rotateRight_eq_rotateRightAux_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {r : ℕ}, r < w → x.rotateRight r = x.rotateRightAux r |
MeasureTheory.Measure.InnerRegularWRT.rfl | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p : Set α → Prop}, μ.InnerRegularWRT p p |
Algebra.Extension.Cotangent.of_add | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
(w z : P.ker.Cotangent),
Algebra.Extension.Cotangent.of (w + z) = Algebra.Extension.Cotangent.of w + Algebra.Extension.Cotangent.of z |
Int.lcm_dvd | Init.Data.Int.Gcd | ∀ {a b : ℤ} {c : ℕ}, a ∣ ↑c → b ∣ ↑c → a.lcm b ∣ c |
CategoryTheory.Iso.mk.inj | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {hom : X ⟶ Y} {inv : Y ⟶ X}
{hom_inv_id :
autoParam (CategoryTheory.CategoryStruct.comp hom inv = CategoryTheory.CategoryStruct.id X)
CategoryTheory.Iso.hom_inv_id._autoParam}
{inv_hom_id :
autoParam (CategoryTheory.CategoryStruct.comp inv hom = CategoryTheory.CategoryStruct.id Y)
CategoryTheory.Iso.inv_hom_id._autoParam}
{hom_1 : X ⟶ Y} {inv_1 : Y ⟶ X}
{hom_inv_id_1 :
autoParam (CategoryTheory.CategoryStruct.comp hom_1 inv_1 = CategoryTheory.CategoryStruct.id X)
CategoryTheory.Iso.hom_inv_id._autoParam}
{inv_hom_id_1 :
autoParam (CategoryTheory.CategoryStruct.comp inv_1 hom_1 = CategoryTheory.CategoryStruct.id Y)
CategoryTheory.Iso.inv_hom_id._autoParam},
{ hom := hom, inv := inv, hom_inv_id := hom_inv_id, inv_hom_id := inv_hom_id } =
{ hom := hom_1, inv := inv_1, hom_inv_id := hom_inv_id_1, inv_hom_id := inv_hom_id_1 } →
hom = hom_1 ∧ inv = inv_1 |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)] [inst_1 : (i : ι) → PseudoEMetricSpace (β i)]
[inst_2 : Fintype ι], LipschitzWith 1 WithLp.ofLp |
Std.DTreeMap.ofList_equiv_foldl | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {l : List ((a : α) × β a)},
(Std.DTreeMap.ofList l cmp).Equiv (List.foldl (fun acc p => acc.insert p.fst p.snd) ∅ l) |
RingCon.instNonAssocSemiringQuotient._proof_3 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (c : RingCon R), Quotient.mk'' 1 = Quotient.mk'' 1 |
Finset.sup_image₂_right | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} [inst : DecidableEq γ] {f : α → β → γ} (s : Finset α)
(t : Finset β) [inst_1 : SemilatticeSup δ] [inst_2 : OrderBot δ] (g : γ → δ),
(Finset.image₂ f s t).sup g = t.sup fun y => s.sup fun x => g (f x y) |
Function.locallyFinsuppWithin.le_def | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : LE Y] [inst_2 : Zero Y]
{D₁ D₂ : Function.locallyFinsuppWithin U Y}, D₁ ≤ D₂ ↔ ⇑D₁ ≤ ⇑D₂ |
CategoryTheory.exactPairingUnit._proof_1 | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv |
ZNum.zneg_neg | Mathlib.Data.Num.ZNum | ∀ (n : PosNum), -ZNum.neg n = ZNum.pos n |
UInt8.add_mul | Init.Data.UInt.Lemmas | ∀ {a b c : UInt8}, (a + b) * c = a * c + b * c |
NonUnitalAlgHom.mk.injEq | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} [inst : Monoid R] [inst_1 : Monoid S] {φ : R →* S} {A : Type v} {B : Type w}
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : DistribMulAction R A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction S B] (toDistribMulActionHom : A →ₑ+[φ] B)
(map_mul' :
∀ (x y : A), toDistribMulActionHom.toFun (x * y) = toDistribMulActionHom.toFun x * toDistribMulActionHom.toFun y)
(toDistribMulActionHom_1 : A →ₑ+[φ] B)
(map_mul'_1 :
∀ (x y : A),
toDistribMulActionHom_1.toFun (x * y) = toDistribMulActionHom_1.toFun x * toDistribMulActionHom_1.toFun y),
({ toDistribMulActionHom := toDistribMulActionHom, map_mul' := map_mul' } =
{ toDistribMulActionHom := toDistribMulActionHom_1, map_mul' := map_mul'_1 }) =
(toDistribMulActionHom = toDistribMulActionHom_1) |
LeanSearchClient.SearchServer.query | LeanSearchClient.Syntax | LeanSearchClient.SearchServer → String → ℕ → Lean.MetaM (Array LeanSearchClient.SearchResult) |
Action.leftRegularTensorIso_inv_hom | Mathlib.CategoryTheory.Action.Monoidal | ∀ (G : Type u) [inst : Group G] (X : Action (Type u) G)
(a : (CategoryTheory.MonoidalCategoryStruct.tensorObj (Action.leftRegular G) (Action.trivial G X.V)).V),
(Action.leftRegularTensorIso G X).inv.hom a = (a.1, X.ρ a.1 a.2) |
ModuleCat.monoidalClosedHomEquiv._proof_2 | Mathlib.Algebra.Category.ModuleCat.Monoidal.Closed | ∀ {R : Type u_1} [inst : CommRing R] (M N P : ModuleCat R),
Function.RightInverse
(fun f =>
CategoryTheory.CategoryStruct.comp (β_ M N).hom (ModuleCat.ofHom (TensorProduct.lift (ModuleCat.Hom.hom₂ f))))
fun f =>
ModuleCat.ofHom₂
((TensorProduct.mk R ↑N ↑M).compr₂ (ModuleCat.Hom.hom (CategoryTheory.CategoryStruct.comp (β_ N M).hom f))) |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.eq_pow_of_pow_eq_one._simp_1_2 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (↑u = ↑v) = (u = v) |
Lean.Meta.RefinedDiscrTree.ModuleDiscrTreeRef.casesOn | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} →
{motive : Lean.Meta.RefinedDiscrTree.ModuleDiscrTreeRef α → Sort u} →
(t : Lean.Meta.RefinedDiscrTree.ModuleDiscrTreeRef α) →
((ref : IO.Ref (Lean.Meta.RefinedDiscrTree α)) → motive { ref := ref }) → motive t |
String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.instIteratorIdSearchStepOfBackwardPattern.match_1 | Init.Data.String.Pattern.Basic | {ρ : Type} →
(pat : ρ) →
(s : String.Slice) →
(motive :
Std.IterStep (Std.IterM Id (String.Slice.Pattern.SearchStep s)) (String.Slice.Pattern.SearchStep s) →
Sort u_1) →
(x : Std.IterStep (Std.IterM Id (String.Slice.Pattern.SearchStep s)) (String.Slice.Pattern.SearchStep s)) →
((it' : Std.IterM Id (String.Slice.Pattern.SearchStep s)) →
(p₁ p₂ : s.Pos) → motive (Std.IterStep.yield it' (String.Slice.Pattern.SearchStep.rejected p₁ p₂))) →
((it' : Std.IterM Id (String.Slice.Pattern.SearchStep s)) →
(p₁ p₂ : s.Pos) → motive (Std.IterStep.yield it' (String.Slice.Pattern.SearchStep.matched p₁ p₂))) →
(Unit → motive Std.IterStep.done) →
((it : Std.IterM Id (String.Slice.Pattern.SearchStep s)) → motive (Std.IterStep.skip it)) → motive x |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Presieve.ofArrows_of_unique.match_1_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {ι : Type u_3} [inst_1 : Unique ι] {Y : ι → C}
(f : (i : ι) → Y i ⟶ X) (motive : (Y_1 : C) → (x : Y_1 ⟶ X) → CategoryTheory.Presieve.singleton (f default) x → Prop)
(Y_1 : C) (x : Y_1 ⟶ X) (x_1 : CategoryTheory.Presieve.singleton (f default) x),
(∀ (a : Unit), motive (Y default) (f default) ⋯) → motive Y_1 x x_1 |
MvQPF.wrepr.eq_1 | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n},
MvQPF.wrepr = MvQPF.recF ((MvQPF.P F).wMk' ∘ MvQPF.repr) |
Lean.Meta.Grind.CongrTheoremCacheKey.mk | Lean.Meta.Tactic.Grind.Types | Lean.Expr → ℕ → Lean.Meta.Grind.CongrTheoremCacheKey |
Sym2.toFinset_ne_empty._simp_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} [inst : DecidableEq α] (z : Sym2 α), (z.toFinset = ∅) = False |
analyticOn_cexp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | AnalyticOn ℂ Complex.exp Set.univ |
AlgebraicGeometry.SpecMapRestrictBasicOpenIso._proof_7 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {R S : CommRingCat} (f : R ⟶ S) (r : ↑R),
CategoryTheory.CategoryStruct.comp
((AlgebraicGeometry.Spec S).isoOfEq ⋯ ≪≫
⋯.isoSpec ≪≫
AlgebraicGeometry.Scheme.Spec.mapIso
(IsLocalization.algEquiv (Submonoid.powers ((CommRingCat.Hom.hom f) r))
(Localization.Away ((CommRingCat.Hom.hom f) r))
↑((AlgebraicGeometry.Spec S).presheaf.obj
(Opposite.op
(PrimeSpectrum.basicOpen
((CommRingCat.Hom.hom f) r))))).toRingEquiv.toCommRingCatIso.op).hom
(CategoryTheory.Arrow.mk
(AlgebraicGeometry.Spec.map (CommRingCat.ofHom (Localization.awayMap (CommRingCat.Hom.hom f) r)))).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Arrow.mk (AlgebraicGeometry.Spec.map f ∣_ PrimeSpectrum.basicOpen r)).hom
(⋯.isoSpec ≪≫
AlgebraicGeometry.Scheme.Spec.mapIso
(IsLocalization.algEquiv (Submonoid.powers r) (Localization.Away r)
↑((AlgebraicGeometry.Spec R).presheaf.obj
(Opposite.op (PrimeSpectrum.basicOpen r)))).toRingEquiv.toCommRingCatIso.op).hom |
IntermediateField.LinearDisjoint.congr_simp | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (A A_1 : IntermediateField F E),
A = A_1 →
∀ (L : Type w) [inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E],
A.LinearDisjoint L = A_1.LinearDisjoint L |
Lean.Meta.Closure.Context._sizeOf_inst | Lean.Meta.Closure | SizeOf Lean.Meta.Closure.Context |
MeasureTheory.Measure.pi_caratheodory | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
(μ : (i : ι) → MeasureTheory.Measure (α i)),
MeasurableSpace.pi ≤ (MeasureTheory.OuterMeasure.pi fun i => (μ i).toOuterMeasure).caratheodory |
_private.Mathlib.GroupTheory.Congruence.Defs.0.Con.sSup_eq_conGen.match_1_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Mul M] (S : Set (Con M)) (x x_1 : M) (motive : (∃ c ∈ S, c x x_1) → Prop)
(x_2 : ∃ c ∈ S, c x x_1), (∀ (r : Con M) (hr : r ∈ S ∧ r x x_1), motive ⋯) → motive x_2 |
BooleanSubalgebra.coe_comap._simp_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_3} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] (L : BooleanSubalgebra β)
(f : BoundedLatticeHom α β), ⇑f ⁻¹' ↑L = ↑(BooleanSubalgebra.comap f L) |
_private.Std.Time.Date.Unit.Weekday.0.Std.Time.instReprWeekday.repr.match_1.splitter | Std.Time.Date.Unit.Weekday | (motive : Std.Time.Weekday → Sort u_1) →
(x : Std.Time.Weekday) →
(Unit → motive Std.Time.Weekday.monday) →
(Unit → motive Std.Time.Weekday.tuesday) →
(Unit → motive Std.Time.Weekday.wednesday) →
(Unit → motive Std.Time.Weekday.thursday) →
(Unit → motive Std.Time.Weekday.friday) →
(Unit → motive Std.Time.Weekday.saturday) → (Unit → motive Std.Time.Weekday.sunday) → motive x |
Aesop.GoalWithMVars.mk.sizeOf_spec | Aesop.Script.GoalWithMVars | ∀ (goal : Lean.MVarId) (mvars : Std.HashSet Lean.MVarId),
sizeOf { goal := goal, mvars := mvars } = 1 + sizeOf goal + sizeOf mvars |
continuous_mabs | Mathlib.Topology.Algebra.Order.Group | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [inst_2 : LinearOrder G] [IsOrderedMonoid G]
[OrderTopology G], Continuous mabs |
Lean.Meta.Simp.mkCast | Batteries.Lean.Meta.Simp | Lean.Meta.Simp.Result → Lean.Expr → Lean.MetaM Lean.Expr |
FintypeCat.Skeleton.incl._proof_2 | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y Z : FintypeCat.Skeleton} (f : X ⟶ Y) (g : Y ⟶ Z),
FintypeCat.homMk (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (FintypeCat.homMk f) (FintypeCat.homMk g) |
CategoryTheory.Precoverage.ZeroHypercover.singleton.congr_simp | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S T : C} (f f_1 : S ⟶ T)
(e_f : f = f_1) (hf : CategoryTheory.Presieve.singleton f ∈ J.coverings T),
CategoryTheory.Precoverage.ZeroHypercover.singleton f hf = CategoryTheory.Precoverage.ZeroHypercover.singleton f_1 ⋯ |
riemannianMetricVectorSpace._proof_1 | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ (F : Type u_1) [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F],
IsManifold (modelWithCornersSelf ℝ F) 1 F |
ArchimedeanClass.instLinearOrderedAddCommMonoidWithTop._proof_1 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] (x : ArchimedeanClass R),
⊤ + x = ⊤ |
ContinuousMap.HomotopyEquiv.piCongrRight._proof_2 | Mathlib.Topology.Homotopy.Equiv | ∀ {ι : Type u_2} {X : ι → Type u_3} {Y : ι → Type u_1} [inst : (i : ι) → TopologicalSpace (X i)]
[inst_1 : (i : ι) → TopologicalSpace (Y i)] (h : (i : ι) → ContinuousMap.HomotopyEquiv (X i) (Y i)),
(ContinuousMap.piMap fun i => (h i).toFun.comp (h i).invFun).Homotopic
(ContinuousMap.piMap fun i => ContinuousMap.id (Y i)) |
Int.add_le_add_left | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → ∀ (c : ℤ), c + a ≤ c + b |
Lean.Meta.Grind.SavedState.grind | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.SavedState → Lean.Meta.Grind.State |
ENNReal.holderConjugate_coe_iff | Mathlib.Data.Real.ConjExponents | ∀ {p q : NNReal}, (↑p).HolderConjugate ↑q ↔ p.HolderConjugate q |
AlgHom.restrictNormalAux._proof_10 | Mathlib.FieldTheory.Normal.Defs | ∀ {F : Type u_2} [inst : Field F] {K₁ : Type u_4} {K₂ : Type u_1} [inst_1 : Field K₁] [inst_2 : Field K₂]
[inst_3 : Algebra F K₁] [inst_4 : Algebra F K₂] (ϕ : K₁ →ₐ[F] K₂) (E : Type u_3) [inst_5 : Field E]
[inst_6 : Algebra F E] [inst_7 : Algebra E K₁] [inst_8 : Algebra E K₂] [inst_9 : IsScalarTower F E K₁]
[inst_10 : IsScalarTower F E K₂] [h : Normal F E] (x y : ↥(IsScalarTower.toAlgHom F E K₁).range),
ϕ ↑(x + y) ∈ (IsScalarTower.toAlgHom F E K₂).range |
Set.image_const_mul_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (a b c : α),
(fun x => a * x) '' Set.uIcc b c = Set.uIcc (a * b) (a * c) |
_private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProductBil._proof_4 | Mathlib.RingTheory.AdicCompletion.AsTensorProduct | ∀ {R : Type u_2} [inst : CommRing R] (I : Ideal R) (M : Type u_1) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
LinearMap.CompatibleSMul (AdicCompletion I M) (AdicCompletion I M) R (AdicCompletion I R) |
Plausible.Injective.testable | Mathlib.Testing.Plausible.Functions | {α : Type u} →
{β : Type v} →
(f : α → β) →
[I :
Plausible.Testable
(Plausible.NamedBinder "x"
(∀ (x : α), Plausible.NamedBinder "y" (∀ (y : α), Plausible.NamedBinder "H" (f x = f y → x = y))))] →
Plausible.Testable (Function.Injective f) |
CategoryTheory.Arrow.homMk.congr_simp | Mathlib.CategoryTheory.Retract | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} (u u_1 : f.left ⟶ g.left)
(e_u : u = u_1) (v v_1 : f.right ⟶ g.right) (e_v : v = v_1)
(w : CategoryTheory.CategoryStruct.comp u g.hom = CategoryTheory.CategoryStruct.comp f.hom v),
CategoryTheory.Arrow.homMk u v w = CategoryTheory.Arrow.homMk u_1 v_1 ⋯ |
Simplicial.«_aux_Mathlib_AlgebraicTopology_SimplicialObject_Basic___delab_app_Simplicial_term__⦋_⦌_1» | Mathlib.AlgebraicTopology.SimplicialObject.Basic | Lean.PrettyPrinter.Delaborator.Delab |
Matrix.isHermitian_add_transpose_self | Mathlib.LinearAlgebra.Matrix.Hermitian | ∀ {α : Type u_1} {n : Type u_4} [inst : AddCommMonoid α] [inst_1 : StarAddMonoid α] (A : Matrix n n α),
(A + A.conjTranspose).IsHermitian |
Mathlib.Tactic.introv | Mathlib.Tactic.Basic | Lean.ParserDescr |
AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot_symm_mk_mk | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (f p : Polynomial R),
(AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot I f).symm
((Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f}))
(Polynomial.map (Ideal.Quotient.mk I) p)) =
(Ideal.Quotient.mk (Ideal.map (AdjoinRoot.of f) I)) ((AdjoinRoot.mk f) p) |
hasSum_iff_tendsto_nat_of_nonneg | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {f : ℕ → ℝ},
(∀ (i : ℕ), 0 ≤ f i) →
∀ (r : ℝ), HasSum f r ↔ Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (nhds r) |
BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eq | Mathlib.Analysis.BoxIntegral.Partition.Filter | ∀ {ι : Type u_1} [inst : Fintype ι] {I : BoxIntegral.Box ι} {c : NNReal} (l : BoxIntegral.IntegrationParams)
(π₀ : BoxIntegral.Prepartition I),
π₀.distortion ≤ c →
π₀.compl.distortion ≤ c →
∀ (r : (ι → ℝ) → ↑(Set.Ioi 0)), ∃ π, l.MemBaseSet I c r π ∧ π.toPrepartition ≤ π₀ ∧ π.iUnion = π₀.iUnion |
Lean.Level.hasMVarEx | Lean.Level | Lean.Level → Bool |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.