name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_invalid_of_isInvalidContinuationByte_eq_false | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.isInvalidContinuationByte b = false →
ByteArray.utf8DecodeChar?.parseFirstByte b = ByteArray.utf8DecodeChar?.FirstByte.invalid | true |
Lean.EnvExtension.instInhabitedAsyncMode | Lean.Environment | Inhabited Lean.EnvExtension.AsyncMode | true |
_private.Mathlib.Analysis.Normed.Lp.lpSpace.0.Memℓp.const_smul._simp_1_5 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {x y : NNReal} {z : ℝ}, x ^ z * y ^ z = (x * y) ^ z | false |
Aesop.LIFOQueue.mk.sizeOf_spec | Aesop.Search.Queue | ∀ (goals : Array Aesop.GoalRef), sizeOf { goals := goals } = 1 + sizeOf goals | true |
IO.Promise.noConfusion | Init.System.Promise | {P : Sort u} →
{α : Type} →
{t : IO.Promise α} → {α' : Type} → {t' : IO.Promise α'} → α = α' → t ≍ t' → IO.Promise.noConfusionType P t t' | false |
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 | false |
Rep.linearization._proof_4 | Mathlib.RepresentationTheory.Rep.Basic | ∀ (k : Type u_3) (G : Type u_2) [inst : CommRing k] [inst_1 : Monoid G] {X Y Z : Action (Type u_1) G} (f : X ⟶ Y)
(g : Y ⟶ Z),
Rep.ofHom (Representation.linearizeMap (CategoryTheory.CategoryStruct.comp f g)) =
CategoryTheory.CategoryStruct.comp (Rep.ofHom (Representation.linearizeMap f))
(Rep.ofHom (Repre... | false |
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 | false |
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.ofUniq... | false |
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 | true |
Mathlib.Tactic.AtomM.addAtom | Mathlib.Util.AtomM | Lean.Expr → Mathlib.Tactic.AtomM (ℕ × Lean.Expr) | true |
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₀ | true |
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 | true |
_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) | false |
CategoryTheory.Limits.ReflectsColimitsOfSize.reflectsColimitsOfShape._autoParam | Mathlib.CategoryTheory.Limits.Preserves.Basic | Lean.Syntax | false |
mod_natCard_zsmul | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : AddGroup G] (a : G) (n : ℤ), (n % ↑(Nat.card G)) • a = n • a | true |
_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 | false |
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 α) | true |
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 (... | false |
_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) | false |
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 | true |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.atomise_empty._simp_1_4 | Mathlib.Order.Partition.Finpartition | ∀ (α : Sort u), (∀ (a : α), True) = True | false |
_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)) | false |
Int.toArray_roc_eq_push | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, m < n → (m<...=n).toArray = (m<...=n - 1).toArray.push n | true |
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 → ... | false |
Bornology.ext_iff' | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {t t' : Bornology α}, t = t' ↔ ∀ (s : Set α), s ∈ Bornology.cobounded α ↔ s ∈ Bornology.cobounded α | true |
Nat.count_true | Mathlib.Data.Nat.Count | ∀ (n : ℕ), Nat.count (fun x => True) n = n | true |
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 | true |
CategoryTheory.Monoidal.instMonoidalTransportedInverseSymmEquivalenceTransported._proof_6 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] (e : C ≌ D) (X Y : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.Monoidal.equivalenceTrans... | false |
CategoryTheory.PreZeroHypercover.empty | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (S : C) → CategoryTheory.PreZeroHypercover S | true |
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 | true |
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 | false |
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 | true |
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) →
... | true |
instFieldCyclotomicField._proof_41 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_1) [inst : Field K],
autoParam
(∀ (n_1 : ℕ) (a : CyclotomicField n K),
instFieldCyclotomicField._aux_37 n K (Int.negSucc n_1) a = -instFieldCyclotomicField._aux_37 n K (↑n_1.succ) a)
SubNegMonoid.zsmul_neg'._autoParam | false |
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... | true |
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
... | true |
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) | false |
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' | true |
_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 : ℕ) →
... | true |
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) | true |
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] [IsScalarTow... | true |
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 ∈ ... | false |
String.Pos.toSlice_le._simp_1 | Init.Data.String.Basic | ∀ {s : String} {p q : s.Pos}, (p.toSlice ≤ q.toSlice) = (p ≤ q) | false |
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.m... | true |
Lean.Meta.Match.matchEqnsExt | Lean.Meta.Match.MatchEqsExt | Lean.EnvExtension Lean.Meta.Match.MatchEqnsExtState | true |
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 | false |
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 }) →
... | false |
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) | true |
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)) | true |
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 | false |
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] →
... | true |
SemistandardYoungTableau.col_strict | Mathlib.Combinatorics.Young.SemistandardTableau | ∀ {μ : YoungDiagram} (T : SemistandardYoungTableau μ) {i1 i2 j : ℕ}, i1 < i2 → (i2, j) ∈ μ → T i1 j < T i2 j | true |
Lean.Meta.instMonadMCtxMetaM | Lean.Meta.Basic | Lean.MonadMCtx Lean.MetaM | true |
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)) | false |
_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) | false |
Substring.Raw.hasBeq | Init.Data.String.Substring | BEq Substring.Raw | true |
_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 ... | false |
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 | true |
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} →
... | false |
_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.off... | false |
ENNReal.tsum_eq_iSup_nat | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {f : ℕ → ENNReal}, ∑' (i : ℕ), f i = ⨆ i, ∑ a ∈ Finset.range i, f a | true |
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 α) | true |
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.shi... | false |
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) | false |
SeminormedAddGroup.toNorm | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → [self : SeminormedAddGroup E] → Norm E | true |
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 (RingCa... | false |
_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₁ | false |
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 | false |
_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)) | false |
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 | false |
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.termExt_iff_1 | Mathlib.Analysis.InnerProductSpace.Defs | Lean.ParserDescr | true |
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) | true |
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 (Categ... | false |
_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 | false |
_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) | 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 | true |
_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 | false |
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₁) | true |
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 | false |
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 Catego... | true |
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 | true |
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)) | false |
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 | true |
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) | false |
SeminormedGroup.toContinuousENorm._proof_1 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_1} [inst : SeminormedGroup E], Continuous (ENNReal.ofNNReal ∘ nnnorm) | false |
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) | false |
Digraph.sdiff | Mathlib.Combinatorics.Digraph.Basic | {V : Type u_2} → SDiff (Digraph V) | true |
Computability.Encoding._sizeOf_inst | Mathlib.Computability.Encoding | (α : Type u) → [SizeOf α] → SizeOf (Computability.Encoding α) | false |
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 | true |
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₂) | true |
Lean.Linter.linter.unusedVariables.analyzeTactics | Lean.Linter.UnusedVariables | Lean.Option Bool | true |
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 | true |
_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 | false |
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' ... | true |
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 | false |
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)) | true |
NonemptyInterval.toDualProdHom | Mathlib.Order.Interval.Basic | {α : Type u_1} → [inst : LE α] → NonemptyInterval α ↪o αᵒᵈ × α | true |
Lean.Compiler.LCNF.ExtractClosed.extractFVar._unsafe_rec | Lean.Compiler.LCNF.ExtractClosed | Lean.FVarId → Lean.Compiler.LCNF.ExtractClosed.ExtractM Unit | false |
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 (CategoryT... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.