name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
TensorProduct.leftModule | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
{R'' : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : Semiring R''] →
{M : Type u_7} →
{N : Type u_8} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R'' M] →
[inst_5 : Module R M] →
[inst_6 : Module R N] → [SMulCommClass R R'' M] → Module R'' (TensorProduct R M N) |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.append_right_inj._simp_1_1 | Init.Data.ByteArray.Lemmas | ∀ {x y : ByteArray}, (x = y) = (x.data = y.data) |
QuotientGroup.comapMk'OrderIso._proof_2 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [hn : N.Normal] (x : { H // N ≤ H }),
N ≤ Subgroup.comap (QuotientGroup.mk' N) (Subgroup.map (QuotientGroup.mk' N) ↑x) |
Std.ExtHashSet.get?_eq_some_of_contains | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : LawfulBEq α] {k : α},
m.contains k = true → m.get? k = some k |
RingCon.instZeroQuotient | Mathlib.RingTheory.Congruence.Defs | {R : Type u_1} → [inst : AddZeroClass R] → [inst_1 : Mul R] → (c : RingCon R) → Zero c.Quotient |
OrderDual.ofDual_inj | Mathlib.Order.OrderDual | ∀ {α : Type u_1} {a b : αᵒᵈ}, OrderDual.ofDual a = OrderDual.ofDual b ↔ a = b |
Lean.DefinitionVal._sizeOf_inst | Lean.Declaration | SizeOf Lean.DefinitionVal |
IterateMulAct.mk._flat_ctor | Mathlib.GroupTheory.GroupAction.IterateAct | {α : Type u_1} → {f : α → α} → ℕ → IterateMulAct f |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitLambdaLet.go._sparseCasesOn_1 | Lean.Meta.LetToHave | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 320 t.ctorIdx → motive t) → motive t |
Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.symm | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.RingEqCnstr → Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof |
_private.Init.Data.Range.Polymorphic.SInt.0.ISize.instUpwardEnumerable._proof_3 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : ISize), i.toInt + ↑n ≤ ISize.maxValueSealed✝.toInt → i.toInt + ↑n ≤ ISize.maxValue.toInt |
add_pow_eq_mul_pow_add_pow_div_char | Mathlib.Algebra.CharP.Lemmas | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (p n : ℕ) [hp : Fact (Nat.Prime p)] [CharP R p],
(x + y) ^ n = (x + y) ^ (n % p) * (x ^ p + y ^ p) ^ (n / p) |
NNRat.cast_inj | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_3} [inst : DivisionSemiring α] [CharZero α] {p q : ℚ≥0}, ↑p = ↑q ↔ p = q |
List.isPrefixOfAux_toArray_succ'._proof_2 | Init.Data.List.ToArray | ∀ {α : Type u_1} (l₁ l₂ : List α),
l₁.length ≤ l₂.length → ∀ (i : ℕ), (List.drop (i + 1) l₁).toArray.size ≤ (List.drop (i + 1) l₂).toArray.size |
groupHomology.shortComplexH2_g | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G),
(groupHomology.shortComplexH2 A).g = groupHomology.d₂₁ A |
Aesop.Frontend.BuilderOption.rec | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.BuilderOption → Sort u} →
((names : Array Lean.Name) → motive (Aesop.Frontend.BuilderOption.immediate names)) →
((imode : Aesop.IndexingMode) → motive (Aesop.Frontend.BuilderOption.index imode)) →
((stx : Lean.Term) → motive (Aesop.Frontend.BuilderOption.pattern stx)) →
((pats : Array Aesop.CasesPattern) → motive (Aesop.Frontend.BuilderOption.casesPatterns pats)) →
((md : Lean.Meta.TransparencyMode) →
(alsoForIndex : Bool) → motive (Aesop.Frontend.BuilderOption.transparency md alsoForIndex)) →
(t : Aesop.Frontend.BuilderOption) → motive t |
_private.Mathlib.Algebra.Module.LocalizedModule.Submodule.0.IsLocalizedModule.toLocalizedQuotient'._simp_2 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{x y : M}, (Submodule.Quotient.mk x = Submodule.Quotient.mk y) = (x - y ∈ p) |
CancelCommMonoidWithZero.toIsLeftCancelMulZero | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_2} (self : CancelCommMonoidWithZero M₀), IsLeftCancelMulZero M₀ |
Std.TreeMap.Raw.WF.insertManyIfNewUnit | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {ρ : Type u_1} [inst : ForIn Id ρ α] {l : ρ}
{t : Std.TreeMap.Raw α Unit cmp}, t.WF → (t.insertManyIfNewUnit l).WF |
antilipschitzWith_inv_iff | Mathlib.Analysis.Normed.Group.Uniform | ∀ {α : Type u_4} {E : Type u_5} [inst : SeminormedCommGroup E] [inst_1 : PseudoEMetricSpace α] {K : NNReal} {f : α → E},
AntilipschitzWith K f⁻¹ ↔ AntilipschitzWith K f |
Pi.single_mul_right | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] [inst_1 : DecidableEq ι] {i : ι}
{f : (i : ι) → α i} (a : α i), Pi.single i (f i * a) = f * Pi.single i a |
Batteries.BEqCmp.cmp_iff_beq | Batteries.Classes.Deprecated | ∀ {α : Type u_1} {inst : BEq α} {cmp : α → α → Ordering} [self : Batteries.BEqCmp cmp] {x y : α},
cmp x y = Ordering.eq ↔ (x == y) = true |
CategoryTheory.Bicategory.Adj.Hom₂.ctorIdx | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | {B : Type u} →
{inst : CategoryTheory.Bicategory B} →
{a b : CategoryTheory.Bicategory.Adj B} → {α β : a ⟶ b} → CategoryTheory.Bicategory.Adj.Hom₂ α β → ℕ |
ByteArray.Iterator.hasNext.eq_1 | Init.Data.ByteArray.Basic | ∀ (arr : ByteArray) (i : ℕ), { array := arr, idx := i }.hasNext = decide (i < arr.size) |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_rio_add_add_eq_append._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m : ℕ}, ¬0 ≤ m → False |
Subgroup.fintypeBot | Mathlib.Algebra.Group.Subgroup.Finite | {G : Type u_1} → [inst : Group G] → Fintype ↥⊥ |
LE.le.isOpenPosMeasure | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} {μ ν : MeasureTheory.Measure X}
[μ.IsOpenPosMeasure], μ ≤ ν → ν.IsOpenPosMeasure |
Lean.Grind.GrobnerConfig.locals._inherited_default | Init.Grind.Config | Bool |
NNNorm | Mathlib.Analysis.Normed.Group.Defs | Type u_8 → Type u_8 |
FirstOrder.Language.Hom.casesOn | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] →
[inst_1 : L.Structure N] →
{motive : L.Hom M N → Sort u_1} →
(t : L.Hom M N) →
((toFun : M → N) →
(map_fun' :
∀ {n : ℕ} (f : L.Functions n) (x : Fin n → M),
toFun (FirstOrder.Language.Structure.funMap f x) =
FirstOrder.Language.Structure.funMap f (toFun ∘ x)) →
(map_rel' :
∀ {n : ℕ} (r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r x →
FirstOrder.Language.Structure.RelMap r (toFun ∘ x)) →
motive { toFun := toFun, map_fun' := map_fun', map_rel' := map_rel' }) →
motive t |
Array.step_iterFromIdxM | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} {array : Array β} {pos : ℕ},
(array.iterFromIdxM m pos).step =
pure
(Std.Shrink.deflate
(if h : pos < array.size then Std.PlausibleIterStep.yield (array.iterFromIdxM m (pos + 1)) array[pos] ⋯
else Std.PlausibleIterStep.done ⋯)) |
WithTop.eq_of_forall_le_coe_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : PartialOrder α] {x y : WithTop α} [NoTopOrder α], (∀ (a : α), x ≤ ↑a ↔ y ≤ ↑a) → x = y |
_private.Mathlib.NumberTheory.NumberField.FinitePlaces.0.NumberField.HeightOneSpectrum.termLw | Mathlib.NumberTheory.NumberField.FinitePlaces | Lean.ParserDescr |
FirstOrder.Language.BoundedFormula.realize_bdEqual._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M}
(t₁ t₂ : L.Term (α ⊕ Fin l)),
(t₁.bdEqual t₂).Realize v xs =
(FirstOrder.Language.Term.realize (Sum.elim v xs) t₁ = FirstOrder.Language.Term.realize (Sum.elim v xs) t₂) |
Module.Dual.extendRCLikeₗ._proof_8 | Mathlib.Analysis.RCLike.Extend | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {F : Type u_1} [inst_1 : AddCommGroup F] [inst_2 : Module ℝ F] [inst_3 : Module 𝕜 F]
[IsScalarTower ℝ 𝕜 F], LinearMap.CompatibleSMul F 𝕜 ℝ 𝕜 |
Std.DTreeMap.Raw.Const.equiv_iff_toList_perm | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap.Raw α (fun x => β) cmp},
t₁.Equiv t₂ ↔ (Std.DTreeMap.Raw.Const.toList t₁).Perm (Std.DTreeMap.Raw.Const.toList t₂) |
Std.Do.SPred.Tactic.HasFrame.mk._flat_ctor | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs} {P' : outParam (Std.Do.SPred σs)} {φ : outParam Prop},
(P ⊣⊢ₛ P' ∧ ⌜φ⌝) → Std.Do.SPred.Tactic.HasFrame P P' φ |
Matroid.IsLoop.dep | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsLoop e → M.Dep {e} |
Ordnode.nth | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → ℕ → Option α |
AddOpposite.op_sub | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubNegMonoid α] (x y : α), AddOpposite.op (x - y) = -AddOpposite.op y + AddOpposite.op x |
GroupFilterBasis.mul' | Mathlib.Topology.Algebra.FilterBasis | ∀ {G : Type u} {inst : Group G} [self : GroupFilterBasis G] {U : Set G}, U ∈ self.sets → ∃ V ∈ self.sets, V * V ⊆ U |
ENNReal.toReal_eq_toReal | Mathlib.Data.ENNReal.Real | ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ ⊤ → (x.toReal = y.toReal ↔ x = y) |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.conditional_filter_eq_map_range._simp_1_3 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {t : Set β}, (t ∈ Filter.map m f) = (m ⁻¹' t ∈ f) |
MeasureTheory.projectiveFamilyContent_mono | Mathlib.MeasureTheory.Constructions.ProjectiveFamilyContent | ∀ {ι : Type u_1} {α : ι → Type u_2} {mα : (i : ι) → MeasurableSpace (α i)}
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} {s t : Set ((i : ι) → α i)}
(hP : MeasureTheory.IsProjectiveMeasureFamily P),
s ∈ MeasureTheory.measurableCylinders α →
t ∈ MeasureTheory.measurableCylinders α →
s ⊆ t → (MeasureTheory.projectiveFamilyContent hP) s ≤ (MeasureTheory.projectiveFamilyContent hP) t |
CategoryTheory.Subobject.underlying_arrow | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {Y Z : CategoryTheory.Subobject X} (f : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.underlying.map f) Z.arrow = Y.arrow |
_private.Mathlib.CategoryTheory.FintypeCat.0.FintypeCat.uSwitchEquivalence._simp_5 | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y : FintypeCat} (f : X ⟶ Y) (x : (FintypeCat.uSwitch.obj X).obj),
Y.uSwitchEquiv ((CategoryTheory.ConcreteCategory.hom (FintypeCat.uSwitch.map f)) x) =
(CategoryTheory.ConcreteCategory.hom f) (X.uSwitchEquiv x) |
Filter.EventuallyEq.fderivWithin_eq_of_nhds | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f f₁ : E → F} {x : E} {s : Set E},
f₁ =ᶠ[nhds x] f → fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x |
_private.Init.Data.SInt.Bitwise.0.Int32.xor_not._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32}, (a = b) = (a.toBitVec = b.toBitVec) |
_private.Lean.Server.InfoUtils.0.Lean.Elab.InfoTree.deepestNodesM.match_1 | Lean.Server.InfoUtils | {α : Type} →
(motive : Option α → Sort u_1) →
(__do_lift : Option α) → ((r : α) → motive (some r)) → (Unit → motive none) → motive __do_lift |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffWithinAt_insert_self._simp_1_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {s : Set M} {x : M}
{n : WithTop ℕ∞},
ContMDiffWithinAt I I' n f s x =
(ContinuousWithinAt f s x ∧
ContDiffWithinAt 𝕜 n (↑(extChartAt I' (f x)) ∘ f ∘ ↑(extChartAt I x).symm)
(↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I) (↑(extChartAt I x) x)) |
normal_iff | Mathlib.FieldTheory.Normal.Defs | ∀ {F : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K],
Normal F K ↔ ∀ (x : K), IsIntegral F x ∧ (Polynomial.map (algebraMap F K) (minpoly F x)).Splits |
_private.Lean.Server.References.0.Lean.Server.combineIdents.match_1 | Lean.Server.References | (motive : Option Lean.Lsp.RefIdent → Sort u_1) →
(x : Option Lean.Lsp.RefIdent) →
((id : Lean.Lsp.RefIdent) → motive (some id)) → ((x : Option Lean.Lsp.RefIdent) → motive x) → motive x |
BoundedLatticeHom.subtypeVal._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {β : Type u_1} [inst : Lattice β] [inst_1 : BoundedOrder β] {P : β → Prop} (Pbot : P ⊥) (Ptop : P ⊤)
(Psup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)) (Pinf : ∀ ⦃x y : β⦄, P x → P y → P (x ⊓ y)),
(LatticeHom.subtypeVal Psup Pinf).toFun ⊤ = ⊤ |
_private.Batteries.Linter.UnnecessarySeqFocus.0.Batteries.Linter.UnnecessarySeqFocus.markUsedTactics._sparseCasesOn_3 | Batteries.Linter.UnnecessarySeqFocus | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.TacticInfo) → motive (Lean.Elab.Info.ofTacticInfo i)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.evalDiv.match_1 | Mathlib.Tactic.NormNum.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(a b : Q(«$α»)) →
(dsα : Q(DivisionSemiring «$α»)) →
(dα : Q(DivisionRing «$α»)) →
(motive : ℚ × (n : Q(ℤ)) × (d : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsRat («$a» * «$b»⁻¹) «$n» «$d») → Sort u_1) →
(__discr : ℚ × (n : Q(ℤ)) × (d : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsRat («$a» * «$b»⁻¹) «$n» «$d»)) →
((qa : ℚ) →
(na : Q(ℤ)) →
(da : Q(ℕ)) →
(pa : Q(Mathlib.Meta.NormNum.IsRat («$a» * «$b»⁻¹) «$na» «$da»)) → motive (qa, ⟨na, ⟨da, pa⟩⟩)) →
motive __discr |
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitSimpleExternalCall.match_3 | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} →
(motive : MProd (Array (LLVM.LLVMType llvmctx)) (Array (LLVM.Value llvmctx)) → Sort u_1) →
(r : MProd (Array (LLVM.LLVMType llvmctx)) (Array (LLVM.Value llvmctx))) →
((argTys : Array (LLVM.LLVMType llvmctx)) → (args : Array (LLVM.Value llvmctx)) → motive ⟨argTys, args⟩) →
motive r |
RelSeries.fromListIsChain | Mathlib.Order.RelSeries | {α : Type u_1} → {r : SetRel α α} → (x : List α) → x ≠ [] → List.IsChain (fun x1 x2 => (x1, x2) ∈ r) x → RelSeries r |
BialgEquiv.instFunLike._proof_1 | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B],
Function.Injective fun f => ⇑f |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rco_add_succ_right_eq_push._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {α : Type u_1} {as : List α} {bs : Array α}, (as.toArray = bs) = (as = bs.toList) |
Lean.Widget.WidgetInstance.noConfusion | Lean.Widget.Types | {P : Sort u} → {t t' : Lean.Widget.WidgetInstance} → t = t' → Lean.Widget.WidgetInstance.noConfusionType P t t' |
AddOpposite.instMulOneClass._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : MulOneClass α], AddOpposite.unop 1 = 1 |
Algebra.Presentation.tensorModelOfHasCoeffsInv._proof_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_4} {S : Type u_5} {ι : Type u_2} {σ : Type u_3} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.Presentation R S ι σ) (R₀ : Type u_1) [inst_3 : CommRing R₀]
[inst_4 : Algebra R₀ R] [inst_5 : Algebra R₀ S] [inst_6 : IsScalarTower R₀ R S] [inst_7 : P.HasCoeffs R₀],
(Ideal.span (Set.range (Algebra.Presentation.relationOfHasCoeffs R₀))).IsTwoSided |
CategoryTheory.Limits.LimitBicone.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {P : Sort u} →
{J : Type w} →
{C : Type uC} →
{inst : CategoryTheory.Category.{uC', uC} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{F : J → C} →
{t : CategoryTheory.Limits.LimitBicone F} →
{J' : Type w} →
{C' : Type uC} →
{inst' : CategoryTheory.Category.{uC', uC} C'} →
{inst'_1 : CategoryTheory.Limits.HasZeroMorphisms C'} →
{F' : J' → C'} →
{t' : CategoryTheory.Limits.LimitBicone F'} →
J = J' →
C = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
F ≍ F' → t ≍ t' → CategoryTheory.Limits.LimitBicone.noConfusionType P t t' |
linearMapOfMemClosureRangeCoe_apply | Mathlib.Topology.Algebra.Module.Basic | ∀ {M₁ : Type u_1} {M₂ : Type u_2} {R : Type u_4} {S : Type u_5} [inst : TopologicalSpace M₂] [inst_1 : T2Space M₂]
[inst_2 : Semiring R] [inst_3 : Semiring S] [inst_4 : AddCommMonoid M₁] [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₁] [inst_7 : Module S M₂] [inst_8 : ContinuousConstSMul S M₂] [inst_9 : ContinuousAdd M₂]
{σ : R →+* S} (f : M₁ → M₂) (hf : f ∈ closure (Set.range DFunLike.coe)),
⇑(linearMapOfMemClosureRangeCoe f hf) = (↑(addMonoidHomOfMemClosureRangeCoe f hf)).toFun |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.cellFrontier_subset_finite_openCell._simp_1_3 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
Sat.Literal.pos.noConfusion | Mathlib.Tactic.Sat.FromLRAT | {P : Sort u} → {a a' : ℕ} → Sat.Literal.pos a = Sat.Literal.pos a' → (a = a' → P) → P |
Module.Basis.instFunLike._proof_1 | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f g : Module.Basis ι R M),
(fun b i => b.repr.symm fun₀ | i => 1) f = (fun b i => b.repr.symm fun₀ | i => 1) g → ↑f.repr.symm = ↑g.repr.symm |
Units.toAut_inv | Mathlib.CategoryTheory.SingleObj | ∀ (M : Type u) [inst : Monoid M] (x : Mˣ), ((Units.toAut M) x).inv = (CategoryTheory.SingleObj.toEnd M) ↑x⁻¹ |
Sum.update_inr_apply_inl | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} [inst : DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {j : β} {x : γ},
Function.update f (Sum.inr j) x (Sum.inl i) = f (Sum.inl i) |
Set.image_const_sub_Ici | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (a b : α),
(fun x => a - x) '' Set.Ici b = Set.Iic (a - b) |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.PendingSolverPropagationsData.diseqs.inj | Lean.Meta.Tactic.Grind.Types | ∀ {solverId : ℕ} {ps : Lean.Meta.Grind.ParentSet} {rest : Lean.Meta.Grind.PendingSolverPropagationsData✝}
{solverId_1 : ℕ} {ps_1 : Lean.Meta.Grind.ParentSet} {rest_1 : Lean.Meta.Grind.PendingSolverPropagationsData✝¹},
Lean.Meta.Grind.PendingSolverPropagationsData.diseqs✝ solverId ps rest =
Lean.Meta.Grind.PendingSolverPropagationsData.diseqs✝¹ solverId_1 ps_1 rest_1 →
solverId = solverId_1 ∧ ps = ps_1 ∧ rest = rest_1 |
AdjoinRoot.algEquivOfEq_symm | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S)
(hfg : f = g), (AdjoinRoot.algEquivOfEq R f g hfg).symm = AdjoinRoot.algEquivOfEq R g f ⋯ |
_private.Mathlib.NumberTheory.Height.Basic.0.Height.hasFiniteMulSupport_iSup_nonarchAbsVal._proof_1_3 | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] {ι : Type u_2} {x : ι → K} (i : { j // x j ≠ 0 }), ¬x ↑i = 0 |
Nat.leRec._proof_1 | Mathlib.Data.Nat.Init | 0 ≤ 0 |
Mathlib.Meta.NormNum.isInt_ratCast | Mathlib.Tactic.NormNum.Inv | ∀ {R : Type u_1} [inst : DivisionRing R] {q : ℚ} {n : ℤ},
Mathlib.Meta.NormNum.IsInt q n → Mathlib.Meta.NormNum.IsInt (↑q) n |
NonemptyInterval.pure_natCast | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : NatCast α] (n : ℕ), NonemptyInterval.pure ↑n = ↑n |
MvPolynomial.comp_aeval_apply | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] [inst_2 : Algebra R S₁]
(f : σ → S₁) {B : Type u_2} [inst_3 : CommSemiring B] [inst_4 : Algebra R B] (φ : S₁ →ₐ[R] B) (p : MvPolynomial σ R),
φ ((MvPolynomial.aeval f) p) = (MvPolynomial.aeval fun i => φ (f i)) p |
_private.Mathlib.Algebra.Polynomial.HasseDeriv.0.Polynomial.factorial_smul_hasseDeriv._simp_1_2 | Mathlib.Algebra.Polynomial.HasseDeriv | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (n : ℕ), ↑n + 1 = ↑n.succ |
InfHom.instPartialOrder.eq_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : SemilatticeInf β],
InfHom.instPartialOrder = PartialOrder.lift (fun f => ⇑f) ⋯ |
Std.DTreeMap.Raw.getKey!_eq_of_contains | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α], t.WF → ∀ {k : α}, t.contains k = true → t.getKey! k = k |
CompletelyPositiveMap.noConfusion | Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap | {P : Sort u} →
{A₁ : Type u_1} →
{A₂ : Type u_2} →
{inst : NonUnitalCStarAlgebra A₁} →
{inst_1 : NonUnitalCStarAlgebra A₂} →
{inst_2 : PartialOrder A₁} →
{inst_3 : PartialOrder A₂} →
{inst_4 : StarOrderedRing A₁} →
{inst_5 : StarOrderedRing A₂} →
{t : CompletelyPositiveMap A₁ A₂} →
{A₁' : Type u_1} →
{A₂' : Type u_2} →
{inst' : NonUnitalCStarAlgebra A₁'} →
{inst'_1 : NonUnitalCStarAlgebra A₂'} →
{inst'_2 : PartialOrder A₁'} →
{inst'_3 : PartialOrder A₂'} →
{inst'_4 : StarOrderedRing A₁'} →
{inst'_5 : StarOrderedRing A₂'} →
{t' : CompletelyPositiveMap A₁' A₂'} →
A₁ = A₁' →
A₂ = A₂' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
inst_4 ≍ inst'_4 →
inst_5 ≍ inst'_5 →
t ≍ t' → CompletelyPositiveMap.noConfusionType P t t' |
_private.Mathlib.Algebra.Module.Submodule.Pointwise.0.Submodule.set_smul_eq_iSup._simp_1_2 | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (iSup f ≤ a) = ∀ (i : ι), f i ≤ a |
_private.Mathlib.Data.Finmap.0.Finmap.any._simp_1 | Mathlib.Data.Finmap | ∀ (α : Sort u), (∀ (a : α), True) = True |
PerfectClosure.mk_inv | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u) [inst : Field K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (x : ℕ × K),
(PerfectClosure.mk K p x)⁻¹ = PerfectClosure.mk K p (x.1, x.2⁻¹) |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Traj.0.ProbabilityTheory.Kernel.condExp_traj'._simp_1_1 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) |
LieSubmodule.subset_lieSpan | 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] {s : Set M}, s ⊆ ↑(LieSubmodule.lieSpan R L s) |
IsContDiffImplicitAt.apply_implicitFunction | Mathlib.Analysis.Calculus.ImplicitContDiff | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G] [inst_8 : NormedSpace 𝕜 G]
[inst_9 : CompleteSpace G] {n : WithTop ℕ∞} {f : E × F → G} {f' : E × F →L[𝕜] G} {a : E × F}
(h : IsContDiffImplicitAt n f f' a), ∀ᶠ (x : E) in nhds a.1, f (x, h.implicitFunction x) = f a |
CategoryTheory.Monad.ForgetCreatesLimits.liftedConeIsLimit._proof_4 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (D : CategoryTheory.Functor J T.Algebra)
(c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c)
(s : CategoryTheory.Limits.Cone D) (m : s.pt ⟶ (CategoryTheory.Monad.ForgetCreatesLimits.liftedCone D c t).pt),
(∀ (j : J),
CategoryTheory.CategoryStruct.comp m ((CategoryTheory.Monad.ForgetCreatesLimits.liftedCone D c t).π.app j) =
s.π.app j) →
m = { f := t.lift (T.forget.mapCone s), h := ⋯ } |
RatFunc.toFractionRingRingEquiv._proof_8 | Mathlib.FieldTheory.RatFunc.Basic | ∀ (K : Type u_1) [inst : CommRing K] (toFractionRing toFractionRing_1 : FractionRing (Polynomial K)),
({ toFractionRing := toFractionRing } + { toFractionRing := toFractionRing_1 }).toFractionRing =
{ toFractionRing := toFractionRing }.toFractionRing + { toFractionRing := toFractionRing_1 }.toFractionRing |
Int.subNatNat_elim | Init.Data.Int.Lemmas | ∀ (m n : ℕ) (motive : ℕ → ℕ → ℤ → Prop),
(∀ (i n : ℕ), motive (n + i) n ↑i) →
(∀ (i m : ℕ), motive m (m + i + 1) (Int.negSucc i)) → motive m n (Int.subNatNat m n) |
Lean.KeyedDeclsAttribute.Def._private_1 | Lean.KeyedDeclsAttribute | Lean.Syntax → Lean.AttrM Lean.KeyedDeclsAttribute.Key |
ContinuousLinearMap.toSpanSingleton_inj | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₂ : Type u_6} [inst_1 : TopologicalSpace M₂] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R₁ M₂] [inst_4 : TopologicalSpace R₁] [inst_5 : ContinuousSMul R₁ M₂] {f f' : M₂},
ContinuousLinearMap.toSpanSingleton R₁ f = ContinuousLinearMap.toSpanSingleton R₁ f' ↔ f = f' |
ArithmeticFunction.LSeries_mul | Mathlib.NumberTheory.LSeries.Convolution | ∀ {f g : ArithmeticFunction ℂ} {s : ℂ},
(LSeries.abscissaOfAbsConv fun n => f n) < ↑s.re →
(LSeries.abscissaOfAbsConv fun n => g n) < ↑s.re →
LSeries (fun n => (f * g) n) s = LSeries (fun n => f n) s * LSeries (fun n => g n) s |
PFunctor.mk._flat_ctor | Mathlib.Data.PFunctor.Univariate.Basic | (A : Type uA) → (A → Type uB) → PFunctor.{uA, uB} |
DirectSum.GradeZero.ring._proof_2 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddMonoid ι], (DirectSum.of A 0) 0 = 0 |
Lean.HeadIndex.sort | Lean.HeadIndex | Lean.HeadIndex |
_private.Mathlib.Topology.Constructions.SumProd.0.isClosed_sum_iff._simp_1_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ |
mdifferentiableWithinAt_comp_projIcc_iff | Mathlib.Geometry.Manifold.Instances.Icc | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {x y : ℝ}
[h : Fact (x < y)] {f : ↑(Set.Icc x y) → M} {w : ↑(Set.Icc x y)},
MDiffAt[Set.Icc x y] (f ∘ Set.projIcc x y ⋯) ↑w ↔ MDiffAt f w |
QuadraticMap.polar_smul_left_of_tower | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {S : Type u_1} {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module R M] [inst_4 : Module R N] (Q : QuadraticMap R M N)
[inst_5 : CommSemiring S] [inst_6 : Algebra S R] [inst_7 : Module S M] [IsScalarTower S R M] [inst_9 : Module S N]
[IsScalarTower S R N] (a : S) (x y : M), QuadraticMap.polar (⇑Q) (a • x) y = a • QuadraticMap.polar (⇑Q) x y |
NumberField.dedekindZeta_residue_pos | Mathlib.NumberTheory.NumberField.DedekindZeta | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K], 0 < NumberField.dedekindZeta_residue K |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.