name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
DirectedSystem.rTensor | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ (R : Type u) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N] {ι : Type u_3}
[inst_3 : Preorder ι] {F : ι → Type u_4} [inst_4 : (i : ι) → AddCommMonoid (F i)] [inst_5 : (i : ι) → Module R (F i)]
{f : ⦃i j : ι⦄ → i ≤ j → F i →ₗ[R] F j},
(DirectedSystem F fun x x_1 h => ⇑(f ... | Given a directed system of `R`-modules, tensoring it on the right gives a directed system | true |
_private.Mathlib.LinearAlgebra.Matrix.ConjTranspose.0.Matrix.map_star_eq_zero._simp_1_1 | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M N : Matrix m n α}, (M = N) = ∀ (i : m) (j : n), M i j = N i j | null | false |
Nat.zeckendorf.eq_def | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (x : ℕ),
x.zeckendorf =
match x with
| 0 => []
| m@h:n.succ => m.greatestFib :: (m - Nat.fib m.greatestFib).zeckendorf | null | true |
_private.Mathlib.Analysis.Analytic.Order.0.analyticOrderAt_deriv_ge_iff._proof_1_3 | Mathlib.Analysis.Analytic.Order | ∀ {n : ℕ} (k : ℕ), k + 1 < n + 1 → k < n | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.weakRankFunction._proof_16 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} (k : Fin (m + 1)) (n d : ℕ) (it : Fin (d + 1))
(t :
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj { len := m + 1 })
(SSet.stdSimplex.obj { len := n })).obj
(Opposite.op { len := d + 1 }))
(ht₁ :
t ∈
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSe... | null | false |
AddSubgroup.index_map_of_injective | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} {G' : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup G'] (H : AddSubgroup G) {f : G →+ G'},
Function.Injective ⇑f → (AddSubgroup.map f H).index = H.index * f.range.index | null | true |
Std.Http.Method.uncheckout.elim | Std.Http.Data.Method | {motive : Std.Http.Method → Sort u} →
(t : Std.Http.Method) → t.ctorIdx = 34 → motive Std.Http.Method.uncheckout → motive t | null | false |
Action.instLinear._proof_4 | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] {G : Type u_3} [inst_1 : Monoid G]
[inst_2 : CategoryTheory.Preadditive V] {R : Type u_4} [inst_3 : Semiring R] [inst_4 : CategoryTheory.Linear R V]
(X Y : Action V G) (a : R), a • 0 = 0 | null | false |
FiberBundleCore.Fiber | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_1} →
{B : Type u_2} →
{F : Type u_3} → [inst : TopologicalSpace B] → [inst_1 : TopologicalSpace F] → FiberBundleCore ι B F → B → Type u_3 | The fiber of a fiber bundle core, as a convenience function for dot notation and
typeclass inference | true |
CategoryTheory.Limits.widePullbackShapeUnopOp._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type u_1) {X Y : CategoryTheory.Limits.WidePullbackShape J} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
(((CategoryTheory.Limits.widePullbackShapeOp J).comp (CategoryTheory.Limits.widePushoutShapeUnop J)).obj
Y)).inv
(((CategoryTheory.Limits.widePu... | null | false |
DirectSum.coeAddMonoidHom_of | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type v} {M : Type u_1} {S : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : SetLike S M]
[inst_3 : AddSubmonoidClass S M] (A : ι → S) (i : ι) (x : ↥(A i)),
(DirectSum.coeAddMonoidHom A) ((DirectSum.of (fun i => ↥(A i)) i) x) = ↑x | null | true |
_private.Mathlib.FieldTheory.PurelyInseparable.Exponent.0.IsPurelyInseparable.iterateFrobeniusAux | Mathlib.FieldTheory.PurelyInseparable.Exponent | (K : Type u_2) →
(L : Type u_3) →
[inst : Field K] →
[inst_1 : Field L] → [inst_2 : Algebra K L] → [IsPurelyInseparable.HasExponent K L] → ℕ → ℕ → L → K | null | true |
Lean.CasesAltInfo.default.sizeOf_spec | Lean.Meta.CasesInfo | ∀ (numHyps : ℕ), sizeOf (Lean.CasesAltInfo.default numHyps) = 1 + sizeOf numHyps | null | true |
_private.Lean.Meta.Closure.0.Lean.Meta.Closure.TopoSort.mk | Lean.Meta.Closure | Lean.FVarIdHashSet → Lean.FVarIdHashSet → Array Lean.LocalDecl → Array Lean.Expr → Lean.Meta.Closure.TopoSort✝ | null | true |
CategoryTheory.Sheaf.H.longSequenceHom._proof_10 | Mathlib.CategoryTheory.Sites.SheafCohomology.ExactSequences | 5 < 5 + 1 | null | false |
List.getElem_length_sub_one_eq_getLast._proof_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α}, l.length - 1 < l.length → l ≠ [] | null | false |
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 = ι | null | true |
FirstOrder.Language.presburger.natCast_zero | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | ∀ {α : Type u_1}, ↑0 = 0 | null | true |
Equiv.commRing._proof_4 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CommRing β] (x y : α),
e (e.symm (e.toFun x * e.toFun y)) = e.toFun x * e.toFun y | null | false |
AddSubgroup.prod.eq_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] (H : AddSubgroup G) (K : AddSubgroup N),
H.prod K = { toAddSubmonoid := H.prod K.toAddSubmonoid, neg_mem' := ⋯ } | null | true |
IsDiscreteValuationRing.quotient | Mathlib.RingTheory.DiscreteValuationRing.Basic | {R : Type u_2} → [CommRing R] → R → R → R | A noncomputable quotient to define the Euclidean domain structure. The GCD algorithm only takes
two steps to terminate. Given `GCD(x,y)`, if `x ∣ y` then `y%x = 0` so we're done in one step;
otherwise `y%x = y` and then `GCD(x,y) = GCD(y,x)` which brings us back to the first case. | true |
AbsoluteValue.not_isNontrivial_apply | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_4} [inst : Semiring R] {S : Type u_5} [inst_1 : Semiring S] [inst_2 : PartialOrder S]
{v : AbsoluteValue R S}, ¬v.IsNontrivial → ∀ {x : R}, x ≠ 0 → v x = 1 | null | 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) ... | null | false |
OneHom | Mathlib.Algebra.Group.Hom.Defs | (M : Type u_10) → (N : Type u_11) → [One M] → [One N] → Type (max u_10 u_11) | `OneHom M N` is the type of functions `M → N` that preserve one.
When possible, instead of parametrizing results over `(f : OneHom M N)`,
you should parametrize over `(F : Type*) [OneHomClass F M N] (f : F)`.
When you extend this structure, make sure to also extend `OneHomClass`.
| 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 →
... | null | 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) α | null | true |
MeasureTheory.mem_map_restrict_ae_iff | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_6} {s : Set α} {t : Set β}
{f : α → β}, MeasurableSet s → (t ∈ Filter.map f (MeasureTheory.ae (μ.restrict s)) ↔ μ ((f ⁻¹' t)ᶜ ∩ s) = 0) | null | 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 α | null | true |
UniformConvergenceCLM.uniformity_toTopologicalSpace_eq | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : 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 : IsUniformAddGr... | null | true |
SimpleGraph.Walk.getVert_mem_support._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (i : ℕ), (p.getVert i ∈ p.support) = True | null | false |
Submodule.Quotient.seminormedAddCommGroup._proof_14 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] {R : Type u_2} [inst_1 : Ring R] [inst_2 : Module R M]
(S : Submodule R M),
((Submodule.Quotient.seminormedAddCommGroup._aux_11 S).lift' fun s => SetRel.comp s s) ≤
Submodule.Quotient.seminormedAddCommGroup._aux_11 S | null | false |
Pi.semiring._proof_3 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → Semiring (f i)] (a : (i : I) → f i), a * 1 = a | null | false |
MonadExcept.orElse | Init.Prelude | {ε : Type u} → {m : Type v → Type w} → [MonadExcept ε m] → {α : Type v} → m α → (Unit → m α) → m α | Unconditional error recovery that ignores which exception was thrown. Usually used via the `<|>`
operator.
If both computations throw exceptions, then the result is the second exception.
| 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.Pr... | null | 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₂ | null | 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) | null | true |
AnalyticOnNhd.sum_divisor_le | Mathlib.Analysis.Complex.JensenFormula | ∀ {c : ℂ} {r R M : ℝ} {f : ℂ → ℂ},
0 < |r| →
|r| < |R| →
1 ≤ M →
AnalyticOnNhd ℂ f (Metric.closedBall c |R|) →
f c ≠ 0 →
(∀ z ∈ Metric.sphere c |R|, ‖f z‖ ≤ M) →
↑(∑ᶠ (u : ℂ), (MeromorphicOn.divisor f (Metric.closedBall c |r|)) u) ≤
Real.log (M / ‖... | **Jensen's Inequality**: Estimates the number of zeros of `f` in a ball of radius `r`
given that `f` is analytic and bounded by `M` on a larger ball of radius `R`.
| true |
alexDiscEquivPreord_functor | Mathlib.Topology.Order.Category.AlexDisc | alexDiscEquivPreord.functor = (CategoryTheory.forget₂ AlexDisc TopCat).comp topToPreord | null | true |
_private.Mathlib.Algebra.Order.Archimedean.Defs.0.exists_int_le.match_1_1 | Mathlib.Algebra.Order.Archimedean.Defs | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : PartialOrder R] (x : R) (motive : (∃ n, -x ≤ ↑n) → Prop)
(x_1 : ∃ n, -x ≤ ↑n), (∀ (n : ℤ) (h : -x ≤ ↑n), motive ⋯) → motive x_1 | null | false |
Lean.Meta.Config.zetaUnused | Lean.Meta.Basic | Lean.Meta.Config → Bool | Zeta reduction for unused let-declarations: `let x := v; e` reduces to `e` when `x` does not occur
in `e`.
This option takes precedence over `zeta` and `zetaHave`.
| true |
Set.fintypeUnion | Mathlib.Data.Set.Finite.Basic | {α : Type u} → [DecidableEq α] → (s t : Set α) → [Fintype ↑s] → [Fintype ↑t] → Fintype ↑(s ∪ t) | null | true |
Multiset.lt_singleton | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α} {a : α}, s < {a} ↔ s = 0 | null | 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 : β → Boo... | null | 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 ... | null | true |
_private.Mathlib.LinearAlgebra.TensorProduct.Decomposition.0.DirectSum.tensorDecomposition._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Decomposition | ∀ {ι : Type u_3} {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(ℳ : ι → Submodule R M) (i : ι), SMulCommClass R R ↥(ℳ i) | null | false |
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 | null | false |
Int32.ofIntLE_int16ToInt._proof_2 | Init.Data.SInt.Lemmas | Int16.maxValue.toInt ≤ Int32.maxValue.toInt | null | false |
isLowerSet_compl._simp_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet sᶜ = IsUpperSet s | null | 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'}
(... | null | 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 | The left homology of a short complex, given by the `H` field of a chosen left homology data. | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doTry._regBuiltin.Lean.Parser.Term.doCatch.parenthesizer_23 | Lean.Parser.Do | IO Unit | null | 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.coeff a = 0 | **Alias** of `AddMonoidAlgebra.coeff_eq_zero_of_not_le_supDegree`. | true |
InitialSeg.«_aux_Mathlib_Order_InitialSeg___macroRules_InitialSeg_term_≼i__1» | Mathlib.Order.InitialSeg | Lean.Macro | null | 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) | null | true |
instRingFreeRing._proof_19 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1) (a : FreeRing α), a * 1 = a | null | 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 | null | false |
WithBot.WithTop.completeLattice | Mathlib.Order.ConditionallyCompleteLattice.Basic | {α : Type u_5} → [ConditionallyCompleteLattice α] → CompleteLattice (WithBot (WithTop α)) | null | 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 | null | false |
LaurentSeries.LaurentSeriesRingEquiv_def | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (f : PowerSeries K),
(LaurentSeries.LaurentSeriesRingEquiv K) ((HahnSeries.ofPowerSeries ℤ K) f) =
IsDedekindDomain.HeightOneSpectrum.adicCompletion.ofCompletion
((LaurentSeries.LaurentSeriesPkg K).compare LaurentSeries.ratfuncAdicComplPkg ((HahnSeries.ofPowerSeries ℤ K) f)... | null | true |
MeasurableSet.symmDiff | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {m : MeasurableSpace α} {s₁ s₂ : Set α},
MeasurableSet s₁ → MeasurableSet s₂ → MeasurableSet (symmDiff s₁ s₂) | null | true |
Submodule.prodEquiv._proof_2 | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_3} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_2}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (p : Submodule R M) (q : Submodule R M'),
Function.RightInverse (fun y => ⟨(↑y.1, ↑y.2), ⋯⟩) fun x => (⟨(↑x).1, ⋯⟩, ⟨(↑x).2, ⋯⟩) | null | 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 | null | 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)
((CategoryTheory.fullyFaith... | null | 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 ... | null | false |
Lean.Meta.Grind.ENode.proof?._default | Lean.Meta.Tactic.Grind.Types | Option Lean.Expr | null | false |
Lean.Compiler.LCNF.StructProjCases.remapFVar | Lean.Compiler.LCNF.StructProjCases | Lean.FVarId → Lean.Compiler.LCNF.StructProjCases.M Lean.FVarId | null | true |
Primcodable.ofDenumerable._proof_2 | Mathlib.Computability.Primrec.Basic | ∀ (α : Type u_1) [inst : Denumerable α], Nat.Primrec fun n => Encodable.encode (Encodable.decode n) | null | 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 () | null | true |
LE.le.not_ssuperset | Mathlib.Order.RelClasses | ∀ {α : Type u_1} [UsesSetNotationForOrder α] [inst : Preorder α] {a b : α}, a ⊆ b → ¬b ⊂ a | Set notation form of `LE.le.not_gt` | true |
CauchySeq.isBounded_range | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} [inst : PseudoMetricSpace α] {f : ℕ → α}, CauchySeq f → Bornology.IsBounded (Set.range f) | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.State | Std.Sat.AIG.CNF | Std.Sat.AIG ℕ → Type | The state to accumulate CNF clauses as we run our Tseitin transformation on the AIG.
| 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 | null | 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) | null | false |
CategoryTheory.ComposableArrows.sc'._proof_4 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ} (i j k : ℕ), j + 1 = k → k ≤ n → j ≤ n | null | false |
BitVec.intMin.eq_1 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ), BitVec.intMin w = BitVec.twoPow w (w - 1) | null | true |
Ordinal.log_zero_left | Mathlib.SetTheory.Ordinal.Exponential | ∀ (x : Ordinal.{u_1}), Ordinal.log 0 x = 0 | null | true |
WeierstrassCurve.Affine.CoordinateRing.basis._proof_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type u_1} [inst : CommRing R] (W' : WeierstrassCurve.Affine R), Nontrivial R → (AdjoinRoot.powerBasis' ⋯).dim = 2 | null | false |
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 | **Alias** of `MonotoneOn.countable_setOfPred_two_preimages`.
---
If a function is monotone on a set in a second countable topological space, then there
are only countably many points that have several preimages. | 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) | The characterization of weak convergence of probability measures by the condition that the
integrals of every continuous bounded nonnegative function are continuous. | 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.CategoryStr... | null | 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 | null | true |
SupBotHom.instInhabited.eq_1 | Mathlib.Order.Hom.BoundedLattice | ∀ (α : Type u_2) [inst : Max α] [inst_1 : Bot α], SupBotHom.instInhabited α = { default := SupBotHom.id α } | null | 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 | null | 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 | null | false |
Nat.smoothNumbers_zero | Mathlib.NumberTheory.SmoothNumbers | Nat.smoothNumbers 0 = {1} | null | 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... | null | 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‖ | Chord-length is always greater than a multiple of arc-length. | 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) | null | 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₂ | null | 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₂ | null | 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 | null | 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) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Ends.Properties.0.SimpleGraph.instIsEmptyElemForallObjOppositeFinsetComponentComplFunctorEndOfFinite._simp_1 | Mathlib.Combinatorics.SimpleGraph.Ends.Properties | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
«_aux_Mathlib_Topology_Algebra_InfiniteSum_Defs___macroRules_term∑'[_]_,__1» | Mathlib.Topology.Algebra.InfiniteSum.Defs | Lean.Macro | null | 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 | null | 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' | null | true |
MultilinearMap.instZero._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {M₂ : Type u_1} [inst : AddCommMonoid M₂], 0 = 0 + 0 | null | 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⟩) | null | 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 :... | null | 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) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.