name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
MonadSatisfying.instEStateM._proof_4 | Batteries.Classes.SatisfiesM | ∀ {ε σ α : Type u_1} {p : α → Prop} {x : EStateM ε σ α} (h : SatisfiesM p x),
(Subtype.val <$>
have h' := ⋯;
fun s =>
match w : x.run s with
| EStateM.Result.ok a s' => EStateM.Result.ok ⟨a, ⋯⟩ s'
| EStateM.Result.error e s' => EStateM.Result.error e s') =
x | false |
coverPreserving_opens_map | Mathlib.Topology.Sheaves.SheafCondition.Sites | ∀ {X Y : TopCat} (f : X ⟶ Y),
CategoryTheory.CoverPreserving (Opens.grothendieckTopology ↑Y) (Opens.grothendieckTopology ↑X)
(TopologicalSpace.Opens.map f) | true |
DiffeologicalSpace.CorePlotsOn.mk.sizeOf_spec | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} [inst : SizeOf X]
(isPlotOn : {n : ℕ} → {u : Set (EuclideanSpace ℝ (Fin n))} → IsOpen u → (EuclideanSpace ℝ (Fin n) → X) → Prop)
(isPlotOn_congr :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p q : EuclideanSpace ℝ (Fin n) → X},
Set.EqOn p q u → (isPlotOn hu p ↔ isPlotO... | true |
Lean.Meta.PProdN.reduceProjs | Lean.Meta.PProdN | Lean.Expr → Lean.MetaM Lean.Expr | true |
nsmul_iterate | Mathlib.Algebra.Group.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] (k n : ℕ), (fun x => k • x)^[n] = fun x => k ^ n • x | true |
CategoryTheory.EnrichedFunctor.hom_ext | Mathlib.CategoryTheory.Enriched.Basic | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₂} [inst_3 : CategoryTheory.EnrichedCategory V D]
{F G : CategoryTheory.EnrichedFunctor V C D} {α β : F ⟶ G}, (∀ (X : C), α.out.app X = β.out.... | true |
_private.Mathlib.NumberTheory.TsumDivisorsAntidiagonal.0.tsum_pow_div_one_sub_eq_tsum_sigma._simp_1_1 | Mathlib.NumberTheory.TsumDivisorsAntidiagonal | ∀ {ι : Type u_1} {α : Type u_3} {L : SummationFilter ι} [inst : DivisionSemiring α] [inst_1 : TopologicalSpace α]
[IsTopologicalSemiring α] {f : ι → α} {a : α} [T2Space α], a * ∑'[L] (x : ι), f x = ∑'[L] (x : ι), a * f x | false |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.Lean.Meta.Grind.AC.propagateEqs.match_3 | Lean.Meta.Tactic.Grind.AC.Eq | (motive : Unit × Bool × Lean.Meta.Grind.AC.PropagateEqMap → Sort u_1) →
(__discr : Unit × Bool × Lean.Meta.Grind.AC.PropagateEqMap) →
((fst : Unit) → (propagated : Bool) → (snd : Lean.Meta.Grind.AC.PropagateEqMap) → motive (fst, propagated, snd)) →
motive __discr | false |
UniformFun.ofFun_toFun | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} (f : UniformFun α β), UniformFun.ofFun (UniformFun.toFun f) = f | true |
UniformSpace.metricSpace | Mathlib.Topology.Metrizable.Uniformity | (X : Type u_2) → [inst : UniformSpace X] → [(uniformity X).IsCountablyGenerated] → [T0Space X] → MetricSpace X | true |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.State.mk.sizeOf_spec | Lean.Meta.Match.SimpH | ∀ (mvarId : Lean.MVarId) (xs eqs eqsNew : List Lean.FVarId),
sizeOf { mvarId := mvarId, xs := xs, eqs := eqs, eqsNew := eqsNew } =
1 + sizeOf mvarId + sizeOf xs + sizeOf eqs + sizeOf eqsNew | true |
AddEquiv.mulOp_symm_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_3} {β : Type u_4} [inst : Add α] [inst_1 : Add β] (f : αᵐᵒᵖ ≃+ βᵐᵒᵖ),
AddEquiv.mulOp.symm f = MulOpposite.opAddEquiv.trans (f.trans MulOpposite.opAddEquiv.symm) | true |
Lean.Data.AC.eval.eq_2 | Init.Data.AC | ∀ {α : Sort u_1} (β : Sort u) [inst : Lean.Data.AC.EvalInformation α β] (ctx : α) (l r : Lean.Data.AC.Expr),
Lean.Data.AC.eval β ctx (l.op r) =
Lean.Data.AC.EvalInformation.evalOp ctx (Lean.Data.AC.eval β ctx l) (Lean.Data.AC.eval β ctx r) | true |
_aux_Mathlib_Data_PFun___unexpand_PFun_1 | Mathlib.Data.PFun | Lean.PrettyPrinter.Unexpander | false |
FreeGroup.IsCyclicallyReduced.nil | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u}, FreeGroup.IsCyclicallyReduced [] | true |
CategoryTheory.Functor.homObjFunctor_map_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F G : CategoryTheory.Functor C D) {A A' : (CategoryTheory.Functor C (Type w))ᵒᵖ} (f : A ⟶ A')
(x : F.HomObj G (Opposite.unop A)) (X : C) (a : (Opposite.unop A').obj X),
((F.homObjFunctor G).map f ... | true |
AlgebraicGeometry.tilde.instModuleCarrierCarrierStalkAbPresheaf | Mathlib.AlgebraicGeometry.Modules.Tilde | {R : CommRingCat} →
(M : ModuleCat ↑R) →
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top ↑R)) → Module ↑R ↑((AlgebraicGeometry.tilde M).presheaf.stalk x) | true |
BitVec.instMod | Init.Data.BitVec.Basic | {n : ℕ} → Mod (BitVec n) | true |
Lean.Elab.Command.InductiveElabStep2.collectUsedFVars | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep2 → StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit | true |
Lean.Meta.Grind.Arith.Cutsat.isSupportedType | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | Lean.Expr → Lean.Meta.Grind.GoalM Bool | true |
UInt64.neg_one_shiftLeft_and_shiftLeft | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (-1) <<< b &&& a <<< b = a <<< b | true |
_private.Mathlib.CategoryTheory.Limits.Types.Pullbacks.0.CategoryTheory.Limits.Types.isPullback_iff._proof_1_4 | Mathlib.CategoryTheory.Limits.Types.Pullbacks | ∀ {X₁ X₂ X₃ X₄ : Type u_1} (t : X₁ ⟶ X₂) (r : X₂ ⟶ X₄) (l : X₁ ⟶ X₃) (b : X₃ ⟶ X₄)
(w : CategoryTheory.CategoryStruct.comp t r = CategoryTheory.CategoryStruct.comp l b),
(∀ (x₁ y₁ : X₁), t x₁ = t y₁ ∧ l x₁ = l y₁ → x₁ = y₁) →
(∀ (x₂ : X₂) (x₃ : X₃), r x₂ = b x₃ → ∃ x₁, t x₁ = x₂ ∧ l x₁ = x₃) → Function.Bijectiv... | false |
List.zipWithM.match_1.congr_eq_1 | Init.Data.List.Monadic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (motive : List α → List β → Array γ → Sort u_4) (x : List α)
(x_1 : List β) (x_2 : Array γ)
(h_1 : (a : α) → (as : List α) → (b : β) → (bs : List β) → (acc : Array γ) → motive (a :: as) (b :: bs) acc)
(h_2 : (x : List α) → (x_3 : List β) → (acc : Array γ) → motive x ... | true |
intervalIntegral.integral_hasStrictDerivAt_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
ContinuousAt f b → HasStrictDerivAt (fun u => ∫ (x : ℝ) in a..u, f x) (f b) b | true |
CategoryTheory.CreatesLimitsOfSize.CreatesLimitsOfShape._autoParam | Mathlib.CategoryTheory.Limits.Creates | Lean.Syntax | false |
LinearMap.instLieRingModule._proof_1 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u_4} {L : Type u_2} {M : Type u_3} {N : Type u_1} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] [inst_7 : LieRingModule L N] (x : L) (f : M →ₗ[R] N) (m n : M),
⁅x, f (m + n)⁆ - f ⁅x,... | false |
CategoryTheory.FreeMonoidalCategory.Hom.recOn | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : (a a_1 : CategoryTheory.FreeMonoidalCategory C) → a.Hom a_1 → Sort u_1} →
{a a_1 : CategoryTheory.FreeMonoidalCategory C} →
(t : a.Hom a_1) →
((X : CategoryTheory.FreeMonoidalCategory C) → motive X X (CategoryTheory.FreeMonoidalCategory.Hom.id X)) →
((X Y Z : Categ... | false |
_private.Init.Data.List.Impl.0.List.eraseIdxTR.go | Init.Data.List.Impl | {α : Type u_1} → List α → List α → ℕ → Array α → List α | true |
CategoryTheory.Cat.Hom.instCategory._proof_1 | Mathlib.CategoryTheory.Category.Cat | ∀ {X Y : CategoryTheory.Cat} {X_1 Y_1 : X ⟶ Y} (η : X_1 ⟶ Y_1),
CategoryTheory.NatTrans.toCatHom₂
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.NatTrans.toCatHom₂ (CategoryTheory.CategoryStruct.id X_1.toFunctor)).toNatTrans η.toNatTrans) =
CategoryTheory.NatTrans.toCatHom₂ η.toNatTrans | false |
BitVec.getElem_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {n start len : ℕ} {x : BitVec n} {i : ℕ} (h : i < len), (BitVec.extractLsb' start len x)[i] = x.getLsbD (start + i) | true |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd'_hom_app_hom₃ | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (a b n : ℤ)
(h : a + b = n) (X : CategoryTheory.Pretriangulated.Triangle C),
((CategoryTheory.Pretriangulated.Tri... | true |
Lean.Meta.mkSimpAttr | Lean.Meta.Tactic.Simp.Attr | Lean.Name → String → Lean.Meta.SimpExtension → autoParam Lean.Name Lean.Meta.mkSimpAttr._auto_1 → IO Unit | true |
Polynomial.lifts_and_degree_eq_and_monic | Mathlib.Algebra.Polynomial.Lifts | ∀ {R : Type u} [inst : Semiring R] {S : Type v} [inst_1 : Semiring S] {f : R →+* S} [Nontrivial S] {p : Polynomial S},
p ∈ Polynomial.lifts f → p.Monic → ∃ q, Polynomial.map f q = p ∧ q.degree = p.degree ∧ q.Monic | true |
AddSubmonoid.map._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_3}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid M), ∃ a ∈ ↑S, f a = 0 | false |
_private.Init.Data.List.Find.0.List.finIdxOf?_eq_pmap_idxOf?._simp_1_5 | Init.Data.List.Find | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | false |
instCompactlyGeneratedSpaceSigma | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {ι : Type u} {X : ι → Type v} [inst : (i : ι) → TopologicalSpace (X i)] [∀ (i : ι), CompactlyGeneratedSpace (X i)],
CompactlyGeneratedSpace ((i : ι) × X i) | true |
Algebra.Etale.formallyEtale._autoParam | Mathlib.RingTheory.Etale.Basic | Lean.Syntax | false |
CategoryTheory.Over.iteratedSliceEquivOverMapIso._proof_6 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {X : T} {f g : CategoryTheory.Over X} (p : f ⟶ g)
{X_1 Y : CategoryTheory.Over f} (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp
((f.iteratedSliceForward.comp ((CategoryTheory.Over.map p.left).comp g.iteratedSliceBackward)).map f_1)
((f... | false |
ZFSet.Insert.match_3 | Mathlib.SetTheory.ZFC.Basic | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (motive : Option (PSet.mk α A).Type → Prop) (o : Option (PSet.mk α A).Type),
(∀ (a : (PSet.mk α A).Type), motive (some a)) → (∀ (a : Unit), motive none) → motive o | false |
pNilradical | Mathlib.FieldTheory.IsPerfectClosure | (R : Type u_1) → [inst : CommSemiring R] → ℕ → Ideal R | true |
Finset.monoid._proof_2 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Monoid α] (s t : Finset α), ↑(s * t) = ↑s * ↑t | false |
Group.ofLeftAxioms._proof_2 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Mul G] [inst_1 : One G] (assoc : ∀ (a b c : G), a * b * c = a * (b * c)) (x : G),
npowRecAuto 0 x = 1 | false |
_private.Mathlib.RingTheory.Spectrum.Maximal.Localization.0.MaximalSpectrum.toPiLocalization_not_surjective_of_infinite._simp_1_3 | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {ι : Type u_4} {R : ι → Type u_5} [inst : (i : ι) → CommSemiring (R i)] {i : ι} (I : Ideal (R i)) [inst_1 : I.IsPrime]
{r : (i : ι) → R i},
(algebraMap (R i) (Localization.AtPrime I)) (r i) =
(Localization.AtPrime.mapPiEvalRingHom I)
((algebraMap ((i : ι) → R i) (Localization.AtPrime (Ideal.comap (Pi.ev... | false |
Ordinal.cof_blsub_le_lift | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}), (o.blsub f).cof ≤ Cardinal.lift.{v, u} o.card | true |
BotHom.symm_dual_id | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} [inst : LE α] [inst_1 : OrderBot α], BotHom.dual.symm (TopHom.id αᵒᵈ) = BotHom.id α | true |
ComplexShape.not_rel_of_eq | Mathlib.Algebra.Homology.HasNoLoop | ∀ {ι : Type u_1} (c : ComplexShape ι) [c.HasNoLoop] {j j' : ι}, j = j' → ¬c.Rel j j' | true |
Ideal.Quotient.mkₐ_toRingHom | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_1) {A : Type u_3} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A] (I : Ideal A)
[inst_3 : I.IsTwoSided], (Ideal.Quotient.mkₐ R₁ I).toRingHom = Ideal.Quotient.mk I | true |
Algebra.adjoin.powerBasisAux._proof_4 | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {K : Type u_2} {S : Type u_1} [inst : Field K] [inst_1 : CommRing S] [inst_2 : Algebra K S],
SubmonoidClass (Subalgebra K S) S | false |
ContinuousLinearEquiv.toContinuousAffineEquiv._proof_1 | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_3} [inst : Ring k] {E : Type u_1} {F : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module k E]
[inst_3 : TopologicalSpace E] [inst_4 : AddCommGroup F] [inst_5 : Module k F] [inst_6 : TopologicalSpace F]
(L : E ≃L[k] F), Continuous (↑L.toLinearEquiv).toFun | false |
WithTop.untopD_le | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : PartialOrder α] {y : WithTop α} {a b : α}, y ≤ ↑b → WithTop.untopD a y ≤ b | true |
SkewMonoidAlgebra.liftNC_single | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {R : Type u_5} [inst_1 : NonUnitalNonAssocSemiring R]
(f : k →+ R) (g : G → R) (a : G) (b : k), (SkewMonoidAlgebra.liftNC f g) (SkewMonoidAlgebra.single a b) = f b * g a | true |
LinearMap.IsSymmetric.iSup_eigenspace_inf_eigenspace_of_commute | Mathlib.Analysis.InnerProductSpace.JointEigenspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{α : 𝕜} {A B : E →ₗ[𝕜] E} [FiniteDimensional 𝕜 E],
B.IsSymmetric → Commute A B → ⨆ γ, Module.End.eigenspace A α ⊓ Module.End.eigenspace B γ = Module.End.eigenspace A α | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_union_of_contains_eq_false_right._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
ContinuousMap.HomotopyWith.Simps.apply | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} → {P : C(X, Y) → Prop} → f₀.HomotopyWith f₁ P → ↑unitInterval × X → Y | true |
Std.ExtTreeMap.getKeyLE | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[inst : Std.TransCmp cmp] → (t : Std.ExtTreeMap α β cmp) → (k : α) → (∃ a ∈ t, (cmp a k).isLE = true) → α | true |
MeasureTheory.Measure.inv.instIsMulRightInvariant | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : DivisionMonoid G] [MeasurableMul G] [MeasurableInv G]
{μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant], μ.inv.IsMulRightInvariant | true |
Lean.Parser.Tactic.allGoals | Init.Tactics | Lean.ParserDescr | true |
Bundle.RiemannianMetric.casesOn | Mathlib.Topology.VectorBundle.Riemannian | {B : Type u_4} →
{E : B → Type u_6} →
[inst : (b : B) → TopologicalSpace (E b)] →
[inst_1 : (b : B) → AddCommGroup (E b)] →
[inst_2 : (b : B) → Module ℝ (E b)] →
{motive : Bundle.RiemannianMetric E → Sort u} →
(t : Bundle.RiemannianMetric E) →
((inner : (b : B) → ... | false |
isωSup_ωSup | Mathlib.Topology.OmegaCompletePartialOrder | ∀ {α : Type u_1} [inst : OmegaCompletePartialOrder α] (c : OmegaCompletePartialOrder.Chain α),
Scott.IsωSup c (OmegaCompletePartialOrder.ωSup c) | true |
AddCommGrpCat.ofHom | Mathlib.Algebra.Category.Grp.Basic | {X Y : Type u} →
[inst : AddCommGroup X] → [inst_1 : AddCommGroup Y] → (X →+ Y) → (AddCommGrpCat.of X ⟶ AddCommGrpCat.of Y) | true |
CategoryTheory.SingleObj.differenceFunctor_obj | Mathlib.CategoryTheory.SingleObj | ∀ {G : Type u} [inst : Group G] {C : Type v} [inst_1 : CategoryTheory.Category.{w, v} C] (f : C → G) (x : C),
(CategoryTheory.SingleObj.differenceFunctor f).obj x = () | true |
CategoryTheory.ComposableArrows.homMk₅._proof_6 | Mathlib.CategoryTheory.ComposableArrows.Basic | 5 < 5 + 1 | false |
String.Slice.Pos.lt_next_iff_le | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p q : s.Pos} {h : q ≠ s.endPos}, p < q.next h ↔ p ≤ q | true |
Lean.PrettyPrinter.Parenthesizer.Context.mk.inj | Lean.PrettyPrinter.Parenthesizer | ∀ {cat : Lean.Name} {forceParens : Bool} {cat_1 : Lean.Name} {forceParens_1 : Bool},
{ cat := cat, forceParens := forceParens } = { cat := cat_1, forceParens := forceParens_1 } →
cat = cat_1 ∧ forceParens = forceParens_1 | true |
CategoryTheory.CostructuredArrow.mkIdTerminal._proof_6 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {Y : C} {S : CategoryTheory.Functor C D} [inst_2 : S.Full]
[S.Faithful]
(s : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty (CategoryTheory.CostructuredArrow S (S.obj Y))))
(m ... | false |
Int.tmod_tmod_of_dvd | Init.Data.Int.DivMod.Lemmas | ∀ (n : ℤ) {m k : ℤ}, m ∣ k → (n.tmod k).tmod m = n.tmod m | true |
Fin.prod_univ_two' | Mathlib.Algebra.BigOperators.Fin | ∀ {ι : Type u_1} {M : Type u_2} [inst : CommMonoid M] (f : ι → M) (a b : ι), ∏ i, f (![a, b] i) = f a * f b | true |
Lean.IR.EmitLLVM.emitJp | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → Lean.IR.JoinPointId → Lean.IR.EmitLLVM.M llvmctx (LLVM.BasicBlock llvmctx) | true |
Lean.Meta.Grind.Arith.Cutsat.propagateDvd | Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr | Lean.Meta.Grind.Propagator | true |
ENNReal.tsum_eq_limsup_sum_nat | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {f : ℕ → ENNReal}, ∑' (i : ℕ), f i = Filter.limsup (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop | true |
NumberField.mixedEmbedding.fundamentalCone.expMap_smul | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (c : ℝ) (x : NumberField.mixedEmbedding.realSpace K),
↑NumberField.mixedEmbedding.fundamentalCone.expMap (c • x) = ↑NumberField.mixedEmbedding.fundamentalCone.expMap x ^ c | true |
LieRinehartAlgebra.instDerivation | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_1} {A₁ : Type u_2} [inst : CommRing R] [inst_1 : CommRing A₁] [inst_2 : Algebra R A₁],
LieRinehartAlgebra R A₁ (Derivation R A₁ A₁) | true |
Prod.instStarMul._proof_1 | Mathlib.Algebra.Star.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : Mul R] [inst_1 : Mul S] [inst_2 : StarMul R] [inst_3 : StarMul S]
(x x_1 : R × S), star (x * x_1) = star x_1 * star x | false |
instLawfulOrderLTInt64 | Init.Data.SInt.Lemmas | Std.LawfulOrderLT Int64 | true |
Lean.Meta.Occurrences.pos.injEq | Init.MetaTypes | ∀ (idxs idxs_1 : List ℕ), (Lean.Meta.Occurrences.pos idxs = Lean.Meta.Occurrences.pos idxs_1) = (idxs = idxs_1) | true |
IsMaxOn.bddAbove | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α}, IsMaxOn f s a → BddAbove (f '' s) | true |
CategoryTheory.biproduct_ι_comp_leftDistributor_hom_assoc | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] (X : C) (f : J → C) (j : J)
{Z :... | true |
MeasureTheory.exists_measure_symmDiff_lt_of_generateFrom_isSetSemiring | Mathlib.MeasureTheory.Measure.MeasuredSets | ∀ {α : Type u_1} [mα : MeasurableSpace α] {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ]
{C : Set (Set α)},
MeasureTheory.IsSetSemiring C →
(∃ D, D.Countable ∧ D ⊆ C ∧ μ (⋃₀ D)ᶜ = 0) →
mα = MeasurableSpace.generateFrom C →
∀ {s : Set α}, MeasurableSet s → ∀ {ε : ENNReal}, 0 < ε → ... | true |
NonemptyInterval.coe_top | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α], ↑⊤ = Set.univ | true |
eq_const_of_unique | Mathlib.Logic.Unique | ∀ {α : Sort u_1} {β : Sort u_2} [inst : Unique α] (f : α → β), f = Function.const α (f default) | true |
Affine.Simplex.exradius.congr_simp | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s s_1 : Affine.Simplex ℝ P n),
s = s_1 → ∀ (signs signs_1 : Finset (Fin (n + 1))), signs = signs_1 → s.exradius signs = s_1.exradius sig... | true |
Std.TreeSet.Equiv.atIdxD_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {i : ℕ} {fallback : α},
t₁.Equiv t₂ → t₁.atIdxD i fallback = t₂.atIdxD i fallback | true |
IsLocalization.algEquivOfAlgEquiv_eq_map | Mathlib.RingTheory.Localization.Basic | ∀ {A : Type u_4} [inst : CommSemiring A] {R : Type u_5} [inst_1 : CommSemiring R] [inst_2 : Algebra A R]
{M : Submonoid R} {S : Type u_6} [inst_3 : CommSemiring S] [inst_4 : Algebra A S] [inst_5 : Algebra R S]
[inst_6 : IsScalarTower A R S] [inst_7 : IsLocalization M S] {P : Type u_7} [inst_8 : CommSemiring P]
[i... | true |
Nat.Linear.monomialToExpr | Init.Data.Nat.Linear | ℕ → Nat.Linear.Var → Nat.Linear.Expr | true |
Lean.IRPhases.recOn | Lean.Environment | {motive : Lean.IRPhases → Sort u} →
(t : Lean.IRPhases) →
motive Lean.IRPhases.runtime → motive Lean.IRPhases.comptime → motive Lean.IRPhases.all → motive t | false |
Std.DHashMap.Internal.Raw₀.Const.get!_of_isEmpty | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited β],
(↑m).WF → ∀ {a : α}, (↑m).isEmpty = true → Std.DHashMap.Internal.Raw₀.Const.get! m a = default | true |
Lean.Elab.InlayHintInfo.textEdits | Lean.Elab.InfoTree.InlayHints | Lean.Elab.InlayHintInfo → Array Lean.Elab.InlayHintTextEdit | true |
Orientation.kahler_rightAngleRotation_right | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) (x y : E), (o.kahler x) (o.rightAngleRotation y) = Complex.I * (o.kahler x) y | true |
_private.Mathlib.AlgebraicGeometry.Scheme.0.AlgebraicGeometry.instIsIsoSchemeMapOfCommRingCat._proof_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ {R S : CommRingCat} (f : R ⟶ S) [CategoryTheory.IsIso f], CategoryTheory.IsIso (AlgebraicGeometry.Spec.map f) | false |
CategoryTheory.Square.noConfusionType | Mathlib.CategoryTheory.Square | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.Square C →
{C' : Type u} → [inst' : CategoryTheory.Category.{v, u} C'] → CategoryTheory.Square C' → Sort u_1 | false |
LinearMap.zero_apply | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ M₂]
{σ₁₂ : R₁ →+* R₂} (x : M), 0 x = 0 | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.keyAtIdx_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
IsUnit.mul_right_dvd._simp_1 | Mathlib.Algebra.Divisibility.Units | ∀ {α : Type u_1} [inst : Monoid α] {a b u : α}, IsUnit u → (a * u ∣ b) = (a ∣ b) | false |
instSliceableListSliceNat_5 | Init.Data.Slice.List.Basic | {α : Type u} → Std.Roi.Sliceable (ListSlice α) ℕ (ListSlice α) | true |
Batteries.ByteSubarray.mk.sizeOf_spec | Batteries.Data.ByteSlice | ∀ (array : ByteArray) (start stop : ℕ) (start_le_stop : start ≤ stop) (stop_le_array_size : stop ≤ array.size),
sizeOf
{ array := array, start := start, stop := stop, start_le_stop := start_le_stop,
stop_le_array_size := stop_le_array_size } =
1 + sizeOf array + sizeOf start + sizeOf stop + sizeOf s... | true |
HomotopicalAlgebra.FibrantObject.instIsFibrantObjι | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
[inst_2 : CategoryTheory.Limits.HasTerminal C] (X : HomotopicalAlgebra.FibrantObject C),
HomotopicalAlgebra.IsFibrant (HomotopicalAlgebra.FibrantObject.ι.obj X) | true |
USize.zero_shiftLeft | Init.Data.UInt.Bitwise | ∀ {a : USize}, 0 <<< a = 0 | true |
Equiv.Perm.instDecidableRelSameCycleInv | Mathlib.GroupTheory.Perm.Cycle.Basic | {α : Type u_2} → (f : Equiv.Perm α) → [DecidableRel f.SameCycle] → DecidableRel f⁻¹.SameCycle | true |
MonomialOrder.degree_prod_of_regular | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {ι : Type u_3} {P : ι → MvPolynomial σ R}
{s : Finset ι}, (∀ i ∈ s, IsRegular (m.leadingCoeff (P i))) → m.degree (∏ i ∈ s, P i) = ∑ i ∈ s, m.degree (P i) | true |
Lean.PersistentHashSet.recOn | Lean.Data.PersistentHashSet | {α : Type u} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Lean.PersistentHashSet α → Sort u_1} →
(t : Lean.PersistentHashSet α) → ((set : Lean.PersistentHashMap α Unit) → motive { set := set }) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.