name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Filter.bliminf_eq_liminf_subtype | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {p : β → Prop},
Filter.bliminf u f p = Filter.liminf (u ∘ Subtype.val) (Filter.comap Subtype.val f) | true |
Lean.PrettyPrinter.OneLine.State._sizeOf_1 | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.OneLine.State → ℕ | false |
AddOpposite.instAddCommMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : AddCommMonoid α],
AddOpposite.instAddCommMonoid = { toAddMonoid := AddOpposite.instAddMonoid, add_comm := ⋯ } | true |
FirstOrder.Field.FieldAxiom.toSentence._proof_3 | Mathlib.ModelTheory.Algebra.Field.Basic | NeZero (0 + 1 + 1) | false |
Subsemiring.instSMulWithZeroSubtypeMem | Mathlib.Algebra.Ring.Subsemiring.Basic | {R' : Type u_1} →
{α : Type u_2} →
[inst : NonAssocSemiring R'] →
{S' : Type u_5} →
[inst_1 : SetLike S' R'] →
[inst_2 : SubsemiringClass S' R'] → (s : S') → [inst_3 : Zero α] → [SMulWithZero R' α] → SMulWithZero (↥s) α | true |
_private.Mathlib.Algebra.Group.Units.Defs.0.AddUnits.isAddUnit_add_addUnits.match_1_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] (a : M) (u : AddUnits M) (motive : IsAddUnit (a + ↑u) → Prop)
(x : IsAddUnit (a + ↑u)), (∀ (v : AddUnits M) (hv : ↑v = a + ↑u), motive ⋯) → motive x | false |
instAddCommGroupPadic._proof_14 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (a : ℚ_[p]), -a + a = 0 | false |
StieltjesFunction.mono' | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (self : StieltjesFunction R), Monotone ↑self | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty.0.SimplexCategory.Truncated.morphismProperty_eq_top._proof_1 | Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty | ∀ {d : ℕ}, ∀ n < d, n ≤ d | false |
CategoryTheory.yonedaMonObjIsoOfRepresentableBy._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C) (F : CategoryTheory.Functor Cᵒᵖ MonCat) (α : (F.comp (CategoryTheory.forget MonCat)).RepresentableBy X)
{X_1 Y : Cᵒᵖ} (φ : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.yonedaMonObj X).map φ)
{ toEquiv := α.homEquiv, map_mul' := ⋯ }.toMonCatIso.hom =
CategoryTheory.CategoryStruct.comp { toEquiv := α.homEquiv, map_mul' := ⋯ }.toMonCatIso.hom (F.map φ) | false |
_private.Mathlib.NumberTheory.DiophantineApproximation.Basic.0.Real.aux₁._proof_1_8 | Mathlib.NumberTheory.DiophantineApproximation.Basic | ∀ {v : ℤ}, 2 ≤ v → v = 1 → False | false |
ContinuousAt.snd' | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : Y → Z} {x : X} {y : Y}, ContinuousAt f y → ContinuousAt (fun x => f x.2) (x, y) | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.minEntry?_insertEntry._simp_1_5 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α},
(cmp a b = Ordering.gt) = (cmp b a = Ordering.lt) | false |
irreducible_pow_sup_of_ge | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {T : Type u_4} [inst : CommRing T] [IsDedekindDomain T] {I J : Ideal T},
I ≠ ⊥ → Irreducible J → ∀ (n : ℕ), emultiplicity J I ≤ ↑n → J ^ n ⊔ I = J ^ multiplicity J I | true |
circleAverage_log_norm_sub_const₂ | Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage | ∀ {a : ℂ}, 1 < ‖a‖ → Real.circleAverage (fun x => Real.log ‖x - a‖) 0 1 = Real.log ‖a‖ | true |
RegularWreathProduct | Mathlib.GroupTheory.RegularWreathProduct | Type u_1 → Type u_2 → Type (max u_1 u_2) | true |
MeasurableSet.setOf_infinite | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [Countable α], MeasurableSet {s | s.Infinite} | true |
SetRel.finiteDimensional_iff | Mathlib.Order.RelSeries | ∀ {α : Type u_1} (r : SetRel α α), r.FiniteDimensional ↔ ∃ x, ∀ (y : RelSeries r), y.length ≤ x.length | true |
Multiset.countP_False | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} {s : Multiset α}, Multiset.countP (fun x => False) s = 0 | true |
Lean.RecursorVal.mk._flat_ctor | Lean.Declaration | Lean.Name →
List Lean.Name → Lean.Expr → List Lean.Name → ℕ → ℕ → ℕ → ℕ → List Lean.RecursorRule → Bool → Bool → Lean.RecursorVal | false |
Lean.RecursorRule.mk.injEq | Lean.Declaration | ∀ (ctor : Lean.Name) (nfields : ℕ) (rhs : Lean.Expr) (ctor_1 : Lean.Name) (nfields_1 : ℕ) (rhs_1 : Lean.Expr),
({ ctor := ctor, nfields := nfields, rhs := rhs } = { ctor := ctor_1, nfields := nfields_1, rhs := rhs_1 }) =
(ctor = ctor_1 ∧ nfields = nfields_1 ∧ rhs = rhs_1) | true |
AdicCompletion.instAlgebra._proof_6 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (I : Ideal R) [inst_2 : Algebra S R]
(x y : S),
⟨(algebraMap S ((n : ℕ) → R ⧸ I ^ n • ⊤)) (x * y), ⋯⟩ =
⟨(algebraMap S ((n : ℕ) → R ⧸ I ^ n • ⊤)) x, ⋯⟩ * ⟨(algebraMap S ((n : ℕ) → R ⧸ I ^ n • ⊤)) y, ⋯⟩ | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insertIfNew._proof_1 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (t : Std.DTreeMap.Internal.Impl α β), ¬t.size ≤ t.size → False | false |
CategoryTheory.Functor.CoconeTypes.IsColimitCore.ctorIdx | Mathlib.CategoryTheory.Limits.Types.ColimitType | {J : Type u} →
{inst : CategoryTheory.Category.{v, u} J} →
{F : CategoryTheory.Functor J (Type w₀)} → {c : F.CoconeTypes} → c.IsColimitCore → ℕ | false |
CategoryTheory.ChosenPullbacksAlong.isoInv_pullback_obj_right_as | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y X : C} (f : Y ≅ X) (Z : CategoryTheory.Over Y),
((CategoryTheory.ChosenPullbacksAlong.pullback f.inv).obj Z).right.as = PUnit.unit | true |
List.get_permutations'Aux | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} (s : List α) (x : α) (n : ℕ) (hn : n < (List.permutations'Aux x s).length),
(List.permutations'Aux x s).get ⟨n, hn⟩ = s.insertIdx n x | true |
Ideal.pow_multiset_sum_mem_span_pow | Mathlib.RingTheory.Ideal.Basic | ∀ {α : Type u_2} [inst : CommSemiring α] [inst_1 : DecidableEq α] (s : Multiset α) (n : ℕ),
s.sum ^ (s.card * n + 1) ∈ Ideal.span ↑(Multiset.map (fun x => x ^ (n + 1)) s).toFinset | true |
conditionallyCompleteLatticeOfLatticeOfsSup._proof_2 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [H1 : Lattice α] (a b : α), ∃ x, x ∈ lowerBounds {a, b} | false |
AffineMap.pi | Mathlib.LinearAlgebra.AffineSpace.AffineMap | {k : Type u_2} →
{V1 : Type u_3} →
{P1 : Type u_4} →
[inst : Ring k] →
[inst_1 : AddCommGroup V1] →
[inst_2 : AddTorsor V1 P1] →
[inst_3 : Module k V1] →
{ι : Type u_9} →
{φv : ι → Type u_10} →
{φp : ι → Type u_11} →
[inst_4 : (i : ι) → AddCommGroup (φv i)] →
[inst_5 : (i : ι) → Module k (φv i)] →
[inst_6 : (i : ι) → AddTorsor (φv i) (φp i)] →
((i : ι) → P1 →ᵃ[k] φp i) → P1 →ᵃ[k] (i : ι) → φp i | true |
Submonoid.mem_op._simp_2 | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] {x : Mᵐᵒᵖ} {S : Submonoid M}, (x ∈ S.op) = (MulOpposite.unop x ∈ S) | false |
_private.Mathlib.Algebra.Homology.SpectralSequence.Basic.0.CategoryTheory.SpectralSequence._proof_9 | Mathlib.Algebra.Homology.SpectralSequence.Basic | ∀ (r₀ r r' : ℤ),
autoParam (r + 1 = r') CategoryTheory.SpectralSequence._auto_3 →
autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence._auto_5 → r₀ ≤ r' | false |
Std.ExtTreeMap.minKey_insert_of_isEmpty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, t.isEmpty = true → (t.insert k v).minKey ⋯ = k | true |
convexHullAddMonoidHom._proof_1 | Mathlib.Analysis.Convex.Combination | ∀ (R : Type u_2) (E : Type u_1) [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
[inst_3 : LinearOrder R], (convexHull R) 0 = 0 | false |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.forIn'_eq_match_step.match_3.splitter | Init.Data.Iterators.Lemmas.Consumers.Loop | {α β : Type u_1} →
[inst : Std.Iterator α Id β] →
{it : Std.Iter β} →
(motive : it.Step → Sort u_2) →
(x : it.Step) →
((it' : Std.Iter β) →
(out : β) →
(h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' out, h⟩) →
((it' : Std.Iter β) →
(h : it.IsPlausibleStep (Std.IterStep.skip it')) → motive ⟨Std.IterStep.skip it', h⟩) →
((property : it.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, property⟩) → motive x | true |
Sublattice.mem_iInf | Mathlib.Order.Sublattice | ∀ {ι : Sort u_1} {α : Type u_2} [inst : Lattice α] {a : α} {f : ι → Sublattice α}, a ∈ ⨅ i, f i ↔ ∀ (i : ι), a ∈ f i | true |
LinearMap.sub_mem_ker_iff | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {x y : M}, x - y ∈ f.ker ↔ f x = f y | true |
MultilinearMap.dfinsuppFamily_compLinearMap_lsingle | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {ι : Type uι} {κ : ι → Type uκ} {R : Type uR} {M : (i : ι) → κ i → Type uM} {N : ((i : ι) → κ i) → Type uN}
[inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : Semiring R]
[inst_3 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)] [inst_4 : (p : (i : ι) → κ i) → AddCommMonoid (N p)]
[inst_5 : (i : ι) → (k : κ i) → Module R (M i k)] [inst_6 : (p : (i : ι) → κ i) → Module R (N p)]
[inst_7 : (i : ι) → DecidableEq (κ i)] (f : (p : (i : ι) → κ i) → MultilinearMap R (fun i => M i (p i)) (N p))
(p : (i : ι) → κ i),
((MultilinearMap.dfinsuppFamily f).compLinearMap fun i => DFinsupp.lsingle (p i)) =
(DFinsupp.lsingle p).compMultilinearMap (f p) | true |
Submodule.Quotient.module'._proof_2 | Mathlib.LinearAlgebra.Quotient.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (P : Submodule R M)
(x x_1 : M), Submodule.Quotient.mk (x + x_1) = Submodule.Quotient.mk x + Submodule.Quotient.mk x_1 | false |
_private.Mathlib.Analysis.Normed.Algebra.Exponential.0.NormedSpace.star_exp._simp_1_2 | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (x : R) (n : ℕ), star x ^ n = star (x ^ n) | false |
Mathlib.Tactic.BicategoryCoherence.assoc_liftHom₂ | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f g h i : a ⟶ b}
[inst_1 : Mathlib.Tactic.BicategoryCoherence.LiftHom f] [inst_2 : Mathlib.Tactic.BicategoryCoherence.LiftHom g]
[inst_3 : Mathlib.Tactic.BicategoryCoherence.LiftHom h] (η : f ⟶ g) (θ : g ⟶ h) (ι : h ⟶ i)
[Mathlib.Tactic.BicategoryCoherence.LiftHom₂ η] [Mathlib.Tactic.BicategoryCoherence.LiftHom₂ θ],
CategoryTheory.CategoryStruct.comp η (CategoryTheory.CategoryStruct.comp θ ι) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp η θ) ι | true |
CategoryTheory.uliftYonedaEquiv._proof_4 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X : C}
{F : CategoryTheory.Functor Cᵒᵖ (Type (max u_3 u_2))} (τ : CategoryTheory.uliftYoneda.{u_3, u_2, u_1}.obj X ⟶ F),
(fun x => { app := fun Y y => F.map (Quiver.Hom.op y.down) x, naturality := ⋯ })
((fun τ => τ.app (Opposite.op X) { down := CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.op X)) })
τ) =
τ | false |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.add_factorial_succ_lt_factorial_add_succ._proof_1_3 | Mathlib.Data.Nat.Factorial.Basic | ∀ {i : ℕ} (n : ℕ), 2 ≤ i → i + n ≤ (i + n).factorial → 1 < (i + n).factorial | false |
AlgebraicGeometry.Scheme.openCoverOfIsOpenCover | Mathlib.AlgebraicGeometry.Restrict | {s : Type u_1} → (X : AlgebraicGeometry.Scheme) → (U : s → X.Opens) → TopologicalSpace.IsOpenCover U → X.OpenCover | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.RedRed.imp.match_1_1 | Batteries.Data.RBMap.WF | ∀ {p : Prop} {α : Type u_1} {n : ℕ} (motive : (t : Batteries.RBNode α) → Batteries.RBNode.RedRed p t n → Prop)
(t : Batteries.RBNode α) (x : Batteries.RBNode.RedRed p t n),
(∀ (t : Batteries.RBNode α) (c : Batteries.RBColor) (h : t.Balanced c n), motive t ⋯) →
(∀ (a : Batteries.RBNode α) (c₁ : Batteries.RBColor) (b : Batteries.RBNode α) (c₂ : Batteries.RBColor) (x : α)
(hp : p) (ha : a.Balanced c₁ n) (hb : b.Balanced c₂ n),
motive (Batteries.RBNode.node Batteries.RBColor.red a x b) ⋯) →
motive t x | false |
_private.Mathlib.RingTheory.Polynomial.GaussNorm.0.Polynomial.gaussNorm_zero_right._simp_1_4 | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] {s : Finset β} (H : s.Nonempty) (f : β → α) {a : α},
(s.sup' H f ≤ a) = ∀ b ∈ s, f b ≤ a | false |
CategoryTheory.ComposableArrows.homMk_app | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n}
(app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i)
(w :
∀ (i : ℕ) (hi : i < n),
CategoryTheory.CategoryStruct.comp (F.map' i (i + 1) ⋯ hi) (app ⟨i + 1, ⋯⟩) =
CategoryTheory.CategoryStruct.comp (app ⟨i, ⋯⟩) (G.map' i (i + 1) ⋯ hi))
(i : Fin (n + 1)), (CategoryTheory.ComposableArrows.homMk app w).app i = app i | true |
MulActionWithZero.rec | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
[inst : MonoidWithZero M₀] →
[inst_1 : Zero A] →
{motive : MulActionWithZero M₀ A → Sort u} →
([toMulAction : MulAction M₀ A] →
(smul_zero : ∀ (r : M₀), r • 0 = 0) →
(zero_smul : ∀ (m : A), 0 • m = 0) →
motive { toMulAction := toMulAction, smul_zero := smul_zero, zero_smul := zero_smul }) →
(t : MulActionWithZero M₀ A) → motive t | false |
AlgebraicGeometry.Scheme.homOfLE | Mathlib.AlgebraicGeometry.Restrict | (X : AlgebraicGeometry.Scheme) → {U V : X.Opens} → U ≤ V → (↑U ⟶ ↑V) | true |
Std.TransCmp.eq_trans | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
cmp a b = Ordering.eq → cmp b c = Ordering.eq → cmp a c = Ordering.eq | true |
Lean.Compiler.LCNF.LetValue._auto_15 | Lean.Compiler.LCNF.Basic | Lean.Syntax | false |
Lean.Parser.Tactic.vcAlt | Std.Tactic.Do.Syntax | Lean.ParserDescr | true |
ProbabilityTheory.uncenteredCovarianceBilinDual._proof_2 | Mathlib.Probability.Moments.CovarianceBilinDual | (1 + 1).AtLeastTwo | false |
CompactlySupportedContinuousMap.instAddMonoidOfContinuousAdd | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : AddMonoid β] → [ContinuousAdd β] → AddMonoid (CompactlySupportedContinuousMap α β) | true |
Std.ge_refl | Mathlib.Order.RelClasses | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Std.Refl fun x1 x2 => x1 ≥ x2] (a : α), a ≤ a | true |
_private.Mathlib.Data.Matrix.Mul.0.Matrix.vecMulVec_eq_zero._simp_1_1 | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M N : Matrix m n α}, (M = N) = ∀ (i : m) (j : n), M i j = N i j | false |
AddMonoidAlgebra.map_mul | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Add M] (f : R →+* S)
(x y : AddMonoidAlgebra R M),
AddMonoidAlgebra.map (↑f) (x * y) = AddMonoidAlgebra.map (↑f) x * AddMonoidAlgebra.map (↑f) y | true |
Std.HashMap.Raw.any_eq_true_iff_exists_mem_getElem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α]
{p : α → β → Bool}, m.WF → (m.any p = true ↔ ∃ a, ∃ (h : a ∈ m), p a m[a] = true) | true |
FinVec.sum._proof_1 | Mathlib.Data.Fin.Tuple.Reflection | NeZero (0 + 1) | false |
Asymptotics.isBigOWith_abs_left._simp_1 | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {F : Type u_4} [inst : Norm F] {c : ℝ} {g : α → F} {l : Filter α} {u : α → ℝ},
Asymptotics.IsBigOWith c l (fun x => |u x|) g = Asymptotics.IsBigOWith c l u g | false |
HahnSeries.embDomainRingHom | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} →
[inst : AddCommMonoid Γ] →
[inst_1 : PartialOrder Γ] →
[inst_2 : IsOrderedCancelAddMonoid Γ] →
{Γ' : Type u_6} →
[inst_3 : AddCommMonoid Γ'] →
[inst_4 : PartialOrder Γ'] →
[inst_5 : IsOrderedCancelAddMonoid Γ'] →
[inst_6 : NonAssocSemiring R] →
(f : Γ →+ Γ') →
Function.Injective ⇑f → (∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') → HahnSeries Γ R →+* HahnSeries Γ' R | true |
_private.Init.Data.List.ToArray.0.List.zipWithMAux_toArray_succ._proof_1_4 | Init.Data.List.ToArray | ∀ {α : Type u_2} {β : Type u_1} (as : List α) (bs : List β) (i : ℕ), i + 1 < bs.length → ¬i < bs.length - 1 → False | false |
Lean.Meta.Grind.InjectiveInfo.mk | Lean.Meta.Tactic.Grind.Types | List Lean.Level → Lean.Expr → Lean.Expr → Lean.Expr → Option (Lean.Expr × Lean.Expr) → Lean.Meta.Grind.InjectiveInfo | true |
CategoryTheory.Cat.HasLimits.limitConeLift | Mathlib.CategoryTheory.Category.Cat.Limit | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CategoryTheory.Cat) →
(s : CategoryTheory.Limits.Cone F) → s.pt ⟶ CategoryTheory.Cat.HasLimits.limitConeX F | true |
DoubleQuot.quotLeftToQuotSup.eq_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : CommRing R] (I J : Ideal R), DoubleQuot.quotLeftToQuotSup I J = Ideal.Quotient.factor ⋯ | true |
Std.ExtTreeMap.self_le_maxKeyD_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α}, (cmp k ((t.insert k v).maxKeyD fallback)).isLE = true | true |
eq_zero_of_zpow_eq_zero | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} {n : ℤ}, a ^ n = 0 → a = 0 | true |
CategoryTheory.NatIso.ofComponents'.congr_simp | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (app app_1 : (X : C) → F.obj X ≅ G.obj X) (e_app : app = app_1)
(naturality :
∀ {X Y : C} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (app Y).inv (F.map f) =
CategoryTheory.CategoryStruct.comp (G.map f) (app X).inv),
CategoryTheory.NatIso.ofComponents' app naturality = CategoryTheory.NatIso.ofComponents' app_1 ⋯ | true |
SubgroupClass.instZPow | Mathlib.Algebra.Group.Subgroup.Defs | {M : Type u_5} →
{S : Type u_6} → [inst : DivInvMonoid M] → [inst_1 : SetLike S M] → [SubgroupClass S M] → {H : S} → Pow ↥H ℤ | true |
CategoryTheory.CatEnriched.instCategory | Mathlib.CategoryTheory.Bicategory.CatEnriched | {C : Type u_1} →
[CategoryTheory.EnrichedCategory CategoryTheory.Cat C] →
CategoryTheory.Category.{u_2, u_1} (CategoryTheory.CatEnriched C) | true |
_private.Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop.0.Std.IterM.first?.eq_1 | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β] [inst_2 : Std.IteratorLoop α m m]
(it : Std.IterM m β),
it.first? =
Std.IteratorLoop.forIn (fun x x_1 => flip bind) (Option β) (fun b x s => s = ForInStep.done (some b)) it none
fun b x x_1 => pure ⟨ForInStep.done (some b), ⋯⟩ | true |
Classical.some_spec₂ | Mathlib.Logic.Basic | ∀ {α : Sort u_2} {p : α → Prop} {h : ∃ a, p a} (q : α → Prop), (∀ (a : α), p a → q a) → q (Classical.choose h) | true |
_private.Mathlib.SetTheory.Cardinal.Aleph.0.Cardinal.beth_add_one._simp_1_2 | Mathlib.SetTheory.Cardinal.Aleph | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | false |
Mathlib.Meta.NormNum.NormNums.tree._default | Mathlib.Tactic.NormNum.Core | Lean.Meta.DiscrTree Mathlib.Meta.NormNum.NormNumExt | false |
PowerSeries.coeff_mul_eq_coeff_trunc_mul_trunc | Mathlib.RingTheory.PowerSeries.Trunc | ∀ {R : Type u_2} [inst : CommSemiring R] {d n : ℕ} (f g : PowerSeries R),
d < n →
(PowerSeries.coeff d) (f * g) = (PowerSeries.coeff d) (↑((PowerSeries.trunc n) f) * ↑((PowerSeries.trunc n) g)) | true |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkRichHCongr.trySolveCore | Mathlib.Lean.Meta.CongrTheorems | Lean.MVarId → Lean.MetaM Unit | true |
String.Slice.le_offset_posGE._simp_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : String.Pos.Raw} {h : p ≤ s.rawEndPos}, (p ≤ (s.posGE p h).offset) = True | false |
String.Pos.offset_sliceTo | Init.Data.String.Basic | ∀ {s : String} {p₀ pos : s.Pos} {h : pos ≤ p₀}, (p₀.sliceTo pos h).offset = pos.offset | true |
Finset.card_toRight_le | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {u : Finset (α ⊕ β)}, u.toRight.card ≤ u.card | true |
Associated | Mathlib.Algebra.GroupWithZero.Associated | {M : Type u_1} → [Monoid M] → M → M → Prop | true |
_private.Mathlib.FieldTheory.PerfectClosure.0.PerfectClosure.mk_pow._simp_1_1 | Mathlib.FieldTheory.PerfectClosure | ∀ (R : Type u_1) [inst : CommSemiring R] (p n : ℕ) [inst_1 : ExpChar R p],
(⇑(frobenius R p))^[n] = ⇑(iterateFrobenius R p n) | false |
FirstOrder.Language.BoundedFormula.mapTermRelEquiv._proof_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u_6} {β : Type u_1}
(ft : (n : ℕ) → L.Term (α ⊕ Fin n) ≃ L'.Term (β ⊕ Fin n)) (fr : (n : ℕ) → L.Relations n ≃ L'.Relations n) {n : ℕ}
(φ : L'.BoundedFormula β n),
FirstOrder.Language.BoundedFormula.mapTermRel (fun n => ⇑(ft n)) (fun n => ⇑(fr n)) (fun x => id)
(FirstOrder.Language.BoundedFormula.mapTermRel (fun n => ⇑(ft n).symm) (fun n => ⇑(fr n).symm) (fun x => id) φ) =
φ | false |
DiffeologicalSpace.noConfusionType | Mathlib.Geometry.Diffeology.Basic | Sort u → {X : Type u_1} → DiffeologicalSpace X → {X' : Type u_1} → DiffeologicalSpace X' → Sort u | false |
_private.Mathlib.Analysis.Asymptotics.LinearGrowth.0.Monotone.le_linearGrowthSup_comp.match_1_1 | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {v : ℕ → ℕ} (a : EReal) (motive : a ∈ Set.Ioo 0 (LinearGrowth.linearGrowthInf fun n => ↑(v n)) → Prop)
(h : a ∈ Set.Ioo 0 (LinearGrowth.linearGrowthInf fun n => ↑(v n))),
(∀ (a_0 : 0 < a) (a_v : a < LinearGrowth.linearGrowthInf fun n => ↑(v n)), motive ⋯) → motive h | false |
Lean.Meta.whnfI | Lean.Meta.Basic | Lean.Expr → Lean.MetaM Lean.Expr | true |
_private.Init.Data.Int.Order.0.Int.nonneg_def.match_1_1 | Init.Data.Int.Order | ∀ (motive : (a : ℤ) → a.NonNeg → Prop) (a : ℤ) (x : a.NonNeg), (∀ (n : ℕ), motive (Int.ofNat n) ⋯) → motive a x | false |
cfcₙ_integral | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Integral | ∀ {X : Type u_1} {𝕜 : Type u_2} {A : Type u_3} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : MeasurableSpace X]
{μ : MeasureTheory.Measure X} [inst_2 : NonUnitalNormedRing A] [inst_3 : StarRing A] [inst_4 : NormedSpace 𝕜 A]
[inst_5 : IsScalarTower 𝕜 A A] [inst_6 : SMulCommClass 𝕜 A A] [inst_7 : NonUnitalContinuousFunctionalCalculus 𝕜 A p]
[CompleteSpace A] [inst_9 : NormedSpace ℝ A] [inst_10 : TopologicalSpace X] [OpensMeasurableSpace X] (f : X → 𝕜 → 𝕜)
(bound : X → ℝ) (a : A) [SecondCountableTopologyEither X C(↑(quasispectrum 𝕜 a), 𝕜)],
ContinuousOn (Function.uncurry f) (Set.univ ×ˢ quasispectrum 𝕜 a) →
(∀ᵐ (x : X) ∂μ, f x 0 = 0) →
(∀ᵐ (x : X) ∂μ, ∀ z ∈ quasispectrum 𝕜 a, ‖f x z‖ ≤ bound x) →
MeasureTheory.HasFiniteIntegral bound μ →
autoParam (p a) cfcₙ_integral._auto_1 → cfcₙ (fun r => ∫ (x : X), f x r ∂μ) a = ∫ (x : X), cfcₙ (f x) a ∂μ | true |
DirectSum.IsInternal.collectedOrthonormalBasis.congr_simp | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] {A : ι → Submodule 𝕜 E}
(hV : OrthogonalFamily 𝕜 (fun i => ↥(A i)) fun i => (A i).subtypeₗᵢ) [inst_4 : DecidableEq ι]
(hV_sum : DirectSum.IsInternal fun i => A i) {α : ι → Type u_7} [inst_5 : (i : ι) → Fintype (α i)]
(v_family v_family_1 : (i : ι) → OrthonormalBasis (α i) 𝕜 ↥(A i)),
v_family = v_family_1 →
DirectSum.IsInternal.collectedOrthonormalBasis hV hV_sum v_family =
DirectSum.IsInternal.collectedOrthonormalBasis hV hV_sum v_family_1 | true |
SimpleGraph.Walk.exists_adj_adj_not_adj_ne | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V} {p : G.Walk v w},
p.length = G.dist v w → 1 < G.dist v w → ∃ x a b, G.Adj x a ∧ G.Adj a b ∧ ¬G.Adj x b ∧ x ≠ b | true |
OrderHom.equivalenceFunctor._proof_2 | Mathlib.CategoryTheory.Category.Preorder | ∀ {X : Type u_1} {Y : Type u_2} [inst : Preorder X] [inst_1 : Preorder Y] (X_1 : X →o Y),
{ app := fun x => CategoryTheory.homOfLE ⋯, naturality := ⋯ } = CategoryTheory.CategoryStruct.id X_1.toFunctor | false |
Std.DHashMap.Const.get!_erase_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {k : α}, Std.DHashMap.Const.get! (m.erase k) k = default | true |
CategoryTheory.Functor.IsCoverDense.Types.naturality | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {K : CategoryTheory.GrothendieckTopology D}
{G : CategoryTheory.Functor C D} {ℱ : CategoryTheory.Functor Dᵒᵖ (Type v)} {ℱ' : CategoryTheory.Sheaf K (Type v)}
(α : G.op.comp ℱ ⟶ G.op.comp ℱ'.obj) [G.IsLocallyFull K] {X Y : C} (i : G.obj X ⟶ G.obj Y),
CategoryTheory.CategoryStruct.comp (α.app (Opposite.op Y)) (ℱ'.obj.map i.op) =
CategoryTheory.CategoryStruct.comp (ℱ.map i.op) (α.app (Opposite.op X)) | true |
CategoryTheory.ShortComplex.RightHomologyData.p_g'_assoc | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData) {Z : C} (h_1 : S.X₃ ⟶ Z),
CategoryTheory.CategoryStruct.comp h.p (CategoryTheory.CategoryStruct.comp h.g' h_1) =
CategoryTheory.CategoryStruct.comp S.g h_1 | true |
RootPairing.Base.flip | Mathlib.LinearAlgebra.RootSystem.Base | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] → [inst_4 : Module R N] → {P : RootPairing ι R M N} → P.Base → P.flip.Base | true |
CategoryTheory.LaxBraidedFunctor.forget_map | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{X Y :
CategoryTheory.InducedCategory (CategoryTheory.LaxMonoidalFunctor C D)
CategoryTheory.LaxBraidedFunctor.toLaxMonoidalFunctor}
(f : X ⟶ Y), CategoryTheory.LaxBraidedFunctor.forget.map f = f.hom | true |
Aesop.Frontend.Feature.phase.sizeOf_spec | Aesop.Frontend.RuleExpr | ∀ (p : Aesop.PhaseName), sizeOf (Aesop.Frontend.Feature.phase p) = 1 + sizeOf p | true |
finrank_euclideanSpace | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : Fintype ι],
Module.finrank 𝕜 (EuclideanSpace 𝕜 ι) = Fintype.card ι | true |
SimpleGraph.Subgraph.neighborSet_sup | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph} (v : V),
(H ⊔ H').neighborSet v = H.neighborSet v ∪ H'.neighborSet v | true |
OrderMonoidIso.withZeroUnits | Mathlib.Algebra.Order.Hom.MonoidWithZero | {α : Type u_6} → [inst : LinearOrderedCommGroupWithZero α] → [DecidablePred fun a => a = 0] → WithZero αˣ ≃*o α | true |
AntivaryOn.add_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f₁ f₂ : ι → α} {g : ι → β},
AntivaryOn f₁ g s → AntivaryOn f₂ g s → AntivaryOn (f₁ + f₂) g s | true |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.