name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ENNReal.mul_eq_left | Mathlib.Data.ENNReal.Operations | ∀ {a b : ENNReal}, a ≠ 0 → a ≠ ⊤ → (a * b = a ↔ b = 1) |
Equiv.piOptionEquivProd_apply | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_10} {β : Option α → Type u_9} (f : (a : Option α) → β a),
Equiv.piOptionEquivProd f = (f none, fun a => f (some a)) |
MeasureTheory.ae_eq_comp | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} {δ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {f : α → β} {g g' : β → δ},
AEMeasurable f μ → g =ᵐ[MeasureTheory.Measure.map f μ] g' → g ∘ f =ᵐ[μ] g' ∘ f |
ByteArray.ofFn | Batteries.Data.ByteArray | {n : ℕ} → (Fin n → UInt8) → ByteArray |
TestFunction.toBoundedContinuousFunctionCLM._proof_17 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_3) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_1} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n : ℕ∞} [inst_6 : Algebra ℝ 𝕜] [inst_7 : IsScalarTower ℝ 𝕜 F]
(x : 𝕜) (x_1 : TestFunction Ω F n), ∃ C, ∀ (x_2 y : E), dist ((x • x_1) x_2) ((x • x_1) y) ≤ C |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.IsCyclotomicExtension.eq_self_sdiff_zero._simp_1_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) |
IsCyclotomicExtension.Rat.Three.lambda_pow_four_dvd_cube_add_one_of_dvd_add_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ 3) [inst_1 : NumberField K]
[IsCyclotomicExtension {3} ℚ K] {x : NumberField.RingOfIntegers K},
hζ.toInteger - 1 ∣ x + 1 → (hζ.toInteger - 1) ^ 4 ∣ x ^ 3 + 1 |
IsManifold.recOn | 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} →
{n : WithTop ℕ∞} →
{M : Type u_4} →
[inst_4 : TopologicalSpace M] →
[inst_5 : ChartedSpace H M] →
{motive : IsManifold I n M → Sort u} →
(t : IsManifold I n M) →
([toHasGroupoid : HasGroupoid M (contDiffGroupoid n I)] → motive ⋯) → motive t |
MeasureTheory.VectorMeasure.of_biUnion_finset | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
{v : MeasureTheory.VectorMeasure α M} [T2Space M] {ι : Type u_4} {s : Finset ι} {f : ι → Set α},
(↑s).PairwiseDisjoint f → (∀ b ∈ s, MeasurableSet (f b)) → ↑v (⋃ b ∈ s, f b) = ∑ p ∈ s, ↑v (f p) |
Set.powersetCard.ofFinEmb.eq_1 | Mathlib.Data.Set.PowersetCard | ∀ (n : ℕ) (β : Type u_2) (f : Fin n ↪ β), Set.powersetCard.ofFinEmb n β f = Set.powersetCard.map n f ⟨Finset.univ, ⋯⟩ |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_extractLsb'_eq_extractLsb'._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = x) = (¬p → y = x) |
UniformSpace.Completion.ring._proof_26 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [IsTopologicalRing α] [inst_3 : IsUniformAddGroup α]
(a : UniformSpace.Completion α), a * 0 = 0 |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AddAndFinalizeContext.indFVars | Lean.Elab.MutualInductive | Lean.Elab.Command.AddAndFinalizeContext✝ → Array Lean.Expr |
TopModuleCat.instAddCommGroupHom | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [inst : Ring R] → [inst_1 : TopologicalSpace R] → {X Y : TopModuleCat R} → AddCommGroup (X ⟶ Y) |
Filter.covariant_vadd | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β],
CovariantClass (Filter α) (Filter β) (fun x1 x2 => x1 +ᵥ x2) fun x1 x2 => x1 ≤ x2 |
Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k km kme : α} (hkme : (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKey? = some kme),
t.minKey?.get ⋯ = km → (compare km kme).isLE = true |
grade_strictMono | Mathlib.Order.Grade | ∀ {𝕆 : Type u_1} {α : Type u_3} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeOrder 𝕆 α],
StrictMono (grade 𝕆) |
Vector.eraseIdx_set_lt | Init.Data.Vector.Erase | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {w : i < n} {j : ℕ} {a : α} (h : j < i),
(xs.set i a w).eraseIdx j ⋯ = (xs.eraseIdx j ⋯).set (i - 1) a ⋯ |
Action.FunctorCategoryEquivalence.functor_map_app | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {X Y : Action V G}
(f : X ⟶ Y) (x : CategoryTheory.SingleObj G), (Action.FunctorCategoryEquivalence.functor.map f).app x = f.hom |
Subfield.instPartialOrder | Mathlib.Algebra.Field.Subfield.Defs | {K : Type u} → [inst : DivisionRing K] → PartialOrder (Subfield K) |
FirstOrder.Language.age | Mathlib.ModelTheory.Fraisse | (L : FirstOrder.Language) → (M : Type w) → [L.Structure M] → Set (CategoryTheory.Bundled L.Structure) |
ContinuousMap.zero_comp | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [inst_3 : Zero γ] (g : C(α, β)), ContinuousMap.comp 0 g = 0 |
Std.Do.PredTrans.pure._proof_1 | Std.Do.PredTrans | ∀ {ps : Std.Do.PostShape} {α : Type u_1} (a : α), Std.Do.PredTrans.Conjunctive fun Q => Q.1 a |
Positive.instPowSubtypeLtOfNatNat_mathlib._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (x : { x // 0 < x }) (n : ℕ),
0 < ↑x ^ n |
_private.Mathlib.Tactic.MkIffOfInductiveProp.0.Mathlib.Tactic.MkIff.select.match_5 | Mathlib.Tactic.MkIffOfInductiveProp | (motive : ℕ → ℕ → Sort u_1) →
(m n : ℕ) →
(Unit → motive 0 0) →
((n : ℕ) → motive 0 n.succ) → ((m n : ℕ) → motive m.succ n.succ) → ((x x_1 : ℕ) → motive x x_1) → motive m n |
NNRat.nndist_eq._simp_1 | Mathlib.Topology.Instances.Rat | ∀ (p q : ℚ≥0), nndist ↑p ↑q = nndist p q |
List.Sublist.tail | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₁.tail.Sublist l₂.tail |
«term_<|_» | Init.Notation | Lean.TrailingParserDescr |
CategoryTheory.Under.map.eq_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f : X ⟶ Y),
CategoryTheory.Under.map f =
CategoryTheory.Comma.mapLeft (CategoryTheory.Functor.id T) (CategoryTheory.Discrete.natTrans fun x => f) |
Lean.Compiler.LCNF.Simp.FunDeclInfoMap.format | Lean.Compiler.LCNF.Simp.FunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfoMap → Lean.Compiler.LCNF.CompilerM Std.Format |
smul_nonneg_iff_neg_imp_nonpos | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β]
[PosSMulStrictMono α β] {a : α} {b : β}, 0 ≤ a • b ↔ (a < 0 → b ≤ 0) ∧ (b < 0 → a ≤ 0) |
Projectivization.logHeight_mk | Mathlib.NumberTheory.Height.Projectivization | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} [inst_2 : Finite ι] {x : ι → K}
(hx : x ≠ 0), (Projectivization.mk K x hx).logHeight = Height.logHeight x |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.hasLimit_cospan_forget_of_right' | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
CategoryTheory.Limits.HasLimit
(CategoryTheory.Limits.cospan
(((CategoryTheory.Limits.cospan g f).comp AlgebraicGeometry.SheafedSpace.forgetToPresheafedSpace).map
CategoryTheory.Limits.WalkingCospan.Hom.inl)
(((CategoryTheory.Limits.cospan g f).comp AlgebraicGeometry.SheafedSpace.forgetToPresheafedSpace).map
CategoryTheory.Limits.WalkingCospan.Hom.inr)) |
if_true_right._simp_1 | Init.PropLemmas | ∀ {p q : Prop} [h : Decidable p], (if p then q else True) = (p → q) |
ENat.forall_natCast_le_iff_le | Mathlib.Data.ENat.Basic | ∀ {m n : ℕ∞}, (∀ (a : ℕ), ↑a ≤ m → ↑a ≤ n) ↔ m ≤ n |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_33 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (n : ℕ), ¬Std.Tactic.BVDecide.BVUnOp.clz = Std.Tactic.BVDecide.BVUnOp.rotateRight n |
Plausible.Testable.mk | Plausible.Testable | {p : Prop} → (Plausible.Configuration → Bool → Plausible.Gen (Plausible.TestResult p)) → Plausible.Testable p |
Complex.arg_of_im_pos | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {z : ℂ}, 0 < z.im → z.arg = Real.arccos (z.re / ‖z‖) |
Nat.dfold_zero._proof_7 | Init.Data.Nat.Fold | 0 ≤ 0 |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_70 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
Ideal.comap_map_mk | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {I J : Ideal R} [inst_1 : I.IsTwoSided],
I ≤ J → Ideal.comap (Ideal.Quotient.mk I) (Ideal.map (Ideal.Quotient.mk I) J) = J |
prodXSubSMul.eval | Mathlib.Algebra.Polynomial.GroupRingAction | ∀ (G : Type u_2) [inst : Group G] [inst_1 : Fintype G] (R : Type u_3) [inst_2 : CommRing R]
[inst_3 : MulSemiringAction G R] (x : R), Polynomial.eval x (prodXSubSMul G R x) = 0 |
QuotientGroup.instSeminormedCommGroup._proof_4 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedCommGroup M] (S : Subgroup M) (x y z : M ⧸ S), dist x z ≤ dist x y + dist y z |
_private.Mathlib.Combinatorics.Matroid.Sum.0.Matroid.sum'_isBasis_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Sum | ∀ {α : Type u_3} {β : Type u_4} {M : Matroid α} (f : α ≃ β) {I X : Set β},
(M.mapEquiv f).IsBasis I X = M.IsBasis (⇑f.symm '' I) (⇑f.symm '' X) |
Set.InjOn.eq_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {x y : α}, Set.InjOn f s → x ∈ s → y ∈ s → (f x = f y ↔ x = y) |
CategoryTheory.Limits.image.fac | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasImage f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f) (CategoryTheory.Limits.image.ι f) = f |
DomAddAct.instAddCommMonoidOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [AddCommMonoid Mᵃᵒᵖ] → AddCommMonoid Mᵈᵃᵃ |
Dioph._aux_Mathlib_NumberTheory_Dioph___unexpand_Dioph_le_dioph_1 | Mathlib.NumberTheory.Dioph | Lean.PrettyPrinter.Unexpander |
Metric.PiNatEmbed.recOn | Mathlib.Topology.MetricSpace.PiNat | {ι : Type u_2} →
{X : Type u_5} →
{Y : ι → Type u_6} →
{f : (i : ι) → X → Y i} →
{motive : Metric.PiNatEmbed X Y f → Sort u} →
(t : Metric.PiNatEmbed X Y f) → ((ofPiNat : X) → motive { ofPiNat := ofPiNat }) → motive t |
jacobiSym.mul_right' | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (a : ℤ) {b₁ b₂ : ℕ}, b₁ ≠ 0 → b₂ ≠ 0 → jacobiSym a (b₁ * b₂) = jacobiSym a b₁ * jacobiSym a b₂ |
TopCommRingCat.hasForgetToTopCat | Mathlib.Topology.Category.TopCommRingCat | CategoryTheory.HasForget₂ TopCommRingCat TopCat |
Equiv.Perm.coe_pow._simp_1 | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} (f : Equiv.Perm α) (n : ℕ), (⇑f)^[n] = ⇑(f ^ n) |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.SimpM.run.match_1 | Lean.Meta.Tactic.Simp.Types | {α : Type} →
(motive : α × Lean.Meta.Simp.State → Sort u_1) →
(__discr : α × Lean.Meta.Simp.State) → ((r : α) → (s : Lean.Meta.Simp.State) → motive (r, s)) → motive __discr |
CategoryTheory.ShiftMkCore.casesOn | Mathlib.CategoryTheory.Shift.Basic | {C : Type u} →
{A : Type u_1} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : AddMonoid A] →
{motive : CategoryTheory.ShiftMkCore C A → Sort u_2} →
(t : CategoryTheory.ShiftMkCore C A) →
((F : A → CategoryTheory.Functor C C) →
(zero : F 0 ≅ CategoryTheory.Functor.id C) →
(add : (n m : A) → F (n + m) ≅ (F n).comp (F m)) →
(assoc_hom_app :
∀ (m₁ m₂ m₃ : A) (X : C),
CategoryTheory.CategoryStruct.comp ((add (m₁ + m₂) m₃).hom.app X)
((F m₃).map ((add m₁ m₂).hom.app X)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp ((add m₁ (m₂ + m₃)).hom.app X)
((add m₂ m₃).hom.app ((F m₁).obj X)))) →
(zero_add_hom_app :
∀ (n : A) (X : C),
(add 0 n).hom.app X =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
((F n).map (zero.inv.app X))) →
(add_zero_hom_app :
∀ (n : A) (X : C),
(add n 0).hom.app X =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(zero.inv.app ((F n).obj X))) →
motive
{ F := F, zero := zero, add := add, assoc_hom_app := assoc_hom_app,
zero_add_hom_app := zero_add_hom_app, add_zero_hom_app := add_zero_hom_app }) →
motive t |
Batteries.Tactic.PrintPrefixConfig.imported._default | Batteries.Tactic.PrintPrefix | Bool |
Qq.unpackParensIdent | Qq.Match | Lean.Syntax → Option Lean.Syntax |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triangle_counting'._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) |
Homeomorph.funUnique_apply | Mathlib.Topology.Homeomorph.Lemmas | ∀ (ι : Type u_7) (X : Type u_8) [inst : Unique ι] [inst_1 : TopologicalSpace X],
⇑(Homeomorph.funUnique ι X) = fun f => f default |
Finmap.lookup_eq_none | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s : Finmap β}, Finmap.lookup a s = none ↔ a ∉ s |
even_neg._simp_1 | Mathlib.Algebra.Group.Even | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a |
Lean.Elab.Info.format | Lean.Elab.InfoTree.Main | Lean.Elab.ContextInfo → Lean.Elab.Info → IO Std.Format |
Int64.toISize_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int64), (a ^^^ b).toISize = a.toISize ^^^ b.toISize |
CategoryTheory.Limits.coprod.inl_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproduct X Y] {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.snd X Y) h) =
CategoryTheory.CategoryStruct.comp 0 h |
_private.Mathlib.FieldTheory.Galois.Infinite.0.InfiniteGalois.restrict_fixedField._simp_1_6 | Mathlib.FieldTheory.Galois.Infinite | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) |
Bool.not_eq_eq_eq_not | Init.SimpLemmas | ∀ {a b : Bool}, (!a) = b ↔ a = !b |
MeasureTheory.OuterMeasure.map._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (m : MeasureTheory.OuterMeasure α) (s : ℕ → Set β),
m (f ⁻¹' ⋃ i, s i) ≤ ∑' (i : ℕ), m (f ⁻¹' s i) |
_private.Lean.Elab.Do.Control.0.Lean.Elab.Do.ControlStack.exceptT.stM | Lean.Elab.Do.Control | Lean.Elab.Do.MonadInfo → Lean.Elab.Do.DoElabM Lean.Elab.Do.ReturnCont → Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr |
MeasureTheory.Measure.restrict_apply_self | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (s : Set α), (μ.restrict s) s = μ s |
Array.filter_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool}, Array.filter p #[] = #[] |
BoundedContinuousFunction.instLattice._proof_4 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NormedAddCommGroup β] [inst_2 : Lattice β]
[inst_3 : HasSolidNorm β] [inst_4 : IsOrderedAddMonoid β] (a b : BoundedContinuousFunction α β),
SemilatticeInf.inf a b ≤ b |
Lean.IR.SimpleGroundExpr.string | Lean.Compiler.IR.SimpleGroundExpr | String → Lean.IR.SimpleGroundExpr |
_private.Plausible.Gen.0.Plausible.Gen.permutationOf._proof_7 | Plausible.Gen | ∀ {α : Type u_1} (ys : List α), ¬0 ≤ ys.length → False |
_private.Mathlib.Analysis.Normed.Unbundled.SpectralNorm.0.spectralNorm.spectralMulAlgNorm_eq_of_mem_roots._simp_1_3 | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R}, p.IsRoot a = (Polynomial.eval a p = 0) |
HurwitzZeta.hasSum_int_oddKernel | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : ℝ) {x : ℝ},
0 < x → HasSum (fun n => (↑n + a) * Real.exp (-Real.pi * (↑n + a) ^ 2 * x)) (HurwitzZeta.oddKernel (↑a) x) |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.eraseDecl.match_1 | Lean.Meta.Tactic.Grind.Theorems | (motive : Option (Array Lean.Name) → Sort u_1) →
(__do_lift : Option (Array Lean.Name)) →
((eqns : Array Lean.Name) → motive (some eqns)) → ((x : Option (Array Lean.Name)) → motive x) → motive __do_lift |
CategoryTheory.PreZeroHypercover.pullbackCoverOfLeftIsoPullback₁._proof_3 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X : C} (E : CategoryTheory.PreZeroHypercover X)
{Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [inst_1 : CategoryTheory.Limits.HasPullback f g]
[inst_2 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.fst f g) (E.f i)]
[inst_3 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (E.f i) (CategoryTheory.Limits.pullback.fst f g)]
(i : (E.pullbackCoverOfLeft f g).I₀),
CategoryTheory.CategoryStruct.comp
((fun x =>
(CategoryTheory.Limits.pullbackRightPullbackFstIso f g (E.f x)).symm ≪≫
CategoryTheory.Limits.pullbackSymmetry (E.f x) (CategoryTheory.Limits.pullback.fst f g))
i).hom
((CategoryTheory.PreZeroHypercover.pullback₁ (CategoryTheory.Limits.pullback.fst f g) E).f
((Equiv.refl (E.pullbackCoverOfLeft f g).I₀) i)) =
(E.pullbackCoverOfLeft f g).f i |
Algebra.Extension.noConfusion | Mathlib.RingTheory.Extension.Basic | {P : Sort u_1} →
{R : Type u} →
{S : Type v} →
{inst : CommRing R} →
{inst_1 : CommRing S} →
{inst_2 : Algebra R S} →
{t : Algebra.Extension R S} →
{R' : Type u} →
{S' : Type v} →
{inst' : CommRing R'} →
{inst'_1 : CommRing S'} →
{inst'_2 : Algebra R' S'} →
{t' : Algebra.Extension R' S'} →
R = R' →
S = S' →
inst ≍ inst' →
inst_1 ≍ inst'_1 → inst_2 ≍ inst'_2 → t ≍ t' → Algebra.Extension.noConfusionType P t t' |
Lean.Omega.Fin.lt_of_not_le | Init.Omega.Int | ∀ {n : ℕ} {i j : Fin n}, ¬i ≤ j → j < i |
CategoryTheory.Limits.coproductIsCoproduct'._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete α) C)
[inst_1 : CategoryTheory.Limits.HasCoproduct fun j => X.obj { as := j }] (s : CategoryTheory.Limits.Cocone X)
(m : (CategoryTheory.Limits.Sigma.cocone X).pt ⟶ s.pt),
(∀ (j : CategoryTheory.Discrete α),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.Sigma.cocone X).ι.app j) m = s.ι.app j) →
m = CategoryTheory.Limits.Sigma.desc fun j => s.ι.app { as := j } |
_private.Aesop.Tree.ExtractProof.0.Aesop.extractProofGoal.match_3 | Aesop.Tree.ExtractProof | (motive : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment) → Sort u_1) →
(__discr : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment)) →
((postNormGoal : Lean.MVarId) →
(children : Array Aesop.RappRef) →
(postNormEnv : Lean.Environment) → motive (some (postNormGoal, children, postNormEnv))) →
((x : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment)) → motive x) → motive __discr |
QuotientGroup.fintypeQuotientRightRel | Mathlib.GroupTheory.Coset.Card | {α : Type u_1} → [inst : Group α] → {s : Subgroup α} → [Fintype (α ⧸ s)] → Fintype (Quotient (QuotientGroup.rightRel s)) |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Reify.0.Lean.Meta.Grind.Arith.Linear.reify?.isOfNatZero | Lean.Meta.Tactic.Grind.Arith.Linear.Reify | Lean.Expr → Lean.Meta.Grind.Arith.Linear.LinearM Bool |
Lean.Omega.IntList.mul_get | Init.Omega.IntList | ∀ (xs ys : Lean.Omega.IntList) (i : ℕ), (xs * ys).get i = xs.get i * ys.get i |
Lean.Elab.MonadAutoImplicits.casesOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadAutoImplicits m → Sort u} →
(t : Lean.Elab.MonadAutoImplicits m) →
((getAutoImplicits : m (Array Lean.Expr)) → motive { getAutoImplicits := getAutoImplicits }) → motive t |
Batteries.RBNode.foldr_reverse | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {t : Batteries.RBNode α} {f : α → β → β} {init : β},
Batteries.RBNode.foldr f t.reverse init = Batteries.RBNode.foldl (flip f) init t |
lift_nhds_left | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] {x : α} {g : Set α → Filter β},
Monotone g → (nhds x).lift g = (uniformity α).lift fun s => g (UniformSpace.ball x s) |
Option.get!_none | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Inhabited α], none.get! = default |
_private.Lean.Compiler.LCNF.Simp.SimpM.0.Lean.Compiler.LCNF.Simp.withIncRecDepth.throwMaxRecDepth.match_3 | Lean.Compiler.LCNF.Simp.SimpM | (motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) →
(Unit → motive []) → ((declName : Lean.Name) → (stack : List Lean.Name) → motive (declName :: stack)) → motive x |
_private.Mathlib.Data.Set.Prod.0.Set.pi_inter_distrib._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t t₁ : (i : ι) → Set (α i)},
(s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁ |
sub_lt_comm | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b c : α}, a - b < c ↔ a - c < b |
SimpleGraph.Walk.take_add_eq | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (n m : ℕ),
p.take (n + m) = ((p.take n).append ((p.drop n).take m)).copy ⋯ ⋯ |
PadicInt.withValIntegersRingEquiv | Mathlib.NumberTheory.Padics.WithVal | {p : ℕ} → [inst : Fact (Nat.Prime p)] → ↥(Valued.integer (Rat.padicValuation p).Completion) ≃+* ℤ_[p] |
DiscreteTiling.PlacedTile.coe_nonempty_iff | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X]
{ps : DiscreteTiling.Protoset G X ιₚ} {pt : DiscreteTiling.PlacedTile ps}, (↑pt).Nonempty ↔ (↑(↑ps pt.index)).Nonempty |
Std.PRange.Least?.recOn | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u} →
{motive : Std.PRange.Least? α → Sort u_1} →
(t : Std.PRange.Least? α) → ((least? : Option α) → motive { least? := least? }) → motive t |
ContinuousMap.Homotopy.casesOn | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} →
{motive : f₀.Homotopy f₁ → Sort u_1} →
(t : f₀.Homotopy f₁) →
((toContinuousMap : C(↑unitInterval × X, Y)) →
(map_zero_left : ∀ (x : X), toContinuousMap.toFun (0, x) = f₀ x) →
(map_one_left : ∀ (x : X), toContinuousMap.toFun (1, x) = f₁ x) →
motive
{ toContinuousMap := toContinuousMap, map_zero_left := map_zero_left,
map_one_left := map_one_left }) →
motive t |
AddHomClass.toAddHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f : F), ↑f = { toFun := ⇑f, map_add' := ⋯ } |
TopologicalSpace.NonemptyCompacts.coe_map | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β}
(hf : Continuous f) (s : TopologicalSpace.NonemptyCompacts α),
↑(TopologicalSpace.NonemptyCompacts.map f hf s) = f '' ↑s |
Std.PreorderPackage.ofLE._proof_3 | Init.Data.Order.PackageFactories | ∀ (α : Type u_1) (args : Std.Packages.PreorderOfLEArgs α), Std.IsPreorder α |
_private.Mathlib.Analysis.Convex.Function.0.strictConvexOn_iff_div._simp_1_1 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True |
Subring.mem_mk'._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : Ring R] {s : Set R} {sm : Submonoid R} (hm : ↑sm = s) {sa : AddSubgroup R} (ha : ↑sa = s)
{x : R}, (x ∈ Subring.mk' s sm sa hm ha) = (x ∈ s) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.