name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Algebra.Presentation.differentialsRelations_G | Mathlib.Algebra.Module.Presentation.Differentials | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(pres : Algebra.Presentation R S ι σ), pres.differentialsRelations.G = ι | true |
FirstOrder.Language.presburger.natCast_zero | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | ∀ {α : Type u_1}, ↑0 = 0 | true |
Equiv.commRing._proof_4 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CommRing β] (x y : α), e (e.symm (e x * e y)) = e x * e y | false |
AddSubgroup.prod.eq_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (H : AddSubgroup G) (K : AddSubgroup N),
H.prod K = { toAddSubmonoid := H.prod K.toAddSubmonoid, neg_mem' := ⋯ } | true |
IsDiscreteValuationRing.quotient | Mathlib.RingTheory.DiscreteValuationRing.Basic | {R : Type u_2} → [CommRing R] → R → R → R | true |
AbsoluteValue.not_isNontrivial_apply | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_5} [inst : Semiring R] {S : Type u_6} [inst_1 : Semiring S] [inst_2 : PartialOrder S]
{v : AbsoluteValue R S}, ¬v.IsNontrivial → ∀ {x : R}, x ≠ 0 → v x = 1 | true |
Std.DTreeMap.Internal.Impl.balanceL.match_7 | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(l : Std.DTreeMap.Internal.Impl α β) →
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size r.size → Sort u_3) →
(r : Std.DTreeMap.Internal.Impl α β) →
(hrb : r.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size r.size) →
((hrb : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size Std.DTreeMap.Internal.Impl.leaf.size) →
motive Std.DTreeMap.Internal.Impl.leaf hrb hlr) →
((rs : ℕ) →
(k : α) →
(v : β k) →
(l_1 r : Std.DTreeMap.Internal.Impl α β) →
(hrb : (Std.DTreeMap.Internal.Impl.inner rs k v l_1 r).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size
(Std.DTreeMap.Internal.Impl.inner rs k v l_1 r).size) →
motive (Std.DTreeMap.Internal.Impl.inner rs k v l_1 r) hrb hlr) →
motive r hrb hlr | false |
instToJsonShowMessageParams | Lean.Data.Lsp.Window | Lean.ToJson ShowMessageParams | true |
OneHom | Mathlib.Algebra.Group.Hom.Defs | (M : Type u_10) → (N : Type u_11) → [One M] → [One N] → Type (max u_10 u_11) | true |
ApproximatesLinearOn.open_image | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
[CompleteSpace E] {s : Set E} {c : NNReal} {f' : E →L[𝕜] F},
ApproximatesLinearOn f f' s c →
∀ (f'symm : f'.NonlinearRightInverse), IsOpen s → Subsingleton F ∨ c < f'symm.nnnorm⁻¹ → IsOpen (f '' s) | true |
CategoryTheory.InducedCategory.hasCoeToSort | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} → (F : C → D) → {α : Sort u_1} → [CoeSort D α] → CoeSort (CategoryTheory.InducedCategory D F) α | true |
MeasureTheory.mem_map_restrict_ae_iff | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_7} {s : Set α} {t : Set β}
{f : α → β}, MeasurableSet s → (t ∈ Filter.map f (MeasureTheory.ae (μ.restrict s)) ↔ μ ((f ⁻¹' t)ᶜ ∩ s) = 0) | true |
Lean.Widget.withGoalCtx | Lean.Widget.InteractiveGoal | {n : Type → Type} →
[MonadControlT Lean.MetaM n] →
[Monad n] →
[Lean.MonadError n] →
[Lean.MonadOptions n] →
[Lean.MonadMCtx n] → {α : Type} → Lean.MVarId → (Lean.LocalContext → Lean.MetavarDecl → n α) → n α | true |
CategoryTheory.Sieve.overEquiv._proof_2 | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X : C} (Y : CategoryTheory.Over X)
(S : CategoryTheory.Sieve Y.left),
(fun S => CategoryTheory.Sieve.functorPushforward (CategoryTheory.Over.forget X) S)
((fun S' => CategoryTheory.Sieve.functorPullback (CategoryTheory.Over.forget X) S') S) =
S | false |
UniformConvergenceCLM.uniformity_toTopologicalSpace_eq | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : UniformSpace F] [inst_8 : IsUniformAddGroup F]
(𝔖 : Set (Set E)),
(UniformConvergenceCLM.instUniformSpace σ F 𝔖).toTopologicalSpace = UniformConvergenceCLM.instTopologicalSpace σ F 𝔖 | true |
SimpleGraph.Walk.getVert_mem_support._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (i : ℕ), (p.getVert i ∈ p.support) = True | false |
Pi.semiring._proof_3 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → Semiring (f i)], ↑0 = 0 | false |
MonadExcept.orElse | Init.Prelude | {ε : Type u} → {m : Type v → Type w} → [MonadExcept ε m] → {α : Type v} → m α → (Unit → m α) → m α | true |
CochainComplex.mapBifunctorShift₂Iso_hom_naturality₂_assoc | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Preadditive C₂]
[inst_5 : CategoryTheory.Preadditive D] (K₁ : CochainComplex C₁ ℤ) {K₂ L₂ : CochainComplex C₂ ℤ} (f₂ : K₂ ⟶ L₂)
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D)) [inst_6 : F.PreservesZeroMorphisms]
[inst_7 : ∀ (X₁ : C₁), (F.obj X₁).Additive] (y : ℤ) [inst_8 : K₁.HasMapBifunctor K₂ F]
[inst_9 : K₁.HasMapBifunctor L₂ F] {Z : HomologicalComplex D (ComplexShape.up ℤ)}
(h : (CategoryTheory.shiftFunctor (CochainComplex D ℤ) y).obj (K₁.mapBifunctor L₂ F) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(HomologicalComplex.mapBifunctorMap (CategoryTheory.CategoryStruct.id K₁)
((CategoryTheory.shiftFunctor (HomologicalComplex C₂ (ComplexShape.up ℤ)) y).map f₂) F (ComplexShape.up ℤ))
(CategoryTheory.CategoryStruct.comp (K₁.mapBifunctorShift₂Iso L₂ F y).hom h) =
CategoryTheory.CategoryStruct.comp (K₁.mapBifunctorShift₂Iso K₂ F y).hom
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor (CochainComplex D ℤ) y).map
(HomologicalComplex.mapBifunctorMap (CategoryTheory.CategoryStruct.id K₁) f₂ F (ComplexShape.up ℤ)))
h) | true |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.opcyclesToE_map._proof_12 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ (n₁ n₂ : ℤ), autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.opcyclesToE_map._auto_7 → n₁ + 1 = n₂ | false |
AddSubmonoid.closure_singleton_eq | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_2} [inst : AddMonoid A] (x : A), AddSubmonoid.closure {x} = AddMonoidHom.mrange ((multiplesHom A) x) | true |
alexDiscEquivPreord_functor | Mathlib.Topology.Order.Category.AlexDisc | alexDiscEquivPreord.functor = (CategoryTheory.forget₂ AlexDisc TopCat).comp topToPreord | true |
Lean.Meta.Config.zetaUnused | Lean.Meta.Basic | Lean.Meta.Config → Bool | true |
Set.fintypeUnion | Mathlib.Data.Set.Finite.Basic | {α : Type u} → [DecidableEq α] → (s t : Set α) → [Fintype ↑s] → [Fintype ↑t] → Fintype ↑(s ∪ t) | true |
Multiset.lt_singleton | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α} {a : α}, s < {a} ↔ s = 0 | true |
Std.Iter.any_filterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id]
[inst_2 : Std.IteratorLoop α Id m] [inst_3 : Monad m] [inst_4 : MonadAttach m] [LawfulMonad m]
[WeaklyLawfulMonadAttach m] [Std.LawfulIteratorLoop α Id m] {it : Std.Iter β} {f : β → m (ULift.{w, 0} Bool)}
{p : β → Bool},
Std.IterM.any p (Std.Iter.filterM f it) =
Std.IterM.anyM
(fun x => do
let __do_lift ← f x
if __do_lift.down = true then pure { down := p x } else pure { down := false })
(Std.Iter.mapM pure it) | true |
Rep.coinvariantsAdjunction_homEquiv_apply_hom | Mathlib.RepresentationTheory.Coinvariants | ∀ (k : Type u) (G : Type v) [inst : CommRing k] [inst_1 : Monoid G] {X : Rep.{w, u, v} k G} {Y : ModuleCat k}
(f : (Rep.coinvariantsFunctor k G).obj X ⟶ Y),
(Rep.Hom.hom (((Rep.coinvariantsAdjunction k G).homEquiv X Y) f)).toLinearMap =
ModuleCat.Hom.hom (CategoryTheory.CategoryStruct.comp ((Rep.coinvariantsMk k G).app X) f) | true |
instAddZeroClassTensorProduct._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (a : TensorProduct R M N), 0 + a = a | false |
Int32.ofIntLE_int16ToInt._proof_2 | Init.Data.SInt.Lemmas | Int16.maxValue.toInt ≤ Int32.maxValue.toInt | false |
isLowerSet_compl._simp_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet sᶜ = IsUpperSet s | false |
CategoryTheory.Join.mapIsoWhiskerLeft_inv_app | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {E' : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} E'] (H : CategoryTheory.Functor C E) {Fᵣ Gᵣ : CategoryTheory.Functor D E'}
(α : Fᵣ ≅ Gᵣ) (x : CategoryTheory.Join C D),
(CategoryTheory.Join.mapIsoWhiskerLeft H α).inv.app x =
match x with
| CategoryTheory.Join.left x => CategoryTheory.CategoryStruct.id (CategoryTheory.Join.left (H.obj x))
| CategoryTheory.Join.right x => (CategoryTheory.Join.inclRight E E').map (α.inv.app x) | true |
CategoryTheory.ShortComplex.leftHomology | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] → (S : CategoryTheory.ShortComplex C) → [S.HasLeftHomology] → C | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Internalize.0.Lean.Meta.Grind.Arith.CommRing.internalize.match_3 | Lean.Meta.Tactic.Grind.Arith.CommRing.Internalize | (motive : Option Lean.Meta.Grind.Arith.CommRing.SemiringExpr → Sort u_1) →
(__discr : Option Lean.Meta.Grind.Arith.CommRing.SemiringExpr) →
((re : Lean.Meta.Grind.Arith.CommRing.SemiringExpr) → motive (some re)) →
((x : Option Lean.Meta.Grind.Arith.CommRing.SemiringExpr) → motive x) → motive __discr | false |
AddMonoidAlgebra.apply_eq_zero_of_not_le_supDegree | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : Semiring R] [inst_1 : SemilatticeSup B] [inst_2 : OrderBot B]
{D : A → B} {p : AddMonoidAlgebra R A} {a : A}, ¬D a ≤ AddMonoidAlgebra.supDegree D p → p a = 0 | true |
InitialSeg.«_aux_Mathlib_Order_InitialSeg___macroRules_InitialSeg_term_≼i__1» | Mathlib.Order.InitialSeg | Lean.Macro | false |
Std.HashSet.Raw.insertMany_ind | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {ρ : Type v} [inst_2 : ForIn Id ρ α]
{motive : Std.HashSet.Raw α → Prop} (m : Std.HashSet.Raw α) (l : ρ),
motive m → (∀ (m : Std.HashSet.Raw α) (a : α), motive m → motive (m.insert a)) → motive (m.insertMany l) | true |
instRingFreeRing._proof_19 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1), autoParam (∀ (a : FreeRing α), SubNegMonoid.zsmul 0 a = 0) SubNegMonoid.zsmul_zero'._autoParam | false |
CategoryTheory.abelianOfEquivalence._proof_2 | Mathlib.CategoryTheory.Abelian.Transfer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (F : CategoryTheory.Functor C D) [inst_2 : F.IsEquivalence],
CategoryTheory.Limits.PreservesFiniteLimits F.inv | false |
WithBot.WithTop.completeLattice | Mathlib.Order.ConditionallyCompleteLattice.Basic | {α : Type u_5} → [ConditionallyCompleteLattice α] → CompleteLattice (WithBot (WithTop α)) | true |
finTwoEquiv._proof_3 | Mathlib.Logic.Equiv.Defs | ∀ (i : Fin 2), (fun b => bif b then 1 else 0) ((fun i => i == 1) i) = i | false |
LaurentSeries.LaurentSeriesRingEquiv_def | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (f : PowerSeries K),
(LaurentSeries.LaurentSeriesRingEquiv K) ((HahnSeries.ofPowerSeries ℤ K) f) =
(LaurentSeries.LaurentSeriesPkg K).compare LaurentSeries.ratfuncAdicComplPkg ((HahnSeries.ofPowerSeries ℤ K) f) | true |
MeasurableSet.symmDiff | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {m : MeasurableSpace α} {s₁ s₂ : Set α},
MeasurableSet s₁ → MeasurableSet s₂ → MeasurableSet (symmDiff s₁ s₂) | true |
_private.Mathlib.Data.Real.ConjExponents.0.NNReal.HolderConjugate.div_conj_eq_sub_one._simp_1_3 | Mathlib.Data.Real.ConjExponents | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
GrpCat.SurjectiveOfEpiAuxs.instSMulCarrierXWithInfinity._proof_3 | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B) (b : ↑B) (y : ↑(Set.range fun x => x • ↑(GrpCat.Hom.hom f).range)),
b • ↑y ∈ Set.range fun x => x • ↑(GrpCat.Hom.hom f).range | false |
IsDedekindDomain.FiniteAdeleRing.instDFunLikeHeightOneSpectrumAdicCompletion._proof_1 | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (_a _b : IsDedekindDomain.FiniteAdeleRing R K),
↑_a = ↑_b → _a = _b | false |
Lean.Parser.Attr.tactic_name._regBuiltin.Lean.Parser.Attr.tactic_name.parenthesizer_11 | Lean.Parser.Attr | IO Unit | false |
CategoryTheory.GrothendieckTopology.uliftYonedaIsoYoneda._proof_2 | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{max u_2 u_1, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical] {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.GrothendieckTopology.uliftYoneda.{u_2, max u_1 u_2, u_3} J).map f)
((fun x =>
(CategoryTheory.fullyFaithfulSheafToPresheaf J (Type (max u_1 u_2))).preimageIso
(CategoryTheory.NatIso.ofComponents (fun x_1 => Equiv.ulift.toIso) ⋯))
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun x =>
(CategoryTheory.fullyFaithfulSheafToPresheaf J (Type (max u_1 u_2))).preimageIso
(CategoryTheory.NatIso.ofComponents (fun x_1 => Equiv.ulift.toIso) ⋯))
X).hom
(J.yoneda.map f) | false |
ContinuousMap.toAEEqFunLinearMap._proof_3 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_2} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) [inst_1 : TopologicalSpace α]
[BorelSpace α] {𝕜 : Type u_3} [inst_3 : Semiring 𝕜] [inst_4 : TopologicalSpace γ]
[TopologicalSpace.PseudoMetrizableSpace γ] [inst_6 : AddCommGroup γ] [inst_7 : Module 𝕜 γ] [ContinuousConstSMul 𝕜 γ]
[SecondCountableTopologyEither α γ] (c : 𝕜) (f : C(α, γ)), MeasureTheory.AEStronglyMeasurable (c • ⇑f) μ | false |
Lean.Meta.Grind.ENode.proof?._default | Lean.Meta.Tactic.Grind.Types | Option Lean.Expr | false |
Lean.Compiler.LCNF.StructProjCases.remapFVar | Lean.Compiler.LCNF.StructProjCases | Lean.FVarId → Lean.Compiler.LCNF.StructProjCases.M Lean.FVarId | true |
Primcodable.ofDenumerable._proof_2 | Mathlib.Computability.Primrec.Basic | ∀ (α : Type u_1) [inst : Denumerable α], Nat.Primrec fun n => Encodable.encode (Encodable.decode n) | false |
_private.Lean.Meta.Tactic.Grind.Action.0.Lean.Meta.Grind.Action.loop.match_1.eq_1 | Lean.Meta.Tactic.Grind.Action | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | true |
CauchySeq.isBounded_range | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} [inst : PseudoMetricSpace α] {f : ℕ → α}, CauchySeq f → Bornology.IsBounded (Set.range f) | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.State | Std.Sat.AIG.CNF | Std.Sat.AIG ℕ → Type | true |
Std.HashMap.foldM_eq_foldlM_keys | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} {δ : Type w} {m' : Type w → Type w'}
[inst : Monad m'] [LawfulMonad m'] {f : δ → α → m' δ} {init : δ},
Std.HashMap.foldM (fun d a x => f d a) init m = List.foldlM f init m.keys | true |
_private.Init.Control.Lawful.Instances.0.StateT.seqLeft_eq._simp_1_1 | Init.Control.Lawful.Instances | ∀ {m : Type u → Type v} {inst : Monad m} [self : LawfulMonad m] {α β : Type u} (f : α → β) (x : m α),
f <$> x = do
let a ← x
pure (f a) | false |
CategoryTheory.ComposableArrows.sc'._proof_4 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ} (i j k : ℕ), j + 1 = k → k ≤ n → j ≤ n | false |
BitVec.intMin.eq_1 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ), BitVec.intMin w = BitVec.twoPow w (w - 1) | true |
Ordinal.log_zero_left | Mathlib.SetTheory.Ordinal.Exponential | ∀ (x : Ordinal.{u_1}), Ordinal.log 0 x = 0 | true |
MonotoneOn.countable_setOf_two_preimages | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : LinearOrder β] {s : Set α} {f : α → β} [SecondCountableTopology α],
MonotoneOn f s → {c | ∃ x y, x ∈ s ∧ y ∈ s ∧ x < y ∧ f x = c ∧ f y = c}.Countable | true |
MeasureTheory.ProbabilityMeasure.continuous_iff_forall_continuous_lintegral | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{X : Type u_2} [inst_3 : TopologicalSpace X] {μs : X → MeasureTheory.ProbabilityMeasure Ω},
Continuous μs ↔ ∀ (f : BoundedContinuousFunction Ω NNReal), Continuous fun x => ∫⁻ (ω : Ω), ↑(f ω) ∂↑(μs x) | true |
CategoryTheory.Bicategory.Prod.sectR._proof_2 | Mathlib.CategoryTheory.Bicategory.Product | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] (b : B) (C : Type u_2) [inst_1 : CategoryTheory.Bicategory C]
{a b_1 : C} (f : a ⟶ b_1),
CategoryTheory.Prod.mkHom (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id b))
(CategoryTheory.CategoryStruct.id f) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Prod.mkHom (CategoryTheory.CategoryStruct.id b) f) | false |
LinearMap.singularValues_antitone | Mathlib.Analysis.InnerProductSpace.SingularValues | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : InnerProductSpace 𝕜 F]
[inst_6 : FiniteDimensional 𝕜 F] (T : E →ₗ[𝕜] F), Antitone ⇑T.singularValues | true |
SupBotHom.instInhabited.eq_1 | Mathlib.Order.Hom.BoundedLattice | ∀ (α : Type u_2) [inst : Max α] [inst_1 : Bot α], SupBotHom.instInhabited α = { default := SupBotHom.id α } | true |
CategoryTheory.comp_toNatTrans | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ T₃ : CategoryTheory.Comonad C} (f : T₁ ⟶ T₂)
(g : T₂ ⟶ T₃),
(CategoryTheory.CategoryStruct.comp f g).toNatTrans = CategoryTheory.CategoryStruct.comp f.toNatTrans g.toNatTrans | true |
_private.Batteries.Data.List.Lemmas.0.List.idxOfNth_cons_succ._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {x : α} {n : ℕ} [inst : BEq α] {a : α},
List.idxOfNth x (a :: xs) (n + 1) =
if (a == x) = true then List.idxOfNth x xs n + 1 else List.idxOfNth x xs (n + 1) + 1 | false |
Nat.smoothNumbers_zero | Mathlib.NumberTheory.SmoothNumbers | Nat.smoothNumbers 0 = {1} | true |
FirstOrder.Ring.compatibleRingOfRing._proof_4 | Mathlib.ModelTheory.Algebra.Ring.Basic | ∀ (R : Type u_1) [inst : Add R] [inst_1 : Mul R] [inst_2 : Neg R] [inst_3 : One R] [inst_4 : Zero R] (x : Fin 2 → R),
(match (motive := (n : ℕ) → FirstOrder.Language.ring.Functions n → (Fin n → R) → R) 2, FirstOrder.Ring.mulFunc with
| .(2), FirstOrder.ringFunc.add => fun x => x 0 + x 1
| .(2), FirstOrder.ringFunc.mul => fun x => x 0 * x 1
| .(1), FirstOrder.ringFunc.neg => fun x => -x 0
| .(0), FirstOrder.ringFunc.zero => fun x => 0
| .(0), FirstOrder.ringFunc.one => fun x => 1)
x =
(match (motive := (n : ℕ) → FirstOrder.Language.ring.Functions n → (Fin n → R) → R) 2, FirstOrder.Ring.mulFunc with
| .(2), FirstOrder.ringFunc.add => fun x => x 0 + x 1
| .(2), FirstOrder.ringFunc.mul => fun x => x 0 * x 1
| .(1), FirstOrder.ringFunc.neg => fun x => -x 0
| .(0), FirstOrder.ringFunc.zero => fun x => 0
| .(0), FirstOrder.ringFunc.one => fun x => 1)
x | false |
Complex.mul_angle_le_norm_sub | Mathlib.Analysis.Complex.Angle | ∀ {x y : ℂ}, ‖x‖ = 1 → ‖y‖ = 1 → 2 / Real.pi * InnerProductGeometry.angle x y ≤ ‖x - y‖ | true |
iInf_iSup_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} {κ : ι → Sort w'} [inst : CompletelyDistribLattice α] {f : (a : ι) → κ a → α},
⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a) | true |
Commute.units_val_iff | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : Monoid M] {u₁ u₂ : Mˣ}, Commute ↑u₁ ↑u₂ ↔ Commute u₁ u₂ | true |
Set.add_subset_add_left | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Add α] {s t₁ t₂ : Set α}, t₁ ⊆ t₂ → s + t₁ ⊆ s + t₂ | true |
Std.DHashMap.Internal.Raw₀.size_eq_of_equiv | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α], (↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → (↑m₁).size = (↑m₂).size | true |
Equiv.Perm.prod_list_swap_mem_alternatingGroup_iff_even_length | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {l : List (Equiv.Perm α)},
(∀ g ∈ l, g.IsSwap) → (l.prod ∈ alternatingGroup α ↔ Even l.length) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Ends.Properties.0.SimpleGraph.instIsEmptyElemForallObjOppositeFinsetComponentComplFunctorEndOfFinite._simp_1 | Mathlib.Combinatorics.SimpleGraph.Ends.Properties | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
«_aux_Mathlib_Topology_Algebra_InfiniteSum_Defs___macroRules_term∑'[_]_,__1» | Mathlib.Topology.Algebra.InfiniteSum.Defs | Lean.Macro | false |
Lean.instFromJsonLeanOptionValue.match_1 | Lean.Util.LeanOptions | (motive : Lean.Json → Sort u_1) →
(x : Lean.Json) →
((s : String) → motive (Lean.Json.str s)) →
((b : Bool) → motive (Lean.Json.bool b)) →
((n : ℕ) → motive (Lean.Json.num { mantissa := Int.ofNat n, exponent := 0 })) →
((x : Lean.Json) → motive x) → motive x | false |
Std.ExtHashMap.getKey?_alter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k k' : α} {f : Option β → Option β},
(m.alter k f).getKey? k' = if (k == k') = true then if (f m[k]?).isSome = true then some k else none else m.getKey? k' | true |
MultilinearMap.instZero._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {ι : Type u_2} {M₁ : ι → Type u_3} {M₂ : Type u_1} [inst : (i : ι) → AddCommMonoid (M₁ i)] [inst_1 : AddCommMonoid M₂]
[inst_2 : DecidableEq ι] (x : (i : ι) → M₁ i) (x_1 : ι) (x_2 x_3 : M₁ x_1),
(fun x => 0) (Function.update x x_1 (x_2 + x_3)) =
(fun x => 0) (Function.update x x_1 x_2) + (fun x => 0) (Function.update x x_1 x_3) | false |
NNReal.tendsto_coe' | Mathlib.Topology.Instances.NNReal.Lemmas | ∀ {α : Type u_2} {f : Filter α} [f.NeBot] {m : α → NNReal} {x : ℝ},
Filter.Tendsto (fun a => ↑(m a)) f (nhds x) ↔ ∃ (hx : 0 ≤ x), Filter.Tendsto m f (nhds ⟨x, hx⟩) | true |
CategoryTheory.MorphismProperty.IsLocalAtSource.mk._flat_ctor | Mathlib.CategoryTheory.MorphismProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
{K : CategoryTheory.Precoverage C},
(∀ {X Y Z : C} (i : X ⟶ Y),
CategoryTheory.MorphismProperty.isomorphisms C i →
∀ (f : Y ⟶ Z), P f → P (CategoryTheory.CategoryStruct.comp i f)) →
(∀ {X Y Z : C} (i : Y ⟶ Z),
CategoryTheory.MorphismProperty.isomorphisms C i →
∀ (f : X ⟶ Y), P f → P (CategoryTheory.CategoryStruct.comp f i)) →
(∀ {X Y : C} {f : X ⟶ Y} (𝒰 : K.ZeroHypercover X) (i : 𝒰.I₀),
P f → P (CategoryTheory.CategoryStruct.comp (𝒰.f i) f)) →
(∀ {X Y : C} {f : X ⟶ Y} (𝒰 : K.ZeroHypercover X),
(∀ (i : 𝒰.I₀), P (CategoryTheory.CategoryStruct.comp (𝒰.f i) f)) → P f) →
P.IsLocalAtSource K | false |
Std.ExtTreeMap.instDecidableEqOfLawfulEqCmpOfTransCmpOfLawfulBEq | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.LawfulEqCmp cmp] → [Std.TransCmp cmp] → [inst : BEq β] → [LawfulBEq β] → DecidableEq (Std.ExtTreeMap α β cmp) | true |
Std.Do.PredTrans.instLE | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → LE (Std.Do.PredTrans ps α) | true |
MeasureTheory.SimpleFunc.ctorIdx | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u} → {inst : MeasurableSpace α} → {β : Type v} → MeasureTheory.SimpleFunc α β → ℕ | false |
LinearMap.mk₂' | Mathlib.LinearAlgebra.BilinearMap | (R : Type u_1) →
[inst : Semiring R] →
(S : Type u_2) →
[inst_1 : Semiring S] →
{M : Type u_5} →
{N : Type u_6} →
{Pₗ : Type u_11} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : AddCommMonoid Pₗ] →
[inst_5 : Module R M] →
[inst_6 : Module S N] →
[inst_7 : Module R Pₗ] →
[inst_8 : Module S Pₗ] →
[inst_9 : SMulCommClass S R Pₗ] →
(f : M → N → Pₗ) →
(∀ (m₁ m₂ : M) (n : N), f (m₁ + m₂) n = f m₁ n + f m₂ n) →
(∀ (c : R) (m : M) (n : N), f (c • m) n = c • f m n) →
(∀ (m : M) (n₁ n₂ : N), f m (n₁ + n₂) = f m n₁ + f m n₂) →
(∀ (c : S) (m : M) (n : N), f m (c • n) = c • f m n) → M →ₗ[R] N →ₗ[S] Pₗ | true |
WeierstrassCurve.Jacobian.Y_eq_of_Y_ne | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q → P 0 * Q 2 ^ 2 = Q 0 * P 2 ^ 2 → P 1 * Q 2 ^ 3 ≠ Q 1 * P 2 ^ 3 → P 1 * Q 2 ^ 3 = W'.negY Q * P 2 ^ 3 | true |
Bundle.Pretrivialization.domExtend._proof_5 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
{s : Set B} (e : Bundle.Pretrivialization F fun z => proj ↑z), e.target = e.baseSet ×ˢ Set.univ | false |
CategoryTheory.ObjectProperty.instIsClosedUnderSubobjectsInverseImageOfPreservesMonomorphisms | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(P : CategoryTheory.ObjectProperty C) [P.IsClosedUnderSubobjects] (F : CategoryTheory.Functor D C)
[F.PreservesMonomorphisms], (P.inverseImage F).IsClosedUnderSubobjects | true |
CategoryTheory.MorphismProperty.Q' | Mathlib.CategoryTheory.Localization.HasLocalization | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(W : CategoryTheory.MorphismProperty C) → [inst_1 : W.HasLocalization] → CategoryTheory.Functor C W.Localization' | true |
CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso_inv_comp_iCycles | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) [inst_2 : S.HasLeftHomology],
CategoryTheory.CategoryStruct.comp h.cyclesIso.inv S.iCycles = h.i | true |
Computation.get.congr_simp | Mathlib.Data.WSeq.Productive | ∀ {α : Type u} (s s_1 : Computation α) (e_s : s = s_1) [h : s.Terminates], s.get = s_1.get | true |
Real.tsum_eq_tsum_fourier_of_rpow_decay_of_summable | Mathlib.Analysis.Fourier.PoissonSummation | ∀ {f : ℝ → ℂ},
Continuous f →
∀ {b : ℝ},
1 < b →
(f =O[Filter.cocompact ℝ] fun x => |x| ^ (-b)) →
(Summable fun n => FourierTransform.fourier f ↑n) →
∀ (x : ℝ), ∑' (n : ℤ), f (x + ↑n) = ∑' (n : ℤ), FourierTransform.fourier f ↑n * (fourier n) ↑x | true |
Int8.toUInt8_neg | Init.Data.SInt.Lemmas | ∀ (a : Int8), (-a).toUInt8 = -a.toUInt8 | true |
CategoryTheory.Functor.initial_iff_comp_initial_full_faithful | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) [G.Initial] [G.Full] [G.Faithful], F.Initial ↔ (F.comp G).Initial | true |
Asymptotics.IsLittleO.eventually_mul_div_cancel | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {𝕜 : Type u_15} [inst : NormedDivisionRing 𝕜] {l : Filter α} {u v : α → 𝕜},
u =o[l] v → u / v * v =ᶠ[l] u | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.getForallBody._unsafe_rec | Lean.Elab.App | Bool → ℕ → List Lean.Elab.Term.NamedArg → Lean.Expr → Option Lean.Expr | false |
CategoryTheory.Limits.Trident.IsLimit.homIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) (Z : C)
(x : Z ⟶ t.pt), ↑(CategoryTheory.Limits.Trident.IsLimit.lift' ht ↑⟨CategoryTheory.CategoryStruct.comp x t.ι, ⋯⟩ ⋯) = x | false |
Nat.pow_lt_ascFactorial | Mathlib.Data.Nat.Factorial.Basic | ∀ (n : ℕ) {k : ℕ}, 2 ≤ k → (n + 1) ^ k < (n + 1).ascFactorial k | true |
WeierstrassCurve.Jacobian.isUnit_Y_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F},
W.Nonsingular P → P 2 = 0 → IsUnit (P 1) | true |
Mathlib.Tactic.Order.Graph.findSCCsImp | Mathlib.Tactic.Order.Graph.Tarjan | Mathlib.Tactic.Order.Graph → StateM Mathlib.Tactic.Order.Graph.TarjanState Unit | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.