name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.invtSubmoduleToLieIdeal_top._simp_1_5 | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
(x ∈ ⊤) = True |
Aesop.ScriptGenerated.perfect | Aesop.Stats.Basic | Aesop.ScriptGenerated → Bool |
Filter.liminf_bot | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] (f : β → α), Filter.liminf f ⊥ = ⊤ |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.LocallyCompactSpace.of_hasBasis.match_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_2} {ι : X → Type u_1} {p : (x : X) → ι x → Prop} {s : (x : X) → ι x → Set X} (x : X) (_t : Set X)
(motive : (∃ i, p x i ∧ s x i ⊆ _t) → Prop) (x_1 : ∃ i, p x i ∧ s x i ⊆ _t),
(∀ (i : ι x) (hp : p x i) (ht : s x i ⊆ _t), motive ⋯) → motive x_1 |
Lean.Grind.toInt_bitVec | Init.GrindInstances.ToInt | ∀ {v : ℕ} (x : BitVec v), ↑x = ↑x.toNat |
Int.natAbs_dvd_natAbs._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ {a b : ℤ}, (a.natAbs ∣ b.natAbs) = (a ∣ b) |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._proof_1_1 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ (n m : ℤ), n + m = 0 → m = -n |
ModelWithCorners.continuousOn_symm | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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) {s : Set E},
ContinuousOn (↑I.symm) s |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_insert_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel |
_private.Mathlib.GroupTheory.QuotientGroup.Basic.0.QuotientGroup.quotientInfEquivProdNormalizerQuotient._simp_4 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {x y : α}, (QuotientGroup.leftRel s) x y = (x⁻¹ * y ∈ s) |
AddOpposite.instRightCancelSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [RightCancelSemigroup α] → RightCancelSemigroup αᵃᵒᵖ |
Vector.toArray_reverse | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), xs.reverse.toArray = xs.toArray.reverse |
Lean.Elab.FieldInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} → {t t' : Lean.Elab.FieldInfo} → t = t' → Lean.Elab.FieldInfo.noConfusionType P t t' |
_private.Mathlib.Topology.Order.LowerUpperTopology.0.Topology.IsLower.isTopologicalSpace_basis._simp_1_6 | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processExplicitArg._sparseCasesOn_1 | Lean.Elab.App | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exists_closedBall_covering_tsum_measure_le._simp_1_16 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
_private.Mathlib.Data.List.Sym.0.List.Nodup.sym2._simp_1_8 | Mathlib.Data.List.Sym | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' |
UniformEquiv.piCongrRight_symm | Mathlib.Topology.UniformSpace.Equiv | ∀ {ι : Type u_4} {β₁ : ι → Type u_5} {β₂ : ι → Type u_6} [inst : (i : ι) → UniformSpace (β₁ i)]
[inst_1 : (i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i),
(UniformEquiv.piCongrRight F).symm = UniformEquiv.piCongrRight fun i => (F i).symm |
Disjoint.isCompl_sup_right_of_isCompl_sup_left | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} {a b c : α} [inst : Lattice α] [inst_1 : BoundedOrder α] [IsModularLattice α],
Disjoint a b → IsCompl (a ⊔ b) c → IsCompl a (b ⊔ c) |
CauSeq.Completion.ofRat_injective | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv], Function.Injective CauSeq.Completion.ofRat |
ConvexCone.instCompleteLattice._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 : SMul R M] (a b : ConvexCone R M), a ≤ SemilatticeSup.sup a b |
Lean.Elab.Info.ofOptionInfo.inj | Lean.Elab.InfoTree.Types | ∀ {i i_1 : Lean.Elab.OptionInfo}, Lean.Elab.Info.ofOptionInfo i = Lean.Elab.Info.ofOptionInfo i_1 → i = i_1 |
AddMemClass.toAddCommSemigroup._proof_3 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : AddCommSemigroup M] {A : Type u_2} [inst_1 : SetLike A M] [inst_2 : AddMemClass A M] (S : A)
(a b : ↥S), a + b = b + a |
_private.Mathlib.Order.LiminfLimsup.0.limsup_finset_sup'._simp_1_4 | Mathlib.Order.LiminfLimsup | ∀ {α : 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 |
DecompositionMonoid | Mathlib.Algebra.Divisibility.Basic | (α : Type u_1) → [Semigroup α] → Prop |
Lean.Lsp.DeclarationParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.DeclarationParams} → t = t' → Lean.Lsp.DeclarationParams.noConfusionType P t t' |
Inter.inter | Init.Core | {α : Type u} → [self : Inter α] → α → α → α |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getElem_concat_succ._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {k n m : ℕ}, (n + k < m + k) = (n < m) |
Algebra.tensorH1CotangentOfIsLocalization_toLinearMap | Mathlib.RingTheory.Etale.Kaehler | ∀ (R : Type u_1) {S : Type u_2} (T : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] (M : Submonoid S)
[inst_7 : IsLocalization M T],
↑(Algebra.tensorH1CotangentOfIsLocalization R T M) = LinearMap.liftBaseChange T (Algebra.H1Cotangent.map R R S T) |
_private.Mathlib.Probability.StrongLaw.0.ProbabilityTheory.strong_law_aux1._simp_1_10 | Mathlib.Probability.StrongLaw | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) |
Lean.Meta.Grind.Arith.CommRing.State.mk.injEq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ (rings : Array Lean.Meta.Grind.Arith.CommRing.CommRing) (typeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(exprToRingId : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ) (semirings : Array Lean.Meta.Grind.Arith.CommRing.CommSemiring)
(stypeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(exprToSemiringId : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ) (ncRings : Array Lean.Meta.Grind.Arith.CommRing.Ring)
(exprToNCRingId : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ) (nctypeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(ncSemirings : Array Lean.Meta.Grind.Arith.CommRing.Semiring)
(exprToNCSemiringId : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ)
(ncstypeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ)) (steps : ℕ)
(rings_1 : Array Lean.Meta.Grind.Arith.CommRing.CommRing)
(typeIdOf_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ)) (exprToRingId_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ)
(semirings_1 : Array Lean.Meta.Grind.Arith.CommRing.CommSemiring)
(stypeIdOf_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(exprToSemiringId_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ) (ncRings_1 : Array Lean.Meta.Grind.Arith.CommRing.Ring)
(exprToNCRingId_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ)
(nctypeIdOf_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(ncSemirings_1 : Array Lean.Meta.Grind.Arith.CommRing.Semiring)
(exprToNCSemiringId_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ)
(ncstypeIdOf_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ)) (steps_1 : ℕ),
({ rings := rings, typeIdOf := typeIdOf, exprToRingId := exprToRingId, semirings := semirings, stypeIdOf := stypeIdOf,
exprToSemiringId := exprToSemiringId, ncRings := ncRings, exprToNCRingId := exprToNCRingId,
nctypeIdOf := nctypeIdOf, ncSemirings := ncSemirings, exprToNCSemiringId := exprToNCSemiringId,
ncstypeIdOf := ncstypeIdOf, steps := steps } =
{ rings := rings_1, typeIdOf := typeIdOf_1, exprToRingId := exprToRingId_1, semirings := semirings_1,
stypeIdOf := stypeIdOf_1, exprToSemiringId := exprToSemiringId_1, ncRings := ncRings_1,
exprToNCRingId := exprToNCRingId_1, nctypeIdOf := nctypeIdOf_1, ncSemirings := ncSemirings_1,
exprToNCSemiringId := exprToNCSemiringId_1, ncstypeIdOf := ncstypeIdOf_1, steps := steps_1 }) =
(rings = rings_1 ∧
typeIdOf = typeIdOf_1 ∧
exprToRingId = exprToRingId_1 ∧
semirings = semirings_1 ∧
stypeIdOf = stypeIdOf_1 ∧
exprToSemiringId = exprToSemiringId_1 ∧
ncRings = ncRings_1 ∧
exprToNCRingId = exprToNCRingId_1 ∧
nctypeIdOf = nctypeIdOf_1 ∧
ncSemirings = ncSemirings_1 ∧
exprToNCSemiringId = exprToNCSemiringId_1 ∧ ncstypeIdOf = ncstypeIdOf_1 ∧ steps = steps_1) |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Arg.0.Complex.cos_arg._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False |
_private.Mathlib.SetTheory.ZFC.VonNeumann.0.ZFSet.mem_vonNeumann_succ._simp_1_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {o : Ordinal.{u}} {x : ZFSet.{u}}, (x ∈ ZFSet.vonNeumann o) = (x.rank < o) |
CategoryTheory.Triangulated.SpectralObject._sizeOf_inst | Mathlib.CategoryTheory.Triangulated.SpectralObject | (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.Limits.HasZeroObject C} →
{inst_3 : CategoryTheory.HasShift C ℤ} →
{inst_4 : CategoryTheory.Preadditive C} →
{inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive} →
{inst_6 : CategoryTheory.Pretriangulated C} →
[SizeOf C] → [SizeOf ι] → SizeOf (CategoryTheory.Triangulated.SpectralObject C ι) |
CategoryTheory.Functor.CoconeTypes.isColimit_iff | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)} (c : F.CoconeTypes),
c.IsColimit ↔ Nonempty (CategoryTheory.Limits.IsColimit (F.coconeTypesEquiv c)) |
List.traverse.eq_2 | Mathlib.Control.Traversable.Instances | ∀ {F : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Applicative F] (f : α → F β) (a : α) (l : List α),
List.traverse f (a :: l) = List.cons <$> f a <*> List.traverse f l |
ENNReal.tendsto_nhds_zero | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {f : Filter α} {u : α → ENNReal}, Filter.Tendsto u f (nhds 0) ↔ ∀ ε > 0, ∀ᶠ (x : α) in f, u x ≤ ε |
CategoryTheory.Limits.colimMap | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F G : CategoryTheory.Functor J C} →
[inst_2 : CategoryTheory.Limits.HasColimit F] →
[inst_3 : CategoryTheory.Limits.HasColimit G] →
(F ⟶ G) → (CategoryTheory.Limits.colimit F ⟶ CategoryTheory.Limits.colimit G) |
MeasureTheory.OuterMeasure.comap._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) (m : MeasureTheory.OuterMeasure β), m (f '' ∅) = 0 |
List.mapAccumr₂.eq_3 | Mathlib.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β → γ → γ × δ) (x : γ) (x_3 : α) (xr : List α)
(y : β) (yr : List β),
List.mapAccumr₂ f (x_3 :: xr) (y :: yr) x =
((f x_3 y (List.mapAccumr₂ f xr yr x).1).1,
(f x_3 y (List.mapAccumr₂ f xr yr x).1).2 :: (List.mapAccumr₂ f xr yr x).2) |
CategoryTheory.CommGrpObj.noConfusion | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} →
{X : C} →
{t : CategoryTheory.CommGrpObj X} →
{C' : Type u} →
{inst' : CategoryTheory.Category.{v, u} C'} →
{inst'_1 : CategoryTheory.CartesianMonoidalCategory C'} →
{inst'_2 : CategoryTheory.BraidedCategory C'} →
{X' : C'} →
{t' : CategoryTheory.CommGrpObj X'} →
C = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 → X ≍ X' → t ≍ t' → CategoryTheory.CommGrpObj.noConfusionType P t t' |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_insert_of_ne._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, a ≠ b → (insert a s).erase b = insert a (s.erase b) |
CategoryTheory.Adjunction.Quadruple.op_adj₂ | Mathlib.CategoryTheory.Adjunction.Quadruple | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} {G : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor D C} (q : CategoryTheory.Adjunction.Quadruple L F G R), q.op.adj₂ = q.adj₂.op |
Finset.prod_le_one | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommMonoidWithZero R] [inst_1 : PartialOrder R] [ZeroLEOneClass R]
[PosMulMono R] {f : ι → R} {s : Finset ι}, (∀ i ∈ s, 0 ≤ f i) → (∀ i ∈ s, f i ≤ 1) → ∏ i ∈ s, f i ≤ 1 |
GradedTensorProduct.instRing._proof_15 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ℬ] (n : ℕ)
(a : GradedTensorProduct R 𝒜 ℬ), SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a |
AddZero | Mathlib.Algebra.Group.Defs | Type u_2 → Type u_2 |
Equiv.prodSubtypeFstEquivSubtypeProd._proof_4 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} (x : { a // p a } × β), p ↑x.1 |
_private.Mathlib.Data.Finset.Card.0.Finset.exists_of_one_lt_card_pi._simp_1_1 | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {s : Finset α}, (1 < s.card) = ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b |
List.Perm.all_eq | Init.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α} {f : α → Bool}, l₁.Perm l₂ → l₁.all f = l₂.all f |
_private.Mathlib.Tactic.Widget.Conv.0.Mathlib.Tactic.Conv.Path.fun.noConfusion | Mathlib.Tactic.Widget.Conv | {P : Sort u} →
{depth depth' : ℕ} →
Mathlib.Tactic.Conv.Path.fun✝ depth = Mathlib.Tactic.Conv.Path.fun✝¹ depth' → (depth = depth' → P) → P |
unitary.match_1 | Mathlib.Algebra.Star.Unitary | ∀ (R : Type u_1) [inst : Monoid R] [inst_1 : StarMul R] (B : R)
(motive : B ∈ {U | star U * U = 1 ∧ U * star U = 1} → Prop) (x : B ∈ {U | star U * U = 1 ∧ U * star U = 1}),
(∀ (hB₁ : star B * B = 1) (hB₂ : B * star B = 1), motive ⋯) → motive x |
_private.Lean.Elab.Deriving.FromToJson.0.Lean.Elab.Deriving.FromToJson.mkToJsonBodyForStruct.match_1 | Lean.Elab.Deriving.FromToJson | (motive : Bool × Lean.Term → Sort u_1) →
(__discr : Bool × Lean.Term) → ((isOptField : Bool) → (nm : Lean.Term) → motive (isOptField, nm)) → motive __discr |
_private.Mathlib.Tactic.Tauto.0.Mathlib.Tactic.Tauto.elabConfig.match_1 | Mathlib.Tactic.Tauto | (motive : DoResultPR Mathlib.Tactic.Tauto.Config Mathlib.Tactic.Tauto.Config PUnit.{1} → Sort u_1) →
(r : DoResultPR Mathlib.Tactic.Tauto.Config Mathlib.Tactic.Tauto.Config PUnit.{1}) →
((a : Mathlib.Tactic.Tauto.Config) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Mathlib.Tactic.Tauto.Config) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r |
LinearOrderedAddCommGroupWithTop.sub_self_eq_zero_iff_ne_top._simp_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_2} [inst : LinearOrderedAddCommGroupWithTop α] {a : α}, (a - a = 0) = (a ≠ ⊤) |
OrderMonoidIso.symm._proof_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β]
(f : α ≃*o β) {a b : β}, f.toOrderIso.symm a ≤ f.toOrderIso.symm b ↔ a ≤ b |
TensorProduct.map_comp | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring R₂]
[inst_2 : CommSemiring R₃] {σ₁₂ : R →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R →+* R₃} {M : Type u_7} {N : Type u_8}
{M₂ : Type u_12} {M₃ : Type u_13} {N₂ : Type u_14} {N₃ : Type u_15} [inst_3 : AddCommMonoid M]
[inst_4 : AddCommMonoid N] [inst_5 : AddCommMonoid M₂] [inst_6 : AddCommMonoid N₂] [inst_7 : AddCommMonoid M₃]
[inst_8 : AddCommMonoid N₃] [inst_9 : Module R M] [inst_10 : Module R N] [inst_11 : Module R₂ M₂]
[inst_12 : Module R₂ N₂] [inst_13 : Module R₃ M₃] [inst_14 : Module R₃ N₃] [inst_15 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃]
(f₂ : M₂ →ₛₗ[σ₂₃] M₃) (g₂ : N₂ →ₛₗ[σ₂₃] N₃) (f₁ : M →ₛₗ[σ₁₂] M₂) (g₁ : N →ₛₗ[σ₁₂] N₂),
TensorProduct.map (f₂ ∘ₛₗ f₁) (g₂ ∘ₛₗ g₁) = TensorProduct.map f₂ g₂ ∘ₛₗ TensorProduct.map f₁ g₁ |
IsUnit.mul_eq_right | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : Monoid M] {a b : M}, IsUnit b → (a * b = b ↔ a = 1) |
_private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix._aux_Mathlib_NumberTheory_SiegelsLemma___delab_app__private_Mathlib_NumberTheory_SiegelsLemma_0_Int_Matrix_termT_1 | Mathlib.NumberTheory.SiegelsLemma | Lean.PrettyPrinter.Delaborator.Delab |
MeasureTheory.MeasuredSets.continuous_measure | Mathlib.MeasureTheory.Measure.MeasuredSets | ∀ {α : Type u_1} [mα : MeasurableSpace α] {μ : MeasureTheory.Measure α}, Continuous fun s => μ ↑s |
_private.Batteries.Util.ExtendedBinder.0.Batteries.ExtendedBinder.«_aux_Batteries_Util_ExtendedBinder___macroRules_Batteries_ExtendedBinder_term∃ᵉ_,__1».match_1 | Batteries.Util.ExtendedBinder | (motive : Option (Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinder)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinder))) →
((ps : Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinder)) → motive (some ps)) →
(Unit → motive none) → motive x |
Lean.Elab.checkSyntaxNodeKindAtNamespaces._sunfold | Lean.Elab.Util | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → [Lean.MonadError m] → Lean.Name → Lean.Name → m Lean.Name |
Subtype.coe_le_coe._gcongr_2 | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : Subtype p}, x ≤ y → ↑x ≤ ↑y |
LSeries.positive_of_differentiable_of_eqOn | Mathlib.NumberTheory.LSeries.Positivity | ∀ {a : ℕ → ℂ},
0 ≤ a →
0 < a 1 →
∀ {f : ℂ → ℂ},
Differentiable ℂ f →
∀ {x : ℝ}, LSeries.abscissaOfAbsConv a ≤ ↑x → Set.EqOn f (LSeries a) {s | x < s.re} → ∀ (y : ℝ), 0 < f ↑y |
Fin.exists_succAbove_eq_iff._simp_1 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {x y : Fin (n + 1)}, (∃ z, x.succAbove z = y) = (y ≠ x) |
Lean.Elab.Tactic.GuardMsgs.FilterSpec.toCtorIdx | Lean.Elab.GuardMsgs | Lean.Elab.Tactic.GuardMsgs.FilterSpec → ℕ |
LinearIsometryEquiv.toHomeomorph_trans | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} {E : Type u_5} {E₂ : Type u_6} {E₃ : Type u_7} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {σ₁₃ : R →+* R₃} {σ₃₁ : R₃ →+* R}
{σ₂₃ : R₂ →+* R₃} {σ₃₂ : R₃ →+* R₂} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
[inst_5 : RingHomInvPair σ₁₃ σ₃₁] [inst_6 : RingHomInvPair σ₃₁ σ₁₃] [inst_7 : RingHomInvPair σ₂₃ σ₃₂]
[inst_8 : RingHomInvPair σ₃₂ σ₂₃] [inst_9 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_10 : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁]
[inst_11 : SeminormedAddCommGroup E] [inst_12 : SeminormedAddCommGroup E₂] [inst_13 : SeminormedAddCommGroup E₃]
[inst_14 : Module R E] [inst_15 : Module R₂ E₂] [inst_16 : Module R₃ E₃] (e : E ≃ₛₗᵢ[σ₁₂] E₂) (e' : E₂ ≃ₛₗᵢ[σ₂₃] E₃),
(e.trans e').toHomeomorph = e.toHomeomorph.trans e'.toHomeomorph |
WithLp.idemSnd | Mathlib.Analysis.Normed.Lp.ProdLp | {α : Type u_2} →
{β : Type u_3} →
[inst : SeminormedAddCommGroup α] →
[inst_1 : SeminormedAddCommGroup β] → {p : ENNReal} → AddMonoid.End (WithLp p (α × β)) |
Set.compl_cIoo | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularOrder α] {a b : α}, (Set.cIoo a b)ᶜ = Set.cIcc b a |
unitInterval.symm_bijective | Mathlib.Topology.UnitInterval | Function.Bijective unitInterval.symm |
LieAlgebra.SemiDirectSum.recOn | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
{x : L →ₗ⁅R⁆ LieDerivation R K K} →
{motive : K ⋊⁅x⁆ L → Sort u} →
(t : K ⋊⁅x⁆ L) → ((left : K) → (right : L) → motive { left := left, right := right }) → motive t |
Lean.MessageData.ofFormatWithInfos.noConfusion | Lean.Message | {P : Sort u} →
{a a' : Lean.FormatWithInfos} →
Lean.MessageData.ofFormatWithInfos a = Lean.MessageData.ofFormatWithInfos a' → (a = a' → P) → P |
ZeroAtInftyContinuousMap.compNonUnitalAlgHom._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {β : Type u_2} {γ : Type u_3} {δ : Type u_1} [inst : TopologicalSpace β] [inst_1 : TopologicalSpace γ]
[inst_2 : TopologicalSpace δ] [inst_3 : NonUnitalNonAssocSemiring δ] [inst_4 : IsTopologicalSemiring δ]
(g : CocompactMap β γ), ZeroAtInftyContinuousMap.comp 0 g = ZeroAtInftyContinuousMap.comp 0 g |
Primrec.eq_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] (f : α → β),
Primrec f = Nat.Primrec fun n => Encodable.encode (Option.map f (Encodable.decode n)) |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Internalize.0.Lean.Meta.Grind.Arith.Linear.internalize.match_3 | Lean.Meta.Tactic.Grind.Arith.Linear.Internalize | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) →
((natStructId : ℕ) → motive (some natStructId)) → ((x : Option ℕ) → motive x) → motive __do_lift |
Lean.PrintImportsResult._sizeOf_1 | Lean.Elab.ParseImportsFast | Lean.PrintImportsResult → ℕ |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_21 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α) (ha : a ∈ x :: y :: tail),
a ≠ (x :: y :: tail).head ⋯ → 0 < (y :: tail).length |
IsOpen.locallyCompactSpace | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] [LocallyCompactSpace X] {s : Set X}, IsOpen s → LocallyCompactSpace ↑s |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Poly.0.Lean.Grind.CommRing.Poly.checkNoUnitMon._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | {motive : Lean.Grind.CommRing.Mon → Sort u} →
(t : Lean.Grind.CommRing.Mon) →
motive Lean.Grind.CommRing.Mon.unit → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Lean.Meta.Simp.SimprocExtension | Lean.Meta.Tactic.Simp.Simproc | Type |
ProbabilityTheory.«_aux_Mathlib_Probability_Kernel_Composition_CompNotation___macroRules_ProbabilityTheory_term_∘ₘ__1» | Mathlib.Probability.Kernel.Composition.CompNotation | Lean.Macro |
StieltjesFunction.instAddZeroClass._proof_2 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : StieltjesFunction R), x + 0 = x |
_private.Mathlib.Topology.Metrizable.Uniformity.0.UniformSpace.metrizable_uniformity._simp_1_4 | Mathlib.Topology.Metrizable.Uniformity | ∀ {a : Prop}, (¬¬a) = a |
_private.Lean.Meta.Tactic.Symm.0.Lean.Meta.Symm.initFn._sparseCasesOn_4._@.Lean.Meta.Tactic.Symm.3447505512._hygCtx._hyg.2 | Lean.Meta.Tactic.Symm | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
UniformSpace.toCore_toTopologicalSpace | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} (u : UniformSpace α), u.toCore.toTopologicalSpace = u.toTopologicalSpace |
CategoryTheory.CartesianMonoidalCategory.prodComparison_fst_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₁} [inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) (A B : C) {Z : D} (h : F.obj A ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianMonoidalCategory.prodComparison F A B)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.fst (F.obj A) (F.obj B)) h) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.SemiCartesianMonoidalCategory.fst A B)) h |
CategoryTheory.Limits.Cones.eta_hom_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cone F),
(CategoryTheory.Limits.Cones.eta c).hom.hom = CategoryTheory.CategoryStruct.id c.pt |
Filter.germSetoid | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → Filter α → (β : Type u_5) → Setoid (α → β) |
_private.Init.Data.String.Basic.0.String.Slice.Pos.next_le_of_lt._proof_1_11 | Init.Data.String.Basic | ∀ {s : String.Slice} {p q : s.Pos} {h : p ≠ s.endPos},
q.offset.byteIdx = p.offset.byteIdx + (q.offset.byteIdx - p.offset.byteIdx) →
q.offset.byteIdx - p.offset.byteIdx = 0 → p.offset.byteIdx < q.offset.byteIdx → False |
LinearPMap.instAddAction._proof_1 | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] (_f₁ _f₂ : E →ₗ[R] F) (x : E →ₗ.[R] F),
(_f₁ + _f₂) +ᵥ x = _f₁ +ᵥ _f₂ +ᵥ x |
_private.Mathlib.Geometry.Euclidean.Circumcenter.0.Affine.Simplex.sum_reflectionCircumcenterWeightsWithCircumcenter._simp_1_4 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True |
HOr.mk._flat_ctor | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HOr α β γ |
_private.Init.Data.String.Lemmas.Iterate.0.Std.Iter.toArray_eq_match_step.match_1.splitter | Init.Data.String.Lemmas.Iterate | {α β : Type u_1} →
(motive : Std.IterStep (Std.Iter β) β → Sort u_2) →
(x : Std.IterStep (Std.Iter β) β) →
((it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out)) →
((it' : Std.Iter β) → motive (Std.IterStep.skip it')) → (Unit → motive Std.IterStep.done) → motive x |
Vector.forall_mem_flatMap | Init.Data.Vector.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {n m : ℕ} {p : β → Prop} {xs : Vector α n} {f : α → Vector β m},
(∀ x ∈ xs.flatMap f, p x) ↔ ∀ a ∈ xs, ∀ b ∈ f a, p b |
_private.Lean.Compiler.LCNF.ElimDeadBranches.0.Lean.Compiler.LCNF.UnreachableBranches.Value.truncate.match_4 | Lean.Compiler.LCNF.ElimDeadBranches | (motive : ℕ → Sort u_1) →
(remainingDepth : ℕ) → (Unit → motive 0) → ((remainingDepth : ℕ) → motive remainingDepth.succ) → motive remainingDepth |
CategoryTheory.Pretriangulated.Triangle.shiftFunctor._proof_3 | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (n : ℤ) {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Pretriangulated.Triangle.mk (n.negOnePow • (CategoryTheory.shiftFunctor C n).map X.mor₁)
(n.negOnePow • (CategoryTheory.shiftFunctor C n).map X.mor₂)
(n.negOnePow •
CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C n).map X.mor₃)
((CategoryTheory.shiftFunctorComm C 1 n).hom.app X.obj₁))).mor₂
((CategoryTheory.shiftFunctor C n).map f.hom₃) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C n).map f.hom₂)
(CategoryTheory.Pretriangulated.Triangle.mk (n.negOnePow • (CategoryTheory.shiftFunctor C n).map Y.mor₁)
(n.negOnePow • (CategoryTheory.shiftFunctor C n).map Y.mor₂)
(n.negOnePow •
CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C n).map Y.mor₃)
((CategoryTheory.shiftFunctorComm C 1 n).hom.app Y.obj₁))).mor₂ |
CategoryTheory.RegularEpi.ofIso._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (e : X ≅ Y)
(s : CategoryTheory.Limits.Cofork (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.ofπ e.hom ⋯).π
((fun s => CategoryTheory.CategoryStruct.comp e.inv s.π) s) =
s.π |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_2 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → ℕ |
DFinsupp.addCommGroup._proof_4 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → AddCommGroup (β i)] (g : Π₀ (i : ι), β i), ⇑(-g) = -⇑g |
FractionalIdeal.den.eq_1 | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(I : FractionalIdeal S P), I.den = ⟨Exists.choose ⋯, ⋯⟩ |
_private.Mathlib.Analysis.Analytic.Order.0.AnalyticAt.analyticOrderAt_deriv_add_one._simp_1_4 | Mathlib.Analysis.Analytic.Order | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.