name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
MeasureTheory.eLpNorm'_mono_ae | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_5} {G : Type u_6} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G},
0 ≤ q → (∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ ‖g x‖) → MeasureTheory.eLpNorm' f q μ ≤ MeasureTheory.eLpNorm' g q μ | true |
Filter.eventually_mem_set._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α} {l : Filter α}, (∀ᶠ (x : α) in l, x ∈ s) = (s ∈ l) | false |
AddSubgroup.normalCore._proof_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x x_1 : G},
x ∈ {a | ∀ (b : G), b + a + -b ∈ H} → x_1 ∈ {a | ∀ (b : G), b + a + -b ∈ H} → ∀ (c : G), c + (x + x_1) + -c ∈ H | false |
isFullyInvariant_iff_sSup_isotypicComponents | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSemisimpleModule R M]
{m : Submodule R M}, m.IsFullyInvariant ↔ ∃ s ⊆ isotypicComponents R M, m = sSup s | true |
PointedCone.IsSimplicial.hull | Mathlib.Geometry.Convex.Cone.Simplicial | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {s : Set M},
s.Finite → LinearIndepOn R id s → (PointedCone.hull R s).IsSimplicial | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.Tangent.0.termTM | Mathlib.Geometry.Manifold.VectorBundle.Tangent | Lean.ParserDescr | true |
List.alternatingSum_nil | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : Zero G] [inst_1 : Add G] [inst_2 : Neg G], [].alternatingSum = 0 | true |
Lean.Meta.Grind.mkEqHEqProof | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Lean.Expr | true |
WithLp._sizeOf_inst | Mathlib.Analysis.Normed.Lp.WithLp | (p : ENNReal) → (V : Type u_1) → [SizeOf V] → SizeOf (WithLp p V) | false |
continuous_clm_apply | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type w} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [CompleteSpace 𝕜]
{X : Type u_1} [inst_6 : TopologicalSpace X] [FiniteDimensional 𝕜 E] {f : X → E →L[𝕜] F},
Conti... | true |
CategoryTheory.Monoidal.functorCategoryMonoidal._proof_13 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y : CategoryTheory.Functor C D} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
... | false |
Std.TreeSet.min!_insert_le_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(cmp (t.insert k).min! k).isLE = true | true |
_private.Mathlib.Analysis.InnerProductSpace.Basic.0.inner_eq_norm_mul_iff_div._simp_1_6 | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
Std.DTreeMap.Internal.Impl.Const.toListModel_insertManyIfNewUnit!_list | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {x : Ord α} [Std.TransOrd α] [inst : BEq α] [Std.LawfulBEqOrd α] {l : List α}
{t : Std.DTreeMap.Internal.Impl α fun x => Unit},
t.WF →
(↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit! t l)).toListModel.Perm
(Std.Internal.List.insertListIfNewUnit t.toListModel l) | true |
BitVec.sub_add_comm | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {z x y : BitVec w}, x - y + z = x + z - y | true |
SimpleGraph.isAcyclic_sup_fromEdgeSet_iff | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V},
(G ⊔ SimpleGraph.edge u v).IsAcyclic ↔ G.IsAcyclic ∧ (G.Reachable u v → u = v ∨ G.Adj u v) | true |
Lean.Elab.Do.DoElemContKind._sizeOf_inst | Lean.Elab.Do.Basic | SizeOf Lean.Elab.Do.DoElemContKind | false |
_private.Mathlib.RingTheory.Coalgebra.Basic.0.Coalgebra.sum_tmul_tmul_eq._simp_1_1 | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m : M) {α : Type u_22} (s : Finset α)
(n : α → N), ∑ a ∈ s, m ⊗ₜ[R] n a = m ⊗ₜ[R] ∑ a ∈ s, n a | false |
Array.le_sum_div_length_of_min?_eq_some_nat | Init.Data.Array.Nat | ∀ {x : ℕ} {xs : Array ℕ}, xs.min? = some x → x ≤ xs.sum / xs.size | true |
ULiftable.recOn | Mathlib.Control.ULiftable | {f : Type u₀ → Type u₁} →
{g : Type v₀ → Type v₁} →
{motive : ULiftable f g → Sort u} →
(t : ULiftable f g) →
((congr : {α : Type u₀} → {β : Type v₀} → α ≃ β → f α ≃ g β) → motive { congr := congr }) → motive t | false |
Module.End.hasEigenvalue_iff_isRoot_charpoly | Mathlib.LinearAlgebra.Eigenspace.Charpoly | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inst_4 : Module.Free R M] [inst_5 : Module.Finite R M] (f : Module.End R M) (μ : R),
f.HasEigenvalue μ ↔ (LinearMap.charpoly f).IsRoot μ | true |
_private.Batteries.Tactic.Lint.Simp.0.Batteries.Tactic.Lint.formatLemmas._sparseCasesOn_2 | Batteries.Tactic.Lint.Simp | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Lat.Iso.mk._proof_3 | Mathlib.Order.Category.Lat | ∀ {α β : Lat} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊔ b) = e.symm a ⊔ e.symm b | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.mk._flat_ctor | Std.Sync.Channel | {α : Type} →
Std.Queue (IO.Promise Bool) →
Std.Queue (Std.CloseableChannel.Bounded.Consumer✝ α) →
(capacity : ℕ) →
Vector (IO.Ref (Option α)) capacity →
ℕ →
(sendIdx : ℕ) →
sendIdx < capacity → (recvIdx : ℕ) → recvIdx < capacity → Bool → Std.CloseableChannel.Bound... | false |
groupHomology.shortComplexH0 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] → [inst_1 : Group G] → Rep.{u, u, u} k G → CategoryTheory.ShortComplex (ModuleCat k) | true |
WithBot.instIsOrderedRing | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommSemiring α] [inst_2 : PartialOrder α] [IsOrderedRing α]
[inst_4 : CanonicallyOrderedAdd α] [inst_5 : NoZeroDivisors α] [inst_6 : Nontrivial α], IsOrderedRing (WithBot α) | true |
Batteries.RBNode.Path.insertNew.eq_1 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} (path : Batteries.RBNode.Path α) (v : α),
path.insertNew v = path.ins (Batteries.RBNode.node Batteries.RBColor.red Batteries.RBNode.nil v Batteries.RBNode.nil) | true |
Batteries.RBNode.setRed.eq_2 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1}, Batteries.RBNode.nil.setRed = Batteries.RBNode.nil | true |
Algebra.TensorProduct.tensorTensorTensorComm_symm | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type uR} {R' : Type u_1} {S : Type uS} {T : Type u_2} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD}
[inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] [inst_3 : Semiring A] [inst_4 : Algebra R A]
[inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] [inst_7 : Semiring B] [inst... | true |
UInt8.sub_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, b ≤ a → a - b ≤ a | true |
RingCat.Colimits.Prequotient.ctorElim | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J RingCat} →
{motive : RingCat.Colimits.Prequotient F → Sort u} →
(ctorIdx : ℕ) →
(t : RingCat.Colimits.Prequotient F) →
ctorIdx = t.ctorIdx → RingCat.Colimits.Prequotient.ctorElimType ctorIdx ... | false |
AbsoluteValue.isAbsoluteValue | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R]
(abv : AbsoluteValue R S), IsAbsoluteValue ⇑abv | true |
Matroid.Indep.rankPos_of_nonempty | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → I.Nonempty → M.RankPos | true |
MeasureTheory.hausdorffMeasure_smul | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] {α : Type u_4}
[inst_3 : SMul α X] [IsIsometricSMul α X] {d : ℝ} (c : α),
(0 ≤ d ∨ Function.Surjective fun x => c • x) →
∀ (s : Set X), (MeasureTheory.Measure.hausdorffMeasure d) (c • s) = (MeasureTheory.Measure.hausdo... | true |
Std.TreeMap.minKey!_modify | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{k : α} {f : β → β},
(t.modify k f).isEmpty = false → (t.modify k f).minKey! = if cmp t.minKey! k = Ordering.eq then k else t.minKey! | true |
Std.Time.PlainDateTime.mk.sizeOf_spec | Std.Time.DateTime.PlainDateTime | ∀ (date : Std.Time.PlainDate) (time : Std.Time.PlainTime),
sizeOf { date := date, time := time } = 1 + sizeOf date + sizeOf time | true |
Lean.Grind.Ring.intCast_zero | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.Ring α], ↑0 = 0 | true |
Finset.Nonempty.of_smul_left | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] {s : Finset α} {t : Finset β},
(s • t).Nonempty → s.Nonempty | true |
CategoryTheory.AdditiveFunctor.ofLeftExact_map | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasZeroObject C] [inst_5 : CategoryTheory.Limits.HasZeroObject D]
[inst_6 : Catego... | true |
lt_or_le_of_codirected | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] {r v₁ v₂ : α},
r ≤ v₁ → r ≤ v₂ → v₁ < v₂ ∨ v₂ ≤ v₁ | true |
Lean.Meta.Sym.Simp.Result.rfl.injEq | Lean.Meta.Sym.Simp.SimpM | ∀ (done done_1 : Bool), (Lean.Meta.Sym.Simp.Result.rfl done = Lean.Meta.Sym.Simp.Result.rfl done_1) = (done = done_1) | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.Point.toClass.match_1.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} (motive : W.Point → Sort u_2)
(h_1 : Unit → motive WeierstrassCurve.Affine.Point.zero)
(h_2 : (x y : F) → (h : W.Nonsingular x y) → motive (WeierstrassCurve.Affine.Point.some x y h)),
(match WeierstrassCurve.Affine.Point.zero with
| Weierstrass... | true |
Algebra.adjoin_insert_adjoin | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (s : Set A) (x : A),
Algebra.adjoin R (insert x ↑(Algebra.adjoin R s)) = Algebra.adjoin R (insert x s) | true |
Lean.Elab.Term.MVarErrorKind._sizeOf_inst | Lean.Elab.Term.TermElabM | SizeOf Lean.Elab.Term.MVarErrorKind | false |
GrpCat.limitCone | Mathlib.Algebra.Category.Grp.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J GrpCat) →
[Small.{u, max u v} ↑(F.comp (CategoryTheory.forget GrpCat)).sections] → CategoryTheory.Limits.Cone F | true |
Batteries.Tactic.getExplicitRelArg?._sunfold | Batteries.Tactic.Trans | Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr)) | false |
Real.rpow_sum_le_const_mul_sum_rpow_of_nonneg | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} (s : Finset ι) {f : ι → ℝ} {p : ℝ},
1 ≤ p → (∀ i ∈ s, 0 ≤ f i) → (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p | true |
String.Pos.Raw.byteIdx_add_string | Init.Data.String.PosRaw | ∀ {p : String.Pos.Raw} {s : String}, (p + s).byteIdx = p.byteIdx + s.utf8ByteSize | true |
MonCat.Colimits.colimitIsColimit._proof_2 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cocone F) (m : (MonCat.Colimits.colimitCocone F).pt ⟶ s.pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp ((MonCat.Colimits.colimitCocone F).ι.app j) m = s.ι.app j) →
m = MonCat.Coli... | false |
instHasColimitsOfShapeUnderOfWithInitial | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
(X : C) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.WithInitial J) C],
CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.Under X) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.support_getElem_one._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, 1 ≤ p.length → 1 < p.support.length | false |
ContMDiffAt.curry_left | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
LaurentPolynomial.degree_zero | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R], LaurentPolynomial.degree 0 = ⊥ | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go.match_1.splitter | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound | {n : ℕ} →
(motive : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool → Sort u_1) →
(x : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool) →
((fst : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) →
(checkSuccess : Bool) → motive (fst, checkSuccess)) →
motive x | true |
PNat.factorMultiset.eq_1 | Mathlib.Data.PNat.Factors | ∀ (n : ℕ+), n.factorMultiset = PrimeMultiset.ofNatList (↑n).primeFactorsList ⋯ | true |
CategoryTheory.Grothendieck.instCategory._proof_3 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (f : X.Hom Y), CategoryTheory.Grothendieck.comp X.id f = f | false |
_private.Init.Data.Nat.Lemmas.0.Nat.mul_eq_zero.match_1_1 | Init.Data.Nat.Lemmas | ∀ (n n_1 : ℕ) (motive : (n_1 + 1) * (n + 1) = 0 → Prop) (a : (n_1 + 1) * (n + 1) = 0), motive a | false |
Submonoid.map_inf_comap_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F},
Function.Surjective ⇑f → ∀ (S T : Submonoid N), Submonoid.map f (Submonoid.comap f S ⊓ Submonoid.comap f T) = S ⊓ T | true |
CStarModule.inner_zero_left | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ A] [inst_4 : Module ℂ E] [inst_5 : PartialOrder A] [inst_6 : SMul A E] [inst_7 : Norm A]
[inst_8 : Norm E] [inst_9 : CStarModule A E] [StarModule ℂ A] {x : E}, inner A 0 x = 0 | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getEntry_congr._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getEntry a l h) = Std.Internal.List.getEntry? a l | false |
Lean.Grind.AC.Seq.collectVars._sunfold | Lean.Meta.Tactic.Grind.AC.VarRename | Lean.Grind.AC.Seq → Lean.Meta.Grind.VarCollector | false |
Matrix.kroneckerBilinear._proof_3 | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {R : Type u_2} {α : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring α] [inst_2 : Algebra R α],
LinearMapClass (α →ₐ[R] Module.End R α) R α (Module.End R α) | false |
Int.fmod_eq_emod | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a.fmod b = a % b + if 0 ≤ b ∨ b ∣ a then 0 else b | true |
_private.Init.Data.String.Basic.0.String.Pos.Raw.offsetOfPosAux._unary._proof_1 | Init.Data.String.Basic | ∀ (s : String) (i : String.Pos.Raw),
¬String.Pos.Raw.atEnd s i = true → s.utf8ByteSize - (String.Pos.Raw.next s i).byteIdx < s.utf8ByteSize - i.byteIdx | false |
ContinuousLinearEquiv.toLinearEquiv | Mathlib.Topology.Algebra.Module.Equiv | {R : Type u_1} →
{S : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{σ : R →+* S} →
{σ' : S →+* R} →
[inst_2 : RingHomInvPair σ σ'] →
[inst_3 : RingHomInvPair σ' σ] →
{M : Type u_3} →
[inst_4 : TopologicalSpace M] →
... | true |
ProofWidgets.MarkdownDisplay.Props.mk | ProofWidgets.Component.Basic | String → ProofWidgets.MarkdownDisplay.Props | true |
Batteries.RBNode.Path.zoom_fill | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} {cut : α → Ordering} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α}
{t' : Batteries.RBNode α} {path' : Batteries.RBNode.Path α},
Batteries.RBNode.zoom cut t path = (t', path') → path.fill t = path'.fill t' | true |
CategoryTheory.Presieve.functorPushforward | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) → {X : C} → CategoryTheory.Presieve X → CategoryTheory.Presieve (F.obj X) | true |
SimplexCategory.Truncated.Hom.tr_id | Mathlib.AlgebraicTopology.SimplexCategory.Defs | ∀ {n : ℕ} (a : SimplexCategory) (ha : autoParam (a.len ≤ n) SimplexCategory.Truncated.Hom.tr_id._auto_1),
SimplexCategory.Truncated.Hom.tr (CategoryTheory.CategoryStruct.id a) ha ha =
CategoryTheory.CategoryStruct.id { obj := a, property := ha } | true |
ProbabilityTheory.Kernel.densityProcess_empty | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β))
(ν : ProbabilityTheory.Kernel α γ) (n : ℕ) (a : α) (x : γ), κ.densityProcess ν n a x ∅ = 0 | true |
Lean.Elab.FVarAliasInfo.mk | Lean.Elab.InfoTree.Types | Lean.Name → Lean.FVarId → Lean.FVarId → Lean.Elab.FVarAliasInfo | true |
Monotone.seq_pos_lt_seq_of_le_of_lt | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x y : ℕ → α},
Monotone f →
∀ {n : ℕ}, 0 < n → x 0 ≤ y 0 → (∀ k < n, x (k + 1) ≤ f (x k)) → (∀ k < n, f (y k) < y (k + 1)) → x n < y n | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fmod_sub_cancel_left._simp_1_2 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (b.fmod a = 0) = (a ∣ b) | false |
Mathlib.Tactic.BicategoryLike.Mor₂.whiskerLeft.inj | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ {e : Lean.Expr} {isoLift? : Option Mathlib.Tactic.BicategoryLike.IsoLift} {f g h : Mathlib.Tactic.BicategoryLike.Mor₁}
{η : Mathlib.Tactic.BicategoryLike.Mor₂} {e_1 : Lean.Expr} {isoLift?_1 : Option Mathlib.Tactic.BicategoryLike.IsoLift}
{f_1 g_1 h_1 : Mathlib.Tactic.BicategoryLike.Mor₁} {η_1 : Mathlib.Tactic.Bic... | true |
Std.DHashMap.Internal.Raw₀.filterₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : α → Type v} → Std.DHashMap.Internal.Raw₀ α β → ((a : α) → β a → Bool) → Std.DHashMap.Internal.Raw₀ α β | true |
Lean.Elab.Tactic.TacticParsedSnapshot.toSnapshot | Lean.Elab.Term.TermElabM | Lean.Elab.Tactic.TacticParsedSnapshot → Lean.Language.Snapshot | true |
Lean.Lsp.InlayHintKind.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintKind → Sort u} →
(t : Lean.Lsp.InlayHintKind) → motive Lean.Lsp.InlayHintKind.type → motive Lean.Lsp.InlayHintKind.parameter → motive t | false |
Aesop.LocalRuleSet.forwardRulePatternSubstsInLocalDecl | Aesop.RuleSet | Aesop.LocalRuleSet → Lean.LocalDecl → Aesop.BaseM (Array (Aesop.ForwardRule × Aesop.Substitution)) | true |
RingHom.coe_inj | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} ⦃f g : α →+* β⦄, ⇑f = ⇑g → f = g | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceBitVecOfFin.declare_333._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.4171913895._hygCtx._hyg.13 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | false |
OmegaCompletePartialOrder.Chain.ext | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} [inst : Preorder α] ⦃f g : OmegaCompletePartialOrder.Chain α⦄, ⇑f = ⇑g → f = g | true |
onePointEquivSphereOfFinrankEq._proof_5 | Mathlib.Topology.Compactification.OnePoint.Sphere | ∀ {ι : Type u_1} {V : Type u_2} [inst : Fintype ι] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V],
Module.finrank ℝ V + 1 = Fintype.card ι → Nonempty ι | false |
Int.strongRec.eq_1 | Mathlib.Data.Int.Basic | ∀ {m : ℤ} {motive : ℤ → Sort u_1} (lt : (n : ℤ) → n < m → motive n)
(ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → motive k) → motive n) (n : ℤ),
Int.strongRec lt ge n =
if hnm : n < m then lt n hnm
else
ge n ⋯
(Int.inductionOn' (motive := fun x => (k : ℤ) → k < x → motive k) n m lt
(fun... | true |
CovBy | Mathlib.Order.Defs.PartialOrder | {α : Type u_2} → [LT α] → α → α → Prop | true |
CategoryTheory.PreOneHypercover.cylinderHomotopy._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (CategoryTheory.PreOneHypercover.cylinder f g).I₀),
CategoryTheory.CategoryStruct.comp
(... | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_6} {B : Type u_3} {C : Type u_8} [inst : CategoryTheory.Category.{u_5, u_6} A]
[inst_1 : CategoryTheory.Category.{u_2, u_3} B] [inst_2 : CategoryTheory.Category.{u_7, u_8} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u_1} {Y : Type u_9}
[inst_3 : CategoryTheory.Cate... | false |
PreAbstractSimplicialComplex.map._proof_2 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] (K : PreAbstractSimplicialComplex α) (f : α → β) {x : Finset β},
x ∈ (fun s => Finset.image f s) '' K.faces →
x.Nonempty ∧ ∀ ⦃b : Finset β⦄, b ≤ x → b.Nonempty → b ∈ (fun s => Finset.image f s) '' K.faces | false |
IntermediateField.intermediateFieldMap_apply_coe | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] (e : L ≃ₐ[K] L') (E : IntermediateField K L) (a : ↥E),
↑((IntermediateField.intermediateFieldMap e E) a) = e ↑a | true |
GradedObject.eulerChar_eq_sum_finSet_of_finrankSupport_subset | Mathlib.Algebra.Homology.EulerCharacteristic | ∀ {R : Type u_1} [inst : Ring R] {ι : Type u_2} (c : ComplexShape ι) [inst_1 : c.EulerCharSigns]
(X : CategoryTheory.GradedObject ι (ModuleCat R)) (indices : Finset ι),
GradedObject.finrankSupport X ⊆ ↑indices →
GradedObject.eulerChar c X = ∑ i ∈ indices, ↑(c.χ i) * ↑(Module.finrank R ↑(X i)) | true |
Cardinal.powerlt_mono_left | Mathlib.SetTheory.Cardinal.Basic | ∀ (a : Cardinal.{u_1}), Monotone fun c => a ^< c | true |
Lean.Expr.FindStep.done | Lean.Util.FindExpr | Lean.Expr.FindStep | true |
AlgebraicGeometry.Scheme.irreducibleComponentOpen._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.IrreducibleComponent | ∀ (X : AlgebraicGeometry.Scheme) (Z : Set ↥X) [AlgebraicGeometry.IsNoetherian X],
IsOpen (⋃₀ (irreducibleComponents ↥X \ {Z}))ᶜ | false |
midpoint_eq_midpoint_iff_vsub_eq_vsub | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x x' y y' : P}, midpoint R x y = midpoint R x' y' ↔ x -ᵥ x' = y' -ᵥ y | true |
CategoryTheory.Limits.MultispanShape.ctorIdx | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | CategoryTheory.Limits.MultispanShape → ℕ | false |
_private.Mathlib.Data.Int.CardIntervalMod.0.Nat.Ico_filter_modEq_cast._simp_1_4 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
IsLowerSet.vadd | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α] {s : Set α} {a : α},
IsLowerSet s → IsLowerSet (a +ᵥ s) | true |
PrimeSpectrum.noConfusion | Mathlib.RingTheory.Spectrum.Prime.Defs | {P : Sort u} →
{R : Type u_1} →
{inst : CommSemiring R} →
{t : PrimeSpectrum R} →
{R' : Type u_1} →
{inst' : CommSemiring R'} →
{t' : PrimeSpectrum R'} → R = R' → inst ≍ inst' → t ≍ t' → PrimeSpectrum.noConfusionType P t t' | false |
CategoryTheory.ObjectProperty.shiftClosure_le_iff | Mathlib.CategoryTheory.ObjectProperty.Shift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P Q : CategoryTheory.ObjectProperty C) {A : Type u_2}
[inst_1 : AddMonoid A] [inst_2 : CategoryTheory.HasShift C A] [Q.IsClosedUnderIsomorphisms] [Q.IsStableUnderShift A],
P.shiftClosure A ≤ Q ↔ P ≤ Q | true |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.ContinuousLinearMap.isPositive_iff_eq_sum_rankOne._simp_1_4 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {K : Type u_1} [inst : RCLike K] (r s : ℝ), ↑r * ↑s = ↑(r * s) | false |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.rpcRequest.elim | Lean.Server.ProtocolOverview | {motive : Lean.Server.Overview.MessageOverview✝ → Sort u} →
(t : Lean.Server.Overview.MessageOverview✝¹) →
Lean.Server.Overview.MessageOverview.ctorIdx✝ t = 1 →
((o : Lean.Server.Overview.RpcRequestOverview✝) → motive (Lean.Server.Overview.MessageOverview.rpcRequest✝ o)) →
motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.