name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Sep.mk.noConfusion | Init.Core | {α : outParam (Type u)} →
{γ : Type v} →
{P : Sort u_1} → {sep sep' : (α → Prop) → γ → γ} → { sep := sep } = { sep := sep' } → (sep ≍ sep' → P) → P |
isUnit_star._simp_1 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] {a : R}, IsUnit (star a) = IsUnit a |
CategoryTheory.Limits.Cone.isLimitEquivIsTerminal._proof_3 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_3, u_2} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cone F),
Function.LeftInverse (fun h s => { default := h.from s, uniq := ⋯ }) fun x =>
CategoryTheory.Limits.IsTerminal.ofUnique c |
Finset.map_toDual_max | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α),
WithBot.map (⇑OrderDual.toDual) s.max = (Finset.image (⇑OrderDual.toDual) s).min |
Mathlib.Tactic.AtomM.addAtom | Mathlib.Util.AtomM | Lean.Expr → Mathlib.Tactic.AtomM (ℕ × Lean.Expr) |
CategoryTheory.PreZeroHypercover.pullback₂_I₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T : C} (f : S ⟶ T) (E : CategoryTheory.PreZeroHypercover T)
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (E.f i) f],
(CategoryTheory.PreZeroHypercover.pullback₂ f E).I₀ = E.I₀ |
Matrix.uniformContinuous | Mathlib.Topology.UniformSpace.Matrix | ∀ (m : Type u_1) (n : Type u_2) (𝕜 : Type u_3) [inst : UniformSpace 𝕜] {β : Type u_4} [inst_1 : UniformSpace β]
{f : β → Matrix m n 𝕜}, UniformContinuous f ↔ ∀ (i : m) (j : n), UniformContinuous fun x => f x i j |
_private.Mathlib.Algebra.NeZero.0.not_neZero._simp_1_1 | Mathlib.Algebra.NeZero | ∀ {R : Type u_1} [inst : Zero R] {n : R}, NeZero n = (n ≠ 0) |
CategoryTheory.Limits.ReflectsColimitsOfSize.reflectsColimitsOfShape._autoParam | Mathlib.CategoryTheory.Limits.Preserves.Basic | Lean.Syntax |
mod_natCard_zsmul | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : AddGroup G] (a : G) (n : ℤ), (n % ↑(Nat.card G)) • a = n • a |
_private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.ppEqcs?._sparseCasesOn_1 | Lean.Elab.Tactic.Grind.ShowState | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Matrix.decidableEq | Mathlib.Data.Matrix.Basic | {m : Type u_2} →
{n : Type u_3} → {α : Type u_11} → [DecidableEq α] → [Fintype m] → [Fintype n] → DecidableEq (Matrix m n α) |
CategoryTheory.StrictlyUnitaryLaxFunctor.mapIdIso._proof_1 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.StrictlyUnitaryLaxFunctor B C) (x : B),
CategoryTheory.CategoryStruct.comp (F.mapId x) (CategoryTheory.eqToHom ⋯) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id (F.obj x)) |
_private.Mathlib.RingTheory.Polynomial.ScaleRoots.0.Polynomial.scaleRoots_dvd_iff._simp_1_1 | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} [inst : CommSemiring R] (p : Polynomial R) (r s : R),
(p.scaleRoots r).scaleRoots s = p.scaleRoots (r * s) |
AddAction.period_pos_of_addOrderOf_pos | Mathlib.GroupTheory.GroupAction.Period | ∀ {α : Type v} {M : Type u} [inst : AddMonoid M] [inst_1 : AddAction M α] {m : M},
0 < addOrderOf m → ∀ (a : α), 0 < AddAction.period m a |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.atomise_empty._simp_1_4 | Mathlib.Order.Partition.Finpartition | ∀ (α : Sort u), (∀ (a : α), True) = True |
_private.Lean.DocString.Extension.0.Lean.initFn._@.Lean.DocString.Extension.3367263305._hygCtx._hyg.2 | Lean.DocString.Extension | IO (Lean.SimplePersistentEnvExtension Lean.ModuleDoc (Lean.PersistentArray Lean.ModuleDoc)) |
Int.toArray_roc_eq_push | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, m < n → (m<...=n).toArray = (m<...=n - 1).toArray.push n |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.DerivedLitsInvariant._proof_1 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n),
f.assignments.size = n →
∀ (assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment),
assignments.size = n →
∀ (derivedLits : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (i : Fin n),
↑i < n → ↑i < assignments.size |
Bornology.ext_iff' | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {t t' : Bornology α}, t = t' ↔ ∀ (s : Set α), s ∈ Bornology.cobounded α ↔ s ∈ Bornology.cobounded α |
Nat.count_true | Mathlib.Data.Nat.Count | ∀ (n : ℕ), Nat.count (fun x => True) n = n |
Std.Tactic.BVDecide.BVExpr.bitblast.ReplicateTarget.mk.sizeOf_spec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {combined : ℕ} [inst_2 : SizeOf α]
{w : ℕ} (n : ℕ) (inner : aig.RefVec w) (h : combined = w * n),
sizeOf { w := w, n := n, inner := inner, h := h } = 1 + sizeOf w + sizeOf n + sizeOf inner + sizeOf h |
CategoryTheory.PreZeroHypercover.empty | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (S : C) → CategoryTheory.PreZeroHypercover S |
Std.HashSet.get!_diff_of_mem_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, k ∈ m₂ → (m₁ \ m₂).get! k = default |
UInt32.reduceAdd._regBuiltin.UInt32.reduceAdd.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2998934274._hygCtx._hyg.33 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
WeierstrassCurve.Jacobian.negY_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R}, P 2 = 0 → W'.negY P = -P 1 |
CategoryTheory.ShortComplex.mapHomologyIso | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(S : CategoryTheory.ShortComplex C) →
(F : CategoryTheory.Functor C D) →
[inst_4 : F.PreservesZeroMorphisms] →
[inst_5 : S.HasHomology] →
[inst_6 : (S.map F).HasHomology] →
[F.PreservesLeftHomologyOf S] → (S.map F).homology ≅ F.obj S.homology |
differentiable_finCons | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : ℕ} {F' : Fin n.succ → Type u_6}
[inst_3 : (i : Fin n.succ) → NormedAddCommGroup (F' i)] [inst_4 : (i : Fin n.succ) → NormedSpace 𝕜 (F' i)]
{φ : E → F' 0} {φs : E → (i : Fin n) → F' i.succ},
(Differentiable 𝕜 fun x => Fin.cons (φ x) (φs x)) ↔ Differentiable 𝕜 φ ∧ Differentiable 𝕜 φs |
CategoryTheory.MonoidalCategory.pentagon_hom_inv_inv_inv_hom | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y Z : C},
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator W X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft W
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv)
(CategoryTheory.MonoidalCategoryStruct.associator W (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)
Z).inv) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (CategoryTheory.MonoidalCategoryStruct.tensorObj W X) Y Z).inv
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.MonoidalCategoryStruct.associator W X Y).hom
Z) |
BoundedContinuousFunction.comp._proof_3 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] {C : NNReal}
(f : BoundedContinuousFunction α β) (x y : α), ↑C * dist (f x) (f y) ≤ ↑(max C 0) * dist (f x) (f y) |
Std.HashMap.getKey?_eq_some_iff | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α}, m.getKey? k = some k' ↔ ∃ (h : k ∈ m), m.getKey k h = k' |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!.match_3.eq_2 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2}
(motive : Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Sort u_3) (size : ℕ) (lrk : α)
(lrv : β lrk) (l r : Std.DTreeMap.Internal.Impl α β)
(h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
(lrk : α) →
(lrv : β lrk) →
(l r : Std.DTreeMap.Internal.Impl α β) →
motive Std.DTreeMap.Internal.Impl.leaf (Std.DTreeMap.Internal.Impl.inner size lrk lrv l r))
(h_3 :
(size : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
motive (Std.DTreeMap.Internal.Impl.inner size k v l r) Std.DTreeMap.Internal.Impl.leaf)
(h_4 :
(size : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(lrs : ℕ) →
(lrk : α) →
(lrv : β lrk) →
(lrl lrr : Std.DTreeMap.Internal.Impl α β) →
motive (Std.DTreeMap.Internal.Impl.inner size k v l r)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr)),
(match Std.DTreeMap.Internal.Impl.leaf, Std.DTreeMap.Internal.Impl.inner size lrk lrv l r with
| Std.DTreeMap.Internal.Impl.leaf, Std.DTreeMap.Internal.Impl.leaf => h_1 ()
| Std.DTreeMap.Internal.Impl.leaf, Std.DTreeMap.Internal.Impl.inner size lrk lrv l r => h_2 size lrk lrv l r
| Std.DTreeMap.Internal.Impl.inner size k v l r, Std.DTreeMap.Internal.Impl.leaf => h_3 size k v l r
| Std.DTreeMap.Internal.Impl.inner size k v l r, Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr =>
h_4 size k v l r lrs lrk lrv lrl lrr) =
h_2 size lrk lrv l r |
Finset.noncommProd_commute | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid β] (s : Finset α) (f : α → β)
(comm : (↑s).Pairwise (Function.onFun Commute f)) (y : β),
(∀ x ∈ s, Commute y (f x)) → Commute y (s.noncommProd f comm) |
SameRay.pos_smul_left | Mathlib.LinearAlgebra.Ray | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {x y : M} {S : Type u_5} [inst_5 : CommSemiring S]
[inst_6 : PartialOrder S] [inst_7 : Algebra S R] [inst_8 : Module S M] [SMulPosMono S R] [IsScalarTower S R M]
{a : S}, SameRay R x y → 0 < a → SameRay R (a • x) y |
BoxIntegral.TaggedPrepartition.casesOn | Mathlib.Analysis.BoxIntegral.Partition.Tagged | {ι : Type u_1} →
{I : BoxIntegral.Box ι} →
{motive : BoxIntegral.TaggedPrepartition I → Sort u} →
(t : BoxIntegral.TaggedPrepartition I) →
((toPrepartition : BoxIntegral.Prepartition I) →
(tag : BoxIntegral.Box ι → ι → ℝ) →
(tag_mem_Icc : ∀ (J : BoxIntegral.Box ι), tag J ∈ BoxIntegral.Box.Icc I) →
motive { toPrepartition := toPrepartition, tag := tag, tag_mem_Icc := tag_mem_Icc }) →
motive t |
String.Pos.toSlice_le._simp_1 | Init.Data.String.Basic | ∀ {s : String} {p q : s.Pos}, (p.toSlice ≤ q.toSlice) = (p ≤ q) |
CategoryTheory.Pseudofunctor.whiskerRight_mapId_inv | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b),
CategoryTheory.Bicategory.whiskerRight (F.mapId a).inv (F.map f) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (F.map f)).hom
(CategoryTheory.CategoryStruct.comp (F.map₂ (CategoryTheory.Bicategory.leftUnitor f).inv)
(F.mapComp (CategoryTheory.CategoryStruct.id a) f).hom) |
Lean.Meta.Match.matchEqnsExt | Lean.Meta.Match.MatchEqsExt | Lean.EnvExtension Lean.Meta.Match.MatchEqnsExtState |
Mathlib.Tactic.Abel.AbelMode.casesOn | Mathlib.Tactic.Abel | {motive : Mathlib.Tactic.Abel.AbelMode → Sort u} →
(t : Mathlib.Tactic.Abel.AbelMode) →
motive Mathlib.Tactic.Abel.AbelMode.term → motive Mathlib.Tactic.Abel.AbelMode.raw → motive t |
SSet.Subcomplex.Pairing.RankFunction.rec | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} →
{P : A.Pairing} →
{α : Type v} →
[inst : PartialOrder α] →
{motive : P.RankFunction α → Sort u_1} →
((rank : ↑P.II → α) →
(lt : ∀ {x y : ↑P.II}, P.AncestralRel x y → rank x < rank y) → motive { rank := rank, lt := lt }) →
(t : P.RankFunction α) → motive t |
ReaderT.run_orElse | Batteries.Control.Lemmas | ∀ {m : Type u_1 → Type u_2} {ρ α : Type u_1} [inst : Monad m] [inst_1 : Alternative m] (x y : ReaderT ρ m α) (ctx : ρ),
(x <|> y).run ctx = (x.run ctx <|> y.run ctx) |
Nat.divisors_prime_pow | Mathlib.NumberTheory.Divisors | ∀ {p : ℕ} (pp : Nat.Prime p) (k : ℕ),
(p ^ k).divisors = Finset.map { toFun := fun x => p ^ x, inj' := ⋯ } (Finset.range (k + 1)) |
Quiver.Symmetrify.lift.match_1 | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} →
[inst : Quiver V] →
{X Y : Quiver.Symmetrify V} →
(motive : (X ⟶ Y) → Sort u_3) →
(x : X ⟶ Y) → ((g : X ⟶ Y) → motive (Sum.inl g)) → ((g : Y ⟶ X) → motive (Sum.inr g)) → motive x |
Algebra.Presentation.compRelationAux | Mathlib.RingTheory.Extension.Presentation.Basic | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{ι' : Type u_1} →
{σ' : Type u_2} →
{T : Type u_3} →
[inst_3 : CommRing T] →
[inst_4 : Algebra S T] →
Algebra.Presentation S T ι' σ' → Algebra.Presentation R S ι σ → σ' → MvPolynomial (ι' ⊕ ι) R |
SemistandardYoungTableau.col_strict | Mathlib.Combinatorics.Young.SemistandardTableau | ∀ {μ : YoungDiagram} (T : SemistandardYoungTableau μ) {i1 i2 j : ℕ}, i1 < i2 → (i2, j) ∈ μ → T i1 j < T i2 j |
Lean.Meta.instMonadMCtxMetaM | Lean.Meta.Basic | Lean.MonadMCtx Lean.MetaM |
InnerProductSpace.Core.toSeminormedAddCommGroup._proof_4 | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), √(RCLike.re (inner 𝕜 (-x) (-x))) = √(RCLike.re (inner 𝕜 x x)) |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.mem_filter_key._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) |
Substring.Raw.hasBeq | Init.Data.String.Substring | BEq Substring.Raw |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.oangle_sign_smul_add_right._proof_1_3 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V),
(∀ (r' : ℝ), o.oangle x (r' • x + y) ≠ 0 ∧ o.oangle x (r' • x + y) ≠ ↑Real.pi) →
∀ z ∈ (fun r' => (x, r' • x + y)) '' Set.univ, ¬o.oangle z.1 z.2 = 0 ∧ ¬o.oangle z.1 z.2 = ↑Real.pi |
Finset.sum_mul_boole | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonAssocSemiring R] [inst_1 : DecidableEq ι] (s : Finset ι) (f : ι → R) (i : ι),
(∑ j ∈ s, f j * if i = j then 1 else 0) = if i ∈ s then f i else 0 |
Algebra.IsInvariant.recOn | Mathlib.RingTheory.Invariant.Defs | {A : Type u_1} →
{B : Type u_2} →
{G : Type u_3} →
[inst : CommSemiring A] →
[inst_1 : Semiring B] →
[inst_2 : Algebra A B] →
[inst_3 : Group G] →
[inst_4 : MulSemiringAction G B] →
{motive : Algebra.IsInvariant A B G → Sort u} →
(t : Algebra.IsInvariant A B G) →
((isInvariant : ∀ (b : B), (∀ (g : G), g • b = b) → ∃ a, (algebraMap A B) a = b) → motive ⋯) →
motive t |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValidForSlice_sliceTo.match_1_3 | Init.Data.String.Basic | ∀ {s : String.Slice} {p : s.Pos} {off : String.Pos.Raw}
(motive : off ≤ p.offset ∧ String.Pos.Raw.IsValidForSlice s off → Prop)
(x : off ≤ p.offset ∧ String.Pos.Raw.IsValidForSlice s off),
(∀ (h₁ : off ≤ p.offset) (h₂ : off ≤ s.rawEndPos)
(h₃ : String.Pos.Raw.IsValid s.str (off.offsetBy s.startInclusive.offset)), motive ⋯) →
motive x |
ENNReal.tsum_eq_iSup_nat | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {f : ℕ → ENNReal}, ∑' (i : ℕ), f i = ⨆ i, ∑ a ∈ Finset.range i, f a |
Option.instSMulCommClass | Mathlib.Algebra.Group.Action.Option | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_3} [inst : SMul M α] [inst_1 : SMul N α] [SMulCommClass M N α],
SMulCommClass M N (Option α) |
CategoryTheory.Pretriangulated.Triangle.instZeroHom._proof_6 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} [inst_2 : CategoryTheory.Preadditive C]
[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive],
CategoryTheory.CategoryStruct.comp T₁.mor₃ ((CategoryTheory.shiftFunctor C 1).map 0) =
CategoryTheory.CategoryStruct.comp 0 T₂.mor₃ |
Profinite.NobelingProof.πs._proof_1 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] (o : Ordinal.{u_1}),
Continuous (Profinite.NobelingProof.ProjRestrict C fun x => Profinite.NobelingProof.ord I x < o) |
SeminormedAddGroup.toNorm | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → [self : SeminormedAddGroup E] → Norm E |
PresheafOfModules.isoMk._proof_8 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X)
(naturality :
∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (M₁.map f)
((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y).hom) =
CategoryTheory.CategoryStruct.comp (app X).hom (M₂.map f)),
CategoryTheory.CategoryStruct.comp { app := fun X => (app X).inv, naturality := ⋯ }
{ app := fun X => (app X).hom, naturality := ⋯ } =
CategoryTheory.CategoryStruct.id M₂ |
_private.Mathlib.Data.List.Sort.0.List.Pairwise.eq_of_mem_iff._proof_1_2 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l₁ l₂ : List α}, (∀ (a : α), a ∈ l₁ ↔ a ∈ l₂) → l₂ ⊆ l₁ |
Lean.Widget.HighlightedMsgEmbed.goal.noConfusion | Lean.Server.FileWorker.WidgetRequests | {P : Sort u} →
{a a' : Lean.Widget.InteractiveGoal} →
Lean.Widget.HighlightedMsgEmbed.goal a = Lean.Widget.HighlightedMsgEmbed.goal a' → (a = a' → P) → P |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscreteWithin_accPt._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {S T : Set X},
(S ∈ Filter.codiscreteWithin T) = ∀ x ∈ T, Disjoint (nhdsWithin x {x}ᶜ) (Filter.principal (T \ S)) |
Std.Tactic.BVDecide.BVExpr.bin._override | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {w : ℕ} →
Std.Tactic.BVDecide.BVExpr w →
Std.Tactic.BVDecide.BVBinOp → Std.Tactic.BVDecide.BVExpr w → Std.Tactic.BVDecide.BVExpr w |
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.termExt_iff_1 | Mathlib.Analysis.InnerProductSpace.Defs | Lean.ParserDescr |
Matrix.Commute.zpow_right | Mathlib.LinearAlgebra.Matrix.ZPow | ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
{A B : Matrix n' n' R}, Commute A B → ∀ (m : ℤ), Commute A (B ^ m) |
CategoryTheory.Discrete.costructuredArrowEquivalenceOfUnique._proof_9 | Mathlib.CategoryTheory.Discrete.StructuredArrow | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {T : Type u_2}
(F : CategoryTheory.Functor C (CategoryTheory.Discrete T)) (t : T) [inst_1 : Subsingleton T]
{X Y : CategoryTheory.CostructuredArrow F { as := t }} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id (CategoryTheory.CostructuredArrow F { as := t })).map f)
((fun x =>
CategoryTheory.CostructuredArrow.isoMk
(CategoryTheory.Iso.refl
((CategoryTheory.Functor.id (CategoryTheory.CostructuredArrow F { as := t })).obj x).left)
⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun x =>
CategoryTheory.CostructuredArrow.isoMk
(CategoryTheory.Iso.refl
((CategoryTheory.Functor.id (CategoryTheory.CostructuredArrow F { as := t })).obj x).left)
⋯)
X).hom
(((CategoryTheory.CostructuredArrow.proj F { as := t }).comp
{ obj := fun X => CategoryTheory.CostructuredArrow.mk (CategoryTheory.eqToHom ⋯),
map := fun {X Y} f => CategoryTheory.CostructuredArrow.homMk f ⋯, map_id := ⋯, map_comp := ⋯ }).map
f) |
_private.Mathlib.Algebra.Group.ForwardDiff.0.fwdDiff_iter_pow_eq_zero_of_lt._proof_1_3 | Mathlib.Algebra.Group.ForwardDiff | ∀ (n : ℕ) {j : ℕ}, j < n + 1 → ∀ i < j, i < n |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKeyD_eq_iff_getKey?_eq_self_and_forall._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
UniformSpace.ofCoreEq_toCore | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} (u : UniformSpace α) (t : TopologicalSpace α) (h : t = u.toCore.toTopologicalSpace),
UniformSpace.ofCoreEq u.toCore t h = u |
_private.Mathlib.RingTheory.Valuation.LocalSubring.0.Ideal.image_subset_nonunits_valuationSubring.match_1_1 | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_1} [inst : Field K] {A : Subring K} (I : Ideal ↥A) (motive : (∃ M, M.IsMaximal ∧ I ≤ M) → Prop)
(x : ∃ M, M.IsMaximal ∧ I ≤ M), (∀ (M : Ideal ↥A) (hM : M.IsMaximal) (le : I ≤ M), motive ⋯) → motive x |
List.takeListTR.go.eq_def | Batteries.Data.List.Basic | ∀ {α : Type u_1} (x : List ℕ) (x_1 : List α) (x_2 : Array (List α)),
List.takeListTR.go x x_1 x_2 =
match x, x_1, x_2 with
| [], xs, acc => (acc.toList, xs)
| n :: ns, xs, acc =>
match List.splitAt n xs with
| (xs₁, xs₂) => List.takeListTR.go ns xs₂ (acc.push xs₁) |
Prod.instMonoid._proof_2 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] (a : M × N), a * 1 = a |
CategoryTheory.MarkovCategory.discard_natural_assoc | Mathlib.CategoryTheory.MarkovCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.MarkovCategory C] {X Y : C} (f : X ⟶ Y) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp CategoryTheory.ComonObj.counit h) =
CategoryTheory.CategoryStruct.comp CategoryTheory.ComonObj.counit h |
Vector.find?_eq_none | Init.Data.Vector.Find | ∀ {α : Type} {p : α → Bool} {n : ℕ} {l : Vector α n}, Vector.find? p l = none ↔ ∀ x ∈ l, ¬p x = true |
ite_and | Mathlib.Logic.Basic | ∀ {α : Sort u_1} (P Q : Prop) [inst : Decidable P] (a b : α) [inst_1 : Decidable Q],
(if P ∧ Q then a else b) = if P then if Q then a else b else b |
StandardEtalePair.equivAwayAdjoinRoot._proof_8 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R),
(P.lift ((algebraMap (AdjoinRoot P.f) (Localization.Away ((AdjoinRoot.mk P.f) P.g))) (AdjoinRoot.root P.f)) ⋯).comp
(IsLocalization.liftAlgHom ⋯) =
AlgHom.id R (Localization.Away ((AdjoinRoot.mk P.f) P.g)) |
MonoidHom.mem_ker._simp_2 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {M : Type u_7} [inst_1 : MulOneClass M] {f : G →* M} {x : G}, (x ∈ f.ker) = (f x = 1) |
SeminormedGroup.toContinuousENorm._proof_1 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_1} [inst : SeminormedGroup E], Continuous (ENNReal.ofNNReal ∘ nnnorm) |
LinearMap.map_eq_zero_iff._simp_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {S : Type u_5} {M : Type u_8} {M₃ : Type u_11} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
(f : M →ₛₗ[σ] M₃), Function.Injective ⇑f → ∀ {x : M}, (f x = 0) = (x = 0) |
Digraph.sdiff | Mathlib.Combinatorics.Digraph.Basic | {V : Type u_2} → SDiff (Digraph V) |
Computability.Encoding._sizeOf_inst | Mathlib.Computability.Encoding | (α : Type u) → [SizeOf α] → SizeOf (Computability.Encoding α) |
ConvexOn.isMinOn_of_leftDeriv_eq_zero | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x : ℝ}, ConvexOn ℝ S f → x ∈ interior S → derivWithin f (Set.Iio x) x = 0 → IsMinOn f S x |
Std.HashSet.Equiv.congr_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α}, m₁.Equiv m₂ → (m₃.Equiv m₁ ↔ m₃.Equiv m₂) |
Lean.Linter.linter.unusedVariables.analyzeTactics | Lean.Linter.UnusedVariables | Lean.Option Bool |
Polynomial.degree_wronskian_lt_add | Mathlib.RingTheory.Polynomial.Wronskian | ∀ {R : Type u_1} [inst : CommRing R] {a b : Polynomial R}, a ≠ 0 → b ≠ 0 → (a.wronskian b).degree < a.degree + b.degree |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.toArray_rcc_succ_right_eq_append_map._simp_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, (m...=n).toArray = (m...=n).toList.toArray |
RingCon.mk.injEq | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] (toCon : Con R)
(add' : ∀ {w x y z : R}, toCon.toSetoid w x → toCon.toSetoid y z → toCon.toSetoid (w + y) (x + z)) (toCon_1 : Con R)
(add'_1 : ∀ {w x y z : R}, toCon_1.toSetoid w x → toCon_1.toSetoid y z → toCon_1.toSetoid (w + y) (x + z)),
({ toCon := toCon, add' := add' } = { toCon := toCon_1, add' := add'_1 }) = (toCon = toCon_1) |
AddSubsemigroup.instCompleteLattice._proof_8 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Add M] (a b c : AddSubsemigroup M), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c |
tendsto_norm_inv_mul_self_nhdsNE | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} [inst : NormedGroup E] (a : E),
Filter.Tendsto (fun x => ‖x⁻¹ * a‖) (nhdsWithin a {a}ᶜ) (nhdsWithin 0 (Set.Ioi 0)) |
NonemptyInterval.toDualProdHom | Mathlib.Order.Interval.Basic | {α : Type u_1} → [inst : LE α] → NonemptyInterval α ↪o αᵒᵈ × α |
Lean.Compiler.LCNF.ExtractClosed.extractFVar._unsafe_rec | Lean.Compiler.LCNF.ExtractClosed | Lean.FVarId → Lean.Compiler.LCNF.ExtractClosed.ExtractM Unit |
CategoryTheory.leftAdjointMate_comp | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.HasLeftDual X] [inst_3 : CategoryTheory.HasLeftDual Y] {f : X ⟶ Y} {g : ᘁX ⟶ Z},
CategoryTheory.CategoryStruct.comp (ᘁf) g =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor ᘁY).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight (η_ (ᘁX) X) ᘁY)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.MonoidalCategoryStruct.tensorHom g f) ᘁY)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Z Y ᘁY).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z (ε_ (ᘁY) Y))
(CategoryTheory.MonoidalCategoryStruct.rightUnitor Z).hom)))) |
HomologicalComplex.instHasFilteredColimitsOfSize | Mathlib.Algebra.Homology.GrothendieckAbelian | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {ι : Type t} (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', v, u} C],
CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', max t v, max (max t u) v} (HomologicalComplex C c) |
CategoryTheory.constantCommuteCompose_hom_app_val | Mathlib.CategoryTheory.Sites.ConstantSheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
{D : Type u_2} [inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.HasWeakSheafify J D]
{B : Type u_3} [inst_3 : CategoryTheory.Category.{v_3, u_3} B] (U : CategoryTheory.Functor D B)
[inst_4 : CategoryTheory.HasWeakSheafify J B] [inst_5 : J.PreservesSheafification U] [inst_6 : J.HasSheafCompose U]
(X : D),
((CategoryTheory.constantCommuteCompose J U).hom.app X).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.sheafifyComposeIso J U ((CategoryTheory.Functor.const Cᵒᵖ).obj X)).inv
(CategoryTheory.sheafifyMap J (CategoryTheory.Functor.constComp Cᵒᵖ X U).hom) |
Lean.Lsp.DependencyBuildMode.never.sizeOf_spec | Lean.Data.Lsp.Extra | sizeOf Lean.Lsp.DependencyBuildMode.never = 1 |
LinearMap.tensorProduct._proof_5 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (A : Type u_2) (M : Type u_4) (N : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : AddCommMonoid N]
[inst_6 : Module R N], IsScalarTower R A (TensorProduct R A M →ₗ[A] TensorProduct R A N) |
Std.Broadcast.noConfusion | Std.Sync.Broadcast | {P : Sort u} →
{α : Type} →
{t : Std.Broadcast α} →
{α' : Type} → {t' : Std.Broadcast α'} → α = α' → t ≍ t' → Std.Broadcast.noConfusionType P t t' |
UInt64.sub_eq_add_neg | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a - b = a + -b |
Mathlib.Meta.FunProp.MorApplication.ctorIdx | Mathlib.Tactic.FunProp.FunctionData | Mathlib.Meta.FunProp.MorApplication → ℕ |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.not_summable_residueClass_prime_div._simp_1_4 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α] [AddLeftStrictMono α] [AddLeftReflectLT α] (a : α) {b : α},
(a < a + b) = (0 < b) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.