name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.Pi.ι_π_eq_id | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{β : Type w} [inst_2 : DecidableEq β] (f : β → C) [inst_3 : CategoryTheory.Limits.HasProduct f] (b : β),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.ι f b) (CategoryTheory.Limits.Pi.π f b) =
CategoryTheory.CategoryStruct.id (f b) | true |
Lean.Parser.ParserExtension.Entry.parser.sizeOf_spec | Lean.Parser.Extension | ∀ (catName declName : Lean.Name) (leading : Bool) (p : Lean.Parser.Parser) (prio : ℕ),
sizeOf (Lean.Parser.ParserExtension.Entry.parser catName declName leading p prio) =
1 + sizeOf catName + sizeOf declName + sizeOf leading + sizeOf p + sizeOf prio | true |
continuous_sup | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} [inst : TopologicalSpace L] [inst_1 : Max L] [ContinuousSup L], Continuous fun p => p.1 ⊔ p.2 | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.induct_roo_left._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ (a b : ℕ), b - a - 1 = 0 → ¬b ≤ a + 1 → False | false |
Lean.Meta.Grind.Clean.State.rec | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.Clean.State → Sort u} →
((used : Lean.PHashSet Lean.Name) → (next : Lean.PHashMap Lean.Name ℕ) → motive { used := used, next := next }) →
(t : Lean.Meta.Grind.Clean.State) → motive t | false |
IsLocalization.Away.algebraMap_pow_isUnit | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x : R)
[IsLocalization.Away x S] (n : ℕ), IsUnit ((algebraMap R S) x ^ n) | true |
Filter.mem_prod_top | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {s : Set (α × β)}, s ∈ f ×ˢ ⊤ ↔ {a | ∀ (b : β), (a, b) ∈ s} ∈ f | true |
CategoryTheory.Mon.instSymmetricCategory._proof_7 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (X Y Z : CategoryTheory.Mon C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Mon.mkIso' (β_ X.X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z).X)).hom
(CategoryTheory.MonoidalCategoryStruct.associator Y Z X).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Mon.mkIso' (β_ X.X Y.X)).hom Z)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Y X Z).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Y (CategoryTheory.Mon.mkIso' (β_ X.X Z.X)).hom)) | false |
MonoidWithZeroHom.ValueGroup₀.mk | Mathlib.Algebra.GroupWithZero.Range | {A : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
[inst : FunLike F A B] →
(f : F) →
[inst_1 : MonoidWithZero A] →
[inst_2 : CommGroupWithZero B] →
[inst_3 : MonoidWithZeroHomClass F A B] →
[DecidablePred fun b => b = 0] → A → A → MonoidWithZeroHom.ValueGroup₀ f | true |
uniformity_hasBasis_closed | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α], (uniformity α).HasBasis (fun V => V ∈ uniformity α ∧ IsClosed V) id | true |
_private.Mathlib.SetTheory.Cardinal.Finite.0.ENat.card_pos._simp_1_2 | Mathlib.SetTheory.Cardinal.Finite | ∀ (α : Type u_3), (ENat.card α ≠ 0) = Nonempty α | false |
instInhabitedRingInvo | Mathlib.RingTheory.RingInvo | (R : Type u_2) → [inst : CommRing R] → Inhabited (RingInvo R) | true |
_private.Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong.0._auto_80 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | Lean.Syntax | false |
Mathlib.Tactic.BicategoryCoherence.liftHom₂AssociatorHom | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c d : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
(h : c ⟶ d) →
[inst_1 : Mathlib.Tactic.BicategoryCoherence.LiftHom f] →
[inst_2 : Mathlib.Tactic.BicategoryCoherence.LiftHom g] →
[inst_3 : Mathlib.Tactic.BicategoryCoherence.LiftHom h] →
Mathlib.Tactic.BicategoryCoherence.LiftHom₂ (CategoryTheory.Bicategory.associator f g h).hom | true |
List.replace_of_not_mem | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {a b : α} [LawfulBEq α] {l : List α}, a ∉ l → l.replace a b = l | true |
Lean.Lsp.instFromJsonResolveSupport | Lean.Data.Lsp.Basic | Lean.FromJson Lean.Lsp.ResolveSupport | true |
Lean.Elab.Term.LValResolution.projIdx | Lean.Elab.App | Lean.Name → ℕ → Lean.Elab.Term.LValResolution | true |
pow_succ_pos._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} [PosMulStrictMono M₀],
0 < a → ∀ (n : ℕ), (0 < a ^ (n + 1)) = True | false |
FirstOrder.Language.Substructure.map_strictMono_of_injective | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N] {f : L.Hom M N},
Function.Injective ⇑f → StrictMono (FirstOrder.Language.Substructure.map f) | true |
Std.Tactic.BVDecide.BVExpr.bin.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lhs : Std.Tactic.BVDecide.BVExpr w) (op : Std.Tactic.BVDecide.BVBinOp)
(rhs lhs_1 : Std.Tactic.BVDecide.BVExpr w) (op_1 : Std.Tactic.BVDecide.BVBinOp)
(rhs_1 : Std.Tactic.BVDecide.BVExpr w),
(lhs.bin op rhs = lhs_1.bin op_1 rhs_1) = (lhs = lhs_1 ∧ op = op_1 ∧ rhs = rhs_1) | true |
sdiff_inf_right_comm | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} [inst : GeneralizedBooleanAlgebra α] (x y z : α), x \ z ⊓ y = (x ⊓ y) \ z | true |
ISize.toNatClampNeg_pos_iff | Init.Data.SInt.Lemmas | ∀ (n : ISize), 0 < n.toNatClampNeg ↔ 0 < n | true |
Int.fmod_eq_fmod_iff_fmod_sub_eq_zero | Init.Data.Int.DivMod.Lemmas | ∀ {m n k : ℤ}, m.fmod n = k.fmod n ↔ (m - k).fmod n = 0 | true |
_private.Lean.Elab.PreDefinition.WF.PackMutual.0.Lean.Elab.WF.packCalls.match_1 | Lean.Elab.PreDefinition.WF.PackMutual | (motive : Option ℕ → Sort u_1) →
(x : Option ℕ) → ((fidx : ℕ) → motive (some fidx)) → ((x : Option ℕ) → motive x) → motive x | false |
CategoryTheory.ObjectProperty.IsTriangulated.rec | Mathlib.CategoryTheory.Triangulated.Subcategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[inst_3 : CategoryTheory.Preadditive C] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : CategoryTheory.Pretriangulated C] →
{P : CategoryTheory.ObjectProperty C} →
{motive : P.IsTriangulated → Sort u} →
([toContainsZero : P.ContainsZero] →
[toIsStableUnderShift : P.IsStableUnderShift ℤ] →
[toIsTriangulatedClosed₂ : P.IsTriangulatedClosed₂] → motive ⋯) →
(t : P.IsTriangulated) → motive t | false |
_private.Mathlib.ModelTheory.Types.0.FirstOrder.Language.Theory.CompleteType.typesWith_inf._simp_1_4 | Mathlib.ModelTheory.Types | ∀ {α : Sort u_1} {p q : α → Prop}, ((∀ (x : α), p x) ∧ ∀ (x : α), q x) = ∀ (x : α), p x ∧ q x | false |
Std.Tactic.BVDecide.BVLogicalExpr.eval_ite | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {d l r : Std.Tactic.BVDecide.BoolExpr Std.Tactic.BVDecide.BVPred},
Std.Tactic.BVDecide.BVLogicalExpr.eval assign (d.ite l r) =
bif Std.Tactic.BVDecide.BVLogicalExpr.eval assign d then Std.Tactic.BVDecide.BVLogicalExpr.eval assign l
else Std.Tactic.BVDecide.BVLogicalExpr.eval assign r | true |
TProd.instMeasurableSpace._sunfold | Mathlib.MeasureTheory.MeasurableSpace.Constructions | {δ : Type u_4} →
(X : δ → Type u_6) → [(i : δ) → MeasurableSpace (X i)] → (l : List δ) → MeasurableSpace (List.TProd X l) | false |
Set.functorToTypes._proof_4 | Mathlib.CategoryTheory.Types.Set | ∀ {X : Type u_1} {X_1 Y Z : Set X} (f : X_1 ⟶ Y) (g : Y ⟶ Z),
(fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩) =
CategoryTheory.CategoryStruct.comp
(fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩)
fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩ | false |
FinBoolAlg._sizeOf_inst | Mathlib.Order.Category.FinBoolAlg | SizeOf FinBoolAlg | false |
Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor.recOn | Mathlib.Tactic.Linarith.Datatypes | {motive : Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor → Sort u} →
(t : Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor) →
((toPreprocessorBase : Mathlib.Tactic.Linarith.PreprocessorBase) →
(transform : Lean.MVarId → List Lean.Expr → Lean.MetaM (List Mathlib.Tactic.Linarith.Branch)) →
motive { toPreprocessorBase := toPreprocessorBase, transform := transform }) →
motive t | false |
_private.Lean.Elab.BuiltinDo.For.0.Lean.Elab.Do.elabDoFor.match_9 | Lean.Elab.BuiltinDo.For | (motive : Lean.Expr × Option Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Option Lean.Expr) →
((app : Lean.Expr) → (p? : Option Lean.Expr) → motive (app, p?)) → motive __discr | false |
mdifferentiableWithinAt_congr_set' | Mathlib.Geometry.Manifold.MFDeriv.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} {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'} {x : M} {s t : Set M}
(y : M), s =ᶠ[nhdsWithin x {y}ᶜ] t → (MDiffAt[s] f x ↔ MDiffAt[t] f x) | true |
AlgebraicTopology.DoldKan.Γ₀.Obj.summand | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
ChainComplex C ℕ → (Δ : SimplexCategoryᵒᵖ) → SimplicialObject.Splitting.IndexSet Δ → C | true |
MonoidAlgebra.liftNCRingHom._proof_3 | Mathlib.Algebra.MonoidAlgebra.Lift | ∀ {k : Type u_1} {G : Type u_2} {R : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Semiring R]
(f : k →+* R) (g : G →* R),
(∀ (x : k) (y : G), Commute (f x) (g y)) →
∀ (_a _b : MonoidAlgebra k G),
(MonoidAlgebra.liftNC ↑f ⇑g) (_a * _b) = (MonoidAlgebra.liftNC ↑f ⇑g) _a * (MonoidAlgebra.liftNC ↑f ⇑g) _b | false |
Std.TreeSet.min?_le_of_contains | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [inst : Std.TransCmp cmp] {k km : α}
(hc : t.contains k = true), t.min?.get ⋯ = km → (cmp km k).isLE = true | true |
OreLocalization.add_assoc | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddMonoid X] [inst_3 : DistribMulAction R X] (x y z : OreLocalization S X), x + y + z = x + (y + z) | true |
Complex.exp_int_mul_two_pi_mul_I | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℤ), Complex.exp (↑n * (2 * ↑Real.pi * Complex.I)) = 1 | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceR.match_1.eq_4 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2}
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalanceLPrecond r.size Std.DTreeMap.Internal.Impl.leaf.size → Sort u_3)
(size : ℕ) (rk : α) (rv : β rk) (size_1 : ℕ) (rlk : α) (rlv : β rlk) (l r : Std.DTreeMap.Internal.Impl α β)
(hrb :
(Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf).Balanced)
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf).size
Std.DTreeMap.Internal.Impl.leaf.size)
(h_1 :
(hrb : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond Std.DTreeMap.Internal.Impl.leaf.size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive Std.DTreeMap.Internal.Impl.leaf hrb hlr)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
(hrb :
(Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf
Std.DTreeMap.Internal.Impl.leaf).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf
Std.DTreeMap.Internal.Impl.leaf).size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf
Std.DTreeMap.Internal.Impl.leaf)
hrb hlr)
(h_3 :
(size : ℕ) →
(rk : α) →
(rv : β rk) →
(rr : Std.DTreeMap.Internal.Impl α β) →
(size_2 : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
rr = Std.DTreeMap.Internal.Impl.inner size_2 k v l r →
(hrb :
(Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_2 k v l r)).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_2 k v l r)).size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive
(Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_2 k v l r))
hrb hlr)
(h_4 :
(size : ℕ) →
(rk : α) →
(rv : β rk) →
(size_2 : ℕ) →
(rlk : α) →
(rlv : β rlk) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(hrb :
(Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_2 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner size rk rv
(Std.DTreeMap.Internal.Impl.inner size_2 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf).size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive
(Std.DTreeMap.Internal.Impl.inner size rk rv
(Std.DTreeMap.Internal.Impl.inner size_2 rlk rlv l r) Std.DTreeMap.Internal.Impl.leaf)
hrb hlr)
(h_5 :
(rs : ℕ) →
(rk : α) →
(rv : β rk) →
(rls : ℕ) →
(rlk : α) →
(rlv : β rlk) →
(rll rlr : Std.DTreeMap.Internal.Impl α β) →
(rrs : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(hrb :
(Std.DTreeMap.Internal.Impl.inner rs rk rv
(Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr)
(Std.DTreeMap.Internal.Impl.inner rrs k v l r)).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner rs rk rv
(Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr)
(Std.DTreeMap.Internal.Impl.inner rrs k v l r)).size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive
(Std.DTreeMap.Internal.Impl.inner rs rk rv
(Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr)
(Std.DTreeMap.Internal.Impl.inner rrs k v l r))
hrb hlr),
(match
Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf,
hrb, hlr with
| Std.DTreeMap.Internal.Impl.leaf, hrb, hlr => h_1 hrb hlr
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf, hrb,
hlr => h_2 size k v hrb hlr
|
Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf
rr@h:(Std.DTreeMap.Internal.Impl.inner size_2 k v l r),
hrb, hlr => h_3 size rk rv rr size_2 k v l r h hrb hlr
|
Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_2 rlk rlv l r)
Std.DTreeMap.Internal.Impl.leaf,
hrb, hlr => h_4 size rk rv size_2 rlk rlv l r hrb hlr
|
Std.DTreeMap.Internal.Impl.inner rs rk rv (Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr)
(Std.DTreeMap.Internal.Impl.inner rrs k v l r),
hrb, hlr => h_5 rs rk rv rls rlk rlv rll rlr rrs k v l r hrb hlr) =
h_4 size rk rv size_1 rlk rlv l r hrb hlr | true |
CategoryTheory.Cat.FreeRefl.instUnique._proof_3 | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ (V : Type u_1) [inst : CategoryTheory.ReflQuiver V] [inst_1 : Unique V] (a : CategoryTheory.Cat.FreeRefl V),
a = default | false |
_private.Mathlib.Data.Int.CardIntervalMod.0.Nat.Ico_filter_modEq_cast._simp_1_3 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.posSemidef_tfae.match_1_1 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {h p1 : Prop} (motive : h ∧ p1 → Prop) (x : h ∧ p1), (∀ (h_1 : h) (t : p1), motive ⋯) → motive x | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk₄_app_three._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ¬3 < 4 + 1 → False | false |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.elabForIn.match_1 | Lean.Elab.Extra | (motive : Lean.LOption Lean.Expr → Sort u_1) →
(__do_lift : Lean.LOption Lean.Expr) →
((inst : Lean.Expr) → motive (Lean.LOption.some inst)) →
(Unit → motive Lean.LOption.undef) → (Unit → motive Lean.LOption.none) → motive __do_lift | false |
_private.Lean.PrettyPrinter.Formatter.0.Lean.PrettyPrinter.Formatter.withMaybeTag.match_4 | Lean.PrettyPrinter.Formatter | (motive : Option String.Pos.Raw → Sort u_1) →
(pos? : Option String.Pos.Raw) →
((p : String.Pos.Raw) → motive (some p)) → ((x : Option String.Pos.Raw) → motive x) → motive pos? | false |
_private.Mathlib.Geometry.Manifold.VectorField.Pullback.0.VectorField.mpullback_zero._simp_1_1 | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSpace H']
{E' : Type u_6} [inst_7 : NormedAddCommGroup E'] [inst_8 : NormedSpace 𝕜 E'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'}
{V : (x : M') → TangentSpace I' x}, VectorField.mpullback I I' f V = VectorField.mpullbackWithin I I' f V Set.univ | false |
CategoryTheory.Functor.mapSquare._proof_6 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) (X : CategoryTheory.Square C),
{ τ₁ := F.map (CategoryTheory.CategoryStruct.id X).τ₁, τ₂ := F.map (CategoryTheory.CategoryStruct.id X).τ₂,
τ₃ := F.map (CategoryTheory.CategoryStruct.id X).τ₃, τ₄ := F.map (CategoryTheory.CategoryStruct.id X).τ₄,
comm₁₂ := ⋯, comm₁₃ := ⋯, comm₂₄ := ⋯, comm₃₄ := ⋯ } =
CategoryTheory.CategoryStruct.id (X.map F) | false |
PartOrdEmb.hasForgetToPartOrd._proof_4 | Mathlib.Order.Category.PartOrdEmb | { obj := fun X => { carrier := ↑X, str := X.str }, map := fun {X Y} f => PartOrd.ofHom ↑(PartOrdEmb.Hom.hom f),
map_id := PartOrdEmb.hasForgetToPartOrd._proof_1, map_comp := @PartOrdEmb.hasForgetToPartOrd._proof_2 }.comp
(CategoryTheory.forget PartOrd) =
CategoryTheory.forget PartOrdEmb | false |
Filter.ker_surjective | Mathlib.Order.Filter.Ker | ∀ {α : Type u_2}, Function.Surjective Filter.ker | true |
MeasureTheory.Lp.smul_neg | Mathlib.MeasureTheory.Function.Holder | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q r : ENNReal}
[hpqr : p.HolderTriple q r] [inst : NormedRing 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : IsBoundedSMul 𝕜 E] (f : ↥(MeasureTheory.Lp 𝕜 p μ)) (g : ↥(MeasureTheory.Lp E q μ)), f • -g = -(f • g) | true |
Lean.Lsp.SymbolTag.deprecated | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolTag | true |
Con.subgroup_quotientGroupCon | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [inst_1 : H.Normal], (QuotientGroup.con H).subgroup = H | true |
WeierstrassCurve.map_preΨ₄ | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} {S : Type s} [inst : CommRing R] [inst_1 : CommRing S] (W : WeierstrassCurve R) (f : R →+* S),
(W.map f).preΨ₄ = Polynomial.map f W.preΨ₄ | true |
nsmulBinRec.go_spec | Mathlib.Algebra.Group.Defs | ∀ {M : Type u_2} [inst : AddSemigroup M] [inst_1 : Zero M] (k : ℕ) (m n : M),
nsmulBinRec.go (k + 1) m n = m + nsmulRec' (k + 1) n | true |
Std.TreeSet.insertMany_list_equiv_foldl | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ : Std.TreeSet α cmp} {l : List α},
(t₁.insertMany l).Equiv (List.foldl (fun acc a => acc.insert a) t₁ l) | true |
Plausible.Configuration.quiet | Plausible.Testable | Plausible.Configuration → Bool | true |
FixedPoints.instAlgebraSubtypeMemSubfieldSubfield | Mathlib.FieldTheory.Fixed | (M : Type u) →
[inst : Monoid M] →
(F : Type v) → [inst_1 : Field F] → [inst_2 : MulSemiringAction M F] → Algebra (↥(FixedPoints.subfield M F)) F | true |
Std.Internal.List.getValueD_filter_not_contains_of_contains_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ : List ((_ : α) × β)} {l₂ : List α} {k : α} {fallback : β},
Std.Internal.List.DistinctKeys l₁ →
l₂.contains k = true →
Std.Internal.List.getValueD k (List.filter (fun p => !l₂.contains p.fst) l₁) fallback = fallback | true |
Units.map._proof_4 | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_2} {N : Type u_1} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (x x_1 : Mˣ),
↑((fun u => { val := f ↑u, inv := f u.inv, val_inv := ⋯, inv_val := ⋯ }) (x * x_1)) =
↑((fun u => { val := f ↑u, inv := f u.inv, val_inv := ⋯, inv_val := ⋯ }) x *
(fun u => { val := f ↑u, inv := f u.inv, val_inv := ⋯, inv_val := ⋯ }) x_1) | false |
_private.Mathlib.Data.List.NodupEquivFin.0.List.sublist_iff_exists_fin_orderEmbedding_get_eq._proof_1_5 | Mathlib.Data.List.NodupEquivFin | ∀ {α : Type u_1} {l l' : List α} (f : Fin l.length ↪o Fin l'.length) (ix : ℕ),
(OrderEmbedding.ofStrictMono (fun i => if h : i + 1 ≤ l.length then ↑(f ⟨i, ⋯⟩) else i + l'.length) ⋯) ix + 1 ≤
l'.length →
(OrderEmbedding.ofStrictMono (fun i => if h : i + 1 ≤ l.length then ↑(f ⟨i, ⋯⟩) else i + l'.length) ⋯) ix <
l'.length | false |
DedekindCut.instCompleteLinearOrder._proof_7 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Set (DedekindCut α)), IsLUB s (sSup s) | false |
CategoryTheory.Equivalence.unitIso_hom_app_comp_inverse_map_η_functor_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] (e : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal] {Z : C}
(h : e.inverse.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit D) ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.unitIso.hom.app (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
(CategoryTheory.CategoryStruct.comp (e.inverse.map (CategoryTheory.Functor.OplaxMonoidal.η e.functor)) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε e.inverse) h | true |
Lean.Meta.Grind.Arith.Cutsat.UnsatProof.ctorElimType | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_12 : Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u} → ℕ → Sort (max 1 u) | false |
Std.DHashMap.getD_eq_fallback | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {a : α}
{fallback : β a}, a ∉ m → m.getD a fallback = fallback | true |
AlgebraicGeometry.PresheafedSpace.isIso_of_components | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Y)
[CategoryTheory.IsIso f.base] [CategoryTheory.IsIso f.c], CategoryTheory.IsIso f | true |
Lean.Meta.Grind.SavedState | Lean.Meta.Tactic.Grind.Types | Type | true |
WithLp.toLp_zero | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) {V : Type u_4} [inst : AddCommGroup V], WithLp.toLp p 0 = 0 | true |
HasCompactMulSupport.sup | Mathlib.Topology.Algebra.Order.Support | ∀ {X : Type u_1} {M : Type u_2} [inst : TopologicalSpace X] [inst_1 : One M] [inst_2 : SemilatticeSup M] {f g : X → M},
HasCompactMulSupport f → HasCompactMulSupport g → HasCompactMulSupport (f ⊔ g) | true |
IsLUB.exists_between_sub_self' | Mathlib.Algebra.Order.Group.Bounds | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] {s : Set α} {a ε : α},
IsLUB s a → a ∉ s → 0 < ε → ∃ b ∈ s, a - ε < b ∧ b < a | true |
Lean.Meta.SparseCasesOnInfo.rec | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnInfo → Sort u} →
((indName : Lean.Name) →
(majorPos arity : ℕ) →
(insterestingCtors : Array Lean.Name) →
motive { indName := indName, majorPos := majorPos, arity := arity, insterestingCtors := insterestingCtors }) →
(t : Lean.Meta.SparseCasesOnInfo) → motive t | false |
Mathlib.Tactic.Ring.neg_one_mul | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_2} [inst : CommRing R] {a b : R}, (Int.negOfNat 1).rawCast * a = b → -a = b | true |
_private.Lean.Elab.DocString.0.Lean.Doc.initFn._@.Lean.Elab.DocString.2101956971._hygCtx._hyg.2 | Lean.Elab.DocString | IO Unit | false |
fderiv_tsum_apply | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedAddCommGroup F] [CompleteSpace F]
{u : α → ℝ} [inst_6 : NormedSpace 𝕜 F] {f : α → E → F} {x₀ : E},
Summable u →
(∀ (n : α), Differentiable 𝕜 (f n)) →
(∀ (n : α) (x : E), ‖fderiv 𝕜 (f n) x‖ ≤ u n) →
(Summable fun n => f n x₀) → ∀ (x : E), fderiv 𝕜 (fun y => ∑' (n : α), f n y) x = ∑' (n : α), fderiv 𝕜 (f n) x | true |
_private.Init.Data.Array.Find.0.Array.idxOf?.eq_1 | Init.Data.Array.Find | ∀ {α : Type u} [inst : BEq α] (xs : Array α) (v : α), xs.idxOf? v = Option.map (fun x => ↑x) (xs.finIdxOf? v) | true |
DirectSum.decompose_of_mem_same | Mathlib.Algebra.DirectSum.Decomposition | ∀ {ι : Type u_1} {M : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : SetLike σ M]
[inst_3 : AddSubmonoidClass σ M] (ℳ : ι → σ) [inst_4 : DirectSum.Decomposition ℳ] {x : M} {i : ι},
x ∈ ℳ i → ↑(((DirectSum.decompose ℳ) x) i) = x | true |
CategoryTheory.Functor.Faithful.of_comp_eq | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [ℋ : H.Faithful], F.comp G = H → F.Faithful | true |
Lean.indentExpr | Lean.Message | Lean.Expr → Lean.MessageData | true |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T)
{X_1 Y_1 : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X} (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id (CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X)).map
f)
((fun x =>
CategoryTheory.Iso.refl
((CategoryTheory.Functor.id
(CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X)).obj
x))
Y_1).hom =
CategoryTheory.CategoryStruct.comp
((fun x =>
CategoryTheory.Iso.refl
((CategoryTheory.Functor.id
(CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X)).obj
x))
X_1).hom
(((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor F Y X).comp
(CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse F Y X)).map
f) | false |
CompHausLike.instHasPropSigma | Mathlib.Topology.Category.CompHausLike.SigmaComparison | ∀ {P : TopCat → Prop} [CompHausLike.HasExplicitFiniteCoproducts P] {α : Type u} [Finite α] (σ : α → Type u)
[inst : (a : α) → TopologicalSpace (σ a)] [∀ (a : α), CompactSpace (σ a)] [∀ (a : α), T2Space (σ a)]
[∀ (a : α), CompHausLike.HasProp P (σ a)], CompHausLike.HasProp P ((a : α) × σ a) | true |
CategoryTheory.Limits.IsColimit.mono_ι_app_of_isFiltered | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Colim | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} J]
{X : CategoryTheory.Functor J C} [∀ (j j' : J) (φ : j ⟶ j'), CategoryTheory.Mono (X.map φ)]
{c : CategoryTheory.Limits.Cocone X} (hc : CategoryTheory.Limits.IsColimit c) [CategoryTheory.IsFiltered J] (j₀ : J)
[inst_4 : CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Under j₀) C]
[CategoryTheory.Limits.colim.PreservesMonomorphisms], CategoryTheory.Mono (c.ι.app j₀) | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.synthInstanceCore?.match_3 | Lean.Meta.SynthInstance | (motive : Option (Option Lean.Meta.AbstractMVarsResult) → Sort u_1) →
(x : Option (Option Lean.Meta.AbstractMVarsResult)) →
((abstResult? : Option Lean.Meta.AbstractMVarsResult) → motive (some abstResult?)) → (Unit → motive none) → motive x | false |
GaloisInsertion.recOn | Mathlib.Order.GaloisConnection.Defs | {α : Type u_2} →
{β : Type u_3} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
{l : α → β} →
{u : β → α} →
{motive : GaloisInsertion l u → Sort u} →
(t : GaloisInsertion l u) →
((choice : (x : α) → u (l x) ≤ x → β) →
(gc : GaloisConnection l u) →
(le_l_u : ∀ (x : β), x ≤ l (u x)) →
(choice_eq : ∀ (a : α) (h : u (l a) ≤ a), choice a h = l a) →
motive { choice := choice, gc := gc, le_l_u := le_l_u, choice_eq := choice_eq }) →
motive t | false |
CochainComplex.mkAux._proof_2 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(X₀ X₁ X₂ : V) (d₀ : X₀ ⟶ X₁) (d₁ : X₁ ⟶ X₂) (s : CategoryTheory.CategoryStruct.comp d₀ d₁ = 0)
(succ :
(S : CategoryTheory.ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ ⟶ X₄) ×' CategoryTheory.CategoryStruct.comp S.g d₂ = 0)
(n : ℕ),
CategoryTheory.CategoryStruct.comp (CochainComplex.mkAux X₀ X₁ X₂ d₀ d₁ s succ n).g
(succ (CochainComplex.mkAux X₀ X₁ X₂ d₀ d₁ s succ n)).snd.fst =
0 | false |
_private.Mathlib.MeasureTheory.Function.AEMeasurableSequence.0.aeSeq.measure_compl_aeSeqSet_eq_zero._simp_1_3 | Mathlib.MeasureTheory.Function.AEMeasurableSequence | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {ι : Sort u_4} [Countable ι] {p : α → ι → Prop},
(∀ (i : ι), ∀ᵐ (a : α) ∂μ, p a i) = ∀ᵐ (a : α) ∂μ, ∀ (i : ι), p a i | false |
MeasureTheory.NullMeasurableSet.diff._simp_1 | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
MeasureTheory.NullMeasurableSet s μ →
MeasureTheory.NullMeasurableSet t μ → MeasureTheory.NullMeasurableSet (s \ t) μ = True | false |
ProbabilityTheory.condIndepFun_self_right | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {mβ : MeasurableSpace β}
{mβ' : MeasurableSpace β'} {X : Ω → β} {Z : Ω → β'},
Measurable X → ∀ (hZ : Measurable Z), ProbabilityTheory.CondIndepFun (MeasurableSpace.comap Z inferInstance) ⋯ X Z μ | true |
Int.add_one_tdiv_of_pos | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 < b → (a + 1).tdiv b = a.tdiv b + if 0 < a + 1 ∧ b ∣ a + 1 ∨ a < 0 ∧ b ∣ a then 1 else 0 | true |
Qq.Impl.stripDollars | Qq.Macro | Lean.Name → Lean.Name | true |
AlgEquiv.aut._proof_10 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A₁ : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁]
(ϕ : A₁ ≃ₐ[R] A₁), ϕ.symm * ϕ = 1 | false |
_private.Init.Data.List.Find.0.List.findIdx_lt_length_of_exists._simp_1_2 | Init.Data.List.Find | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
CategoryTheory.Enriched.FunctorCategory.homEquiv._proof_7 | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{C : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1}
[inst_3 : CategoryTheory.Category.{u_4, u_1} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C]
{F₁ F₂ : CategoryTheory.Functor J C} [inst_5 : CategoryTheory.Enriched.FunctorCategory.HasEnrichedHom V F₁ F₂]
(τ : F₁ ⟶ F₂),
(fun g =>
{
app := fun j =>
(CategoryTheory.eHomEquiv V).symm
(CategoryTheory.CategoryStruct.comp g
(CategoryTheory.Limits.end_.π (CategoryTheory.Enriched.FunctorCategory.diagram V F₁ F₂) j)),
naturality := ⋯ })
((fun τ => CategoryTheory.Limits.end_.lift (fun j => (CategoryTheory.eHomEquiv V) (τ.app j)) ⋯) τ) =
τ | false |
SummationFilter.tprod_symmetricIcc_eq_tprod_symmetricIco | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ {α : Type u_1} {f : ℤ → α} [inst : CommGroup α] [inst_1 : TopologicalSpace α] [ContinuousMul α] [T2Space α],
Multipliable f (SummationFilter.symmetricIcc ℤ) →
Filter.Tendsto (fun N => (f ↑N)⁻¹) Filter.atTop (nhds 1) →
∏'[SummationFilter.symmetricIco ℤ] (b : ℤ), f b = ∏'[SummationFilter.symmetricIcc ℤ] (b : ℤ), f b | true |
Std.DTreeMap.Internal.Impl.minKeyD_insert_le_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{k : α} {v : β k} {fallback : α},
(compare ((Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl.minKeyD fallback) k).isLE = true | true |
eventually_le_nhds | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α] {a b : α},
a < b → ∀ᶠ (x : α) in nhds a, x ≤ b | true |
IsArtinianRing.quotNilradicalEquivPi._proof_1 | Mathlib.RingTheory.Artinian.Module | ∀ (R : Type u_1) [inst : CommRing R] [IsArtinianRing R] (x : R), x ∈ nilradical R ↔ x ∈ ⨅ i, i.asIdeal | false |
BoundedGENhdsClass.mk | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_7} [inst : Preorder α] [inst_1 : TopologicalSpace α],
(∀ (a : α), Filter.IsBounded (fun x1 x2 => x1 ≥ x2) (nhds a)) → BoundedGENhdsClass α | true |
AlgebraicGeometry.Scheme.instOverXPullbackCoverOverProp' | Mathlib.AlgebraicGeometry.Cover.Over | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
(S : AlgebraicGeometry.Scheme) →
[inst : P.IsStableUnderBaseChange] →
[inst_1 : AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
{X W : AlgebraicGeometry.Scheme} →
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) →
(f : W ⟶ X) →
[inst_2 : W.Over S] →
[inst_3 : X.Over S] →
[inst_4 : AlgebraicGeometry.Scheme.Cover.Over S 𝒰] →
[inst_5 : AlgebraicGeometry.Scheme.Hom.IsOver f S] →
{Q : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
[inst_6 : Q.HasOfPostcompProperty Q] →
[inst_7 : Q.IsStableUnderBaseChange] →
[inst_8 : Q.IsStableUnderComposition] →
(hX : Q (X ↘ S)) →
(hW : Q (W ↘ S)) →
(hQ : ∀ (j : 𝒰.I₀), Q (𝒰.X j ↘ S)) →
(j : 𝒰.I₀) →
((AlgebraicGeometry.Scheme.Cover.pullbackCoverOverProp' S 𝒰 f hX hW hQ).X j).Over
S | true |
_private.Mathlib.Order.WithBot.0.WithBot.le_of_forall_lt_iff_le._simp_1_1 | Mathlib.Order.WithBot | ∀ {α : Type u_3} {inst : LT α} [self : NoMinOrder α] (a : α), (∃ b, b < a) = True | false |
sdiff_sdiff_sdiff_cancel_right | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], z ≤ y → (x \ z) \ (y \ z) = x \ y | true |
Lean.Meta.Grind.Arith.Linear.ProofM.State.mk._flat_ctor | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | Std.HashMap UInt64 Lean.Expr →
Std.HashMap Lean.Grind.Linarith.Var Lean.Expr →
Std.HashMap Lean.Grind.Linarith.Poly Lean.Expr →
Std.HashMap Lean.Meta.Grind.Arith.Linear.LinExpr Lean.Expr →
Std.HashMap Lean.Grind.CommRing.Poly Lean.Expr →
Std.HashMap Lean.Meta.Grind.Arith.CommRing.RingExpr Lean.Expr →
Std.HashMap Lean.Grind.Linarith.Var Lean.Expr → Lean.Meta.Grind.Arith.Linear.ProofM.State | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.