name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Subarray.toArray_mkSlice_rci | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo : ℕ},
Std.Slice.toArray (Std.Rci.Sliceable.mkSlice xs (lo...*)) = (Std.Slice.toArray xs).extract lo | null | true |
ContextFreeRule | Mathlib.Computability.ContextFreeGrammar | Type u_1 → Type u_2 → Type (max u_1 u_2) | Rule that rewrites a single nonterminal to any string (a list of symbols). | true |
Finsupp.uniqueEquiv | Mathlib.Data.Finsupp.Single | {α : Type u_1} → {M : Type u_4} → [inst : Zero M] → α → [Subsingleton α] → (α →₀ M) ≃ M | If `α` has a unique term, then finitely supported functions `α →₀ M` are in bijection with `M`.
| true |
_private.Mathlib.Algebra.ContinuedFractions.Euler.0.GenContFract.convs_toEuler_of_forall_le.match_1_1 | Mathlib.Algebra.ContinuedFractions.Euler | ∀ {K : Type u_1} [inst : Field K] {n : ℕ} {g : GenContFract K}
(motive : (m : ℕ) → (∀ m_1 < m, m_1 ≤ n → g.toEuler.nums m_1 = g.convs m_1) → m ≤ n → Prop) (m : ℕ)
(ih : ∀ m_1 < m, m_1 ≤ n → g.toEuler.nums m_1 = g.convs m_1) (hm : m ≤ n),
(∀ (ih : ∀ m < 0, m ≤ n → g.toEuler.nums m = g.convs m) (hm : 0 ≤ n), motive... | null | false |
ArithmeticFunction.instAddGroup | Mathlib.NumberTheory.ArithmeticFunction.Defs | {R : Type u_1} → [inst : AddGroup R] → AddGroup (ArithmeticFunction R) | null | true |
String.Slice.RevPosIterator.ctorIdx | Init.Data.String.Iterate | {s : String.Slice} → s.RevPosIterator → ℕ | null | false |
Std.Sat.CNF.dimacs | Std.Sat.CNF.Dimacs | Std.Sat.CNF ℕ → String | This function turns `cnf` into a DIMACS `String`.
Note: This function will add `1` to all literal identifiers by default. This is because `0` is an
illegal identifier in the DIMACS format and we can avoid producing invalid DIMACS like this.
| true |
CategoryTheory.FreeMonoidalCategory.HomEquiv.below.α_hom_inv | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u}
{motive :
{X Y : CategoryTheory.FreeMonoidalCategory C} →
(a a_1 : X.Hom Y) → CategoryTheory.FreeMonoidalCategory.HomEquiv a a_1 → Prop}
{X Y Z : CategoryTheory.FreeMonoidalCategory C}, CategoryTheory.FreeMonoidalCategory.HomEquiv.below ⋯ | null | true |
CategoryTheory.Arrow.mapCechNerve._proof_3 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.Arrow C}
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
[inst_2 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback g.right (fun x => g.left) fun x => g.hom] (F : f ⟶ g)
⦃X Y :... | null | false |
groupCohomology.H1ofAutOnUnitsUnique | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | (K L : Type) →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] → [FiniteDimensional K L] → Unique ↑(groupCohomology.H1 (Rep.ofAlgebraAutOnUnits K L)) | Noether's generalization of Hilbert's Theorem 90: given a finite extension of fields `L/K`, the
first group cohomology `H¹(Aut_K(L), Lˣ)` is trivial. | true |
DFinsupp.mapRange_smul | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} [inst : Semiring R] {β₁ : ι → Type u_8} {β₂ : ι → Type u_9}
[inst_1 : (i : ι) → AddCommMonoid (β₁ i)] [inst_2 : (i : ι) → AddCommMonoid (β₂ i)]
[inst_3 : (i : ι) → Module R (β₁ i)] [inst_4 : (i : ι) → Module R (β₂ i)] (f : (i : ι) → β₁ i → β₂ i)
(hf : ∀ (i : ι), f i 0 = 0) (r : R),... | null | true |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pos.skipWhile.match_1.eq_2 | Init.Data.String.Lemmas.Pattern.Char | ∀ {s : String.Slice} (motive : Option s.Pos → Sort u_1) (h_1 : (nextCurr : s.Pos) → motive (some nextCurr))
(h_2 : Unit → motive none),
(match none with
| some nextCurr => h_1 nextCurr
| none => h_2 ()) =
h_2 () | null | true |
SimpleGraph.replaceVertex._proof_4 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u_1} (G : SimpleGraph V) (s t : V) [inst : DecidableEq V],
Std.Irrefl fun v w => if v = t then if w = t then False else G.Adj s w else if w = t then G.Adj v s else G.Adj v w | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isSome_minKey?_insert._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
IsTopologicalAddGroup.toContinuousNeg | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u} {inst : TopologicalSpace G} {inst_1 : AddGroup G} [self : IsTopologicalAddGroup G], ContinuousNeg G | null | true |
MeasureTheory.Measure.map_addHaar_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
r ≠ 0 → MeasureTheory.Measure.map (fun x => r • x) μ = ENNReal.ofReal |(r ^ Module.finrank ℝ E)⁻¹| • μ | null | true |
Polynomial.recOnHorner._unary._proof_19 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u_2} [inst : Semiring R] {M : Polynomial R → Sort u_1} (p : Polynomial R),
p.divX = 0 → M (p.divX * Polynomial.X) = M (0 * Polynomial.X) | null | false |
Filter.limsup_comp | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : ConditionallyCompleteLattice α] (u : β → α) (v : γ → β)
(f : Filter γ), Filter.limsup (u ∘ v) f = Filter.limsup u (Filter.map v f) | null | true |
StrongNormalizationMonoid.noConfusionType | Mathlib.Algebra.GCDMonoid.Basic | Sort u →
{α : Type u_2} →
[inst : CommMonoidWithZero α] →
StrongNormalizationMonoid α →
{α' : Type u_2} → [inst' : CommMonoidWithZero α'] → StrongNormalizationMonoid α' → Sort u | null | false |
Units.val_eq_one | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] {a : αˣ}, ↑a = 1 ↔ a = 1 | null | true |
PLift.seq_up | Mathlib.Control.ULift | ∀ {α : Sort u} {β : Sort v} (f : α → β) (x : α), ({ down := f }.seq fun x_1 => { down := x }) = { down := f x } | null | true |
AddChar.inv_apply_eq_conj | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {G : Type u_3} [Finite G] [inst_2 : AddLeftCancelMonoid G] (ψ : AddChar G K) (x : G),
(ψ x)⁻¹ = (starRingEnd K) (ψ x) | null | true |
_private.Init.Data.List.Nat.TakeDrop.0.List.extract_eq_drop_take'._simp_1_3 | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {xs : List α}, ([] = xs) = (xs = []) | null | false |
SSet.Subcomplex.ofSimplexProd_eq_range | Mathlib.AlgebraicTopology.SimplicialSet.FiniteProd | ∀ {X₁ X₂ : SSet} {p q : ℕ} (x₁ : X₁.obj (Opposite.op { len := p })) (x₂ : X₂.obj (Opposite.op { len := q })),
(SSet.Subcomplex.ofSimplex x₁).prod (SSet.Subcomplex.ofSimplex x₂) =
SSet.Subcomplex.range
(CategoryTheory.MonoidalCategoryStruct.tensorHom (SSet.yonedaEquiv.symm x₁) (SSet.yonedaEquiv.symm x₂)) | null | true |
Alignment.rec | Mathlib.Util.FormatTable | {motive : Alignment → Sort u} →
motive Alignment.left → motive Alignment.right → motive Alignment.center → (t : Alignment) → motive t | null | false |
Orientation.cos_oangle_eq_cos_angle | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V},
x ≠ 0 → y ≠ 0 → (o.oangle x y).cos = Real.cos (InnerProductGeometry.angle x y) | The cosine of the oriented angle between two nonzero vectors equals that of the unoriented
angle. | true |
Function.Surjective.of_comp_iff'._simp_1 | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β},
Function.Bijective f → ∀ (g : γ → α), Function.Surjective (f ∘ g) = Function.Surjective g | null | false |
Fin.lt_def | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b : Fin n}, a < b ↔ ↑a < ↑b | null | true |
CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.exists_nonempty_limit_obj_of_isColimit | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type v} [inst_1 : CategoryTheory.SmallCategory I]
(F : CategoryTheory.Functor I (CategoryTheory.Functor Cᵒᵖ (Type v))) {J : Type v}
[inst_2 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J]
(G :
CategoryTheory.Functor J (CategoryTheo... | null | true |
HomotopicalAlgebra.AttachCells.isPushout | Mathlib.AlgebraicTopology.RelativeCellComplex.AttachCells | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type t} {A B : α → C} {g : (a : α) → A a ⟶ B a}
{X₁ X₂ : C} {f : X₁ ⟶ X₂} (self : HomotopicalAlgebra.AttachCells g f),
CategoryTheory.IsPushout self.g₁ self.m f self.g₂ | null | true |
List.Sublist.drop._f | Init.Data.List.Sublist | ∀ {α : Type u_1} (x : ℕ)
(f :
Nat.below (motive := fun x => ∀ (x_1 x_2 : List α), x_1.Sublist x_2 → (List.drop x x_1).Sublist (List.drop x x_2))
x)
(x_1 x_2 : List α), x_1.Sublist x_2 → (List.drop x x_1).Sublist (List.drop x x_2) | null | false |
Int.le_of_mul_le_mul_right | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, b * a ≤ c * a → 0 < a → b ≤ c | null | true |
Std.ExtTreeMap.mem_of_mem_map | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{f : α → β → γ} {k : α}, k ∈ Std.ExtTreeMap.map f t → k ∈ t | null | true |
Fin.compare_eq_compare_val | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} (a b : Fin n), compare a b = compare ↑a ↑b | null | true |
Std.Iter.internalState | Init.Data.Iterators.Basic | {α β : Type w} → Std.Iter β → α | Internal implementation detail of the iterator. | true |
ContractingWith.aposteriori_dist_iterate_fixedPoint_le | Mathlib.Topology.MetricSpace.Contracting | ∀ {α : Type u_1} [inst : MetricSpace α] {K : NNReal} {f : α → α} (hf : ContractingWith K f) [inst_1 : Nonempty α]
[inst_2 : CompleteSpace α] (x : α) (n : ℕ),
dist (f^[n] x) (ContractingWith.fixedPoint f hf) ≤ dist (f^[n] x) (f^[n + 1] x) / (1 - ↑K) | A posteriori estimates on the convergence of iterates to the fixed point. | true |
RBTree.RBNode.fold._unsafe_rec | Batteries.Recycling.RBTree.Basic | {σ : Sort u_1} → {α : Type u_2} → σ → (σ → α → σ → σ) → RBTree.RBNode α → σ | null | false |
_private.Mathlib.Analysis.BoxIntegral.Partition.Split.0.BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany._simp_1_1 | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (insert a s ⊆ t) = (a ∈ t ∧ s ⊆ t) | null | false |
Perfection.lift_apply_apply_coe | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (R : Type u₁) [inst : CommSemiring R] [inst_1 : CharP R p]
[inst_2 : PerfectRing R p] (S : Type u₂) [inst_3 : CommSemiring S] [inst_4 : CharP S p] (f : R →+* S) (r : R) (n : ℕ),
↑(((Perfection.lift p R S) f) r) n = f ((⇑↑(frobeniusEquiv R p).symm)^[n] r) | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.toUInt64_le._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
HomotopicalAlgebra.Precylinder.inl_i | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P : HomotopicalAlgebra.Precylinder A)
[inst_1 : CategoryTheory.Limits.HasBinaryCoproduct A A],
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl P.i = P.i₀ | null | true |
FP.Float.instAdd | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → Add FP.Float | null | true |
rightLim_rightLim | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace α]
[OrderTopology α] [T3Space β] {f : α → β} {a : α},
Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds (Function.rightLim f a)) →
Function.rightLim (Function.rightLim f) a = Function.rightLim f a | null | true |
SetSemiring.imageHom_def | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} {β : Type u_2} [inst : MulOneClass α] [inst_1 : MulOneClass β] (f : α →* β) (s : SetSemiring α),
(SetSemiring.imageHom f) s = Set.up (⇑f '' SetSemiring.down s) | null | true |
Topology.IsConstructible.compl | Mathlib.Topology.Constructible | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X}, Topology.IsConstructible s → Topology.IsConstructible sᶜ | **Alias** of the reverse direction of `Topology.isConstructible_compl`. | true |
Padic.valuation._proof_2 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (f g : CauSeq ℚ (padicNorm p)), f ≈ g → PadicSeq.valuation f = PadicSeq.valuation g | null | false |
UInt16.not_ne_self | Init.Data.UInt.Bitwise | ∀ {a : UInt16}, ~~~a ≠ a | null | true |
Metric.unitSphere.instInv._proof_1 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NormedDivisionRing 𝕜] (x : ↑(Metric.sphere 0 1)), ‖(↑x)⁻¹‖ = 1 | null | false |
CategoryTheory.ShortComplex.SnakeInput.op._proof_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.Epi S.L₂.op.g | null | false |
Localization.instLinearOrderOfIsOrderedCancelMonoid._proof_3 | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedCancelMonoid α] {s : Submonoid α}
(a b : Localization s), compareOfLessAndEq a b = compareOfLessAndEq a b | null | false |
RKHS.Add'._aux_Mathlib_Analysis_InnerProductSpace_Reproducing_Operations___unexpand_RKHS_Add'_sumSpace_1 | Mathlib.Analysis.InnerProductSpace.Reproducing.Operations | Lean.PrettyPrinter.Unexpander | null | false |
Polynomial.Monic.degree_mul | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, q.Monic → (p * q).degree = p.degree + q.degree | null | true |
MeasureTheory.Measure.ae_integrable_of_integrable_comp | Mathlib.Probability.Kernel.Composition.IntegralCompProd | ∀ {α : Type u_5} {β : Type u_6} {E : Type u_7} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
[inst : NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} {μ : MeasureTheory.Measure α} {f : β → E},
MeasureTheory.Integrable f (μ.bind ⇑κ) → ∀ᵐ (x : α) ∂μ, MeasureTheory.Integrable f (κ x) | null | true |
OneHom.mulSingle_apply | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} [inst : DecidableEq I] [inst_1 : (i : I) → One (f i)] (i : I) (x : f i),
(OneHom.mulSingle f i) x = Pi.mulSingle i x | null | true |
_private.Mathlib.Probability.Martingale.BorelCantelli.0.MeasureTheory.Submartingale.exists_tendsto_of_abs_bddAbove_aux._simp_1_3 | Mathlib.Probability.Martingale.BorelCantelli | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | null | false |
IsBaseChange.rank_eq_of_le_nonZeroDivisors | Mathlib.LinearAlgebra.Dimension.Localization | ∀ {R : Type uR} (S : Type uS) {M : Type uM} {N : Type uN} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Algebra R S]
[inst_7 : Module S N] [IsScalarTower R S N] {p : Submonoid R} [IsLocalization p S] (f : M →ₗ[R] N... | null | true |
DoubleCentralizer.intCast_snd | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (n : ℤ), (↑n).toProd.2 = ↑n | null | true |
Lean.Grind.PowIdentity.mk | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.CommSemiring α] {p : outParam ℕ}, (∀ (x : α), x ^ p = x) → Lean.Grind.PowIdentity α p | null | true |
_private.Batteries.Data.List.Lemmas.0.List.IsChain.imp._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {S : α → α → Prop} (a : α), List.IsChain S [a] | null | false |
_private.Mathlib.Data.List.Pairwise.0.List.pairwise_iff_forall_infix._proof_1_59 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} (l' : List α),
1 < l'.length →
∀ (l₁ : List α),
l₁.length + (l₁.length + (l₁.length + (l₁.length + (l'.length - 1) - l₁.length) - l₁.length) - l₁.length) <
(l₁ ++ l').length | null | false |
CategoryTheory.PrelaxFunctor.map₂_hom_inv | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.PrelaxFunctor B C) {a b : B} {f g : a ⟶ b} (η : f ≅ g),
CategoryTheory.CategoryStruct.comp (F.map₂ η.hom) (F.map₂ η.inv) = CategoryTheory.CategoryStruct.id (F.map f) | null | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.runSimplexAlgorithm | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.SimplexAlgorithm | {matType : ℕ → ℕ → Type} →
[inst : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm matType] →
Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmM matType Unit | Runs the Simplex Algorithm inside the `SimplexAlgorithmM`. It always terminates, finding solution if
such exists.
| true |
Aesop.StatsExtensionEntry.position? | Aesop.Stats.Extension | Aesop.StatsExtensionEntry → Option Lean.Position | null | true |
MeasureTheory.AEStronglyMeasurable.const_vadd' | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} {𝕜 : Type u_5} [inst_1 : VAdd 𝕜 β] [ContinuousConstVAdd 𝕜 β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (c : 𝕜), MeasureTheory.AEStronglyMeasurable (fun i => c +ᵥ f i) μ | **Alias** of `MeasureTheory.AEStronglyMeasurable.fun_const_vadd`.
---
Eta-expanded form of `MeasureTheory.AEStronglyMeasurable.const_vadd` | true |
EquivLike.surjective_comp._simp_1 | Mathlib.Basic.FunLike.Equiv | ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [inst : EquivLike E α β] (e : E) (f : β → γ),
Function.Surjective (f ∘ ⇑e) = Function.Surjective f | null | false |
_private.Mathlib.FieldTheory.Finite.GaloisField.0.FiniteField.nonempty_algHom_iff_finrank_dvd.match_1_1 | Mathlib.FieldTheory.Finite.GaloisField | ∀ {F : Type u_3} {K : Type u_2} {L : Type u_1} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K]
[inst_3 : Field L] [inst_4 : Algebra F L] (motive : Nonempty (K →ₐ[F] L) → Prop) (x : Nonempty (K →ₐ[F] L)),
(∀ (f : K →ₐ[F] L), motive ⋯) → motive x | null | false |
LinearIsometryEquiv.casesOn | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
{σ₂₁ : R₂ →+* R} →
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] →
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] →
{E : Type u_9} →
{E₂ : Type u_10} →
... | null | false |
NonUnitalAlgHom.recOn | Mathlib.Algebra.Algebra.NonUnitalHom | {R : Type u} →
{S : Type u₁} →
[inst : Monoid R] →
[inst_1 : Monoid S] →
{φ : R →* S} →
{A : Type v} →
{B : Type w} →
[inst_2 : NonUnitalNonAssocSemiring A] →
[inst_3 : DistribMulAction R A] →
[inst_4 : NonUnitalNonAssocSemiring B... | null | false |
Specialization.toEquiv | Mathlib.Topology.Specialization | {α : Type u_1} → α ≃ Specialization α | `toEquiv` is the "identity" function to the `Specialization` of a type. | true |
CauSeq.const_mul | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x y : β),
CauSeq.const abv (x * y) = CauSeq.const abv x * CauSeq.const abv y | null | true |
CategoryTheory.Limits.Types.Pushout.Rel'.rec | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂}
{motive : (a a_1 : X₁ ⊕ X₂) → CategoryTheory.Limits.Types.Pushout.Rel' f g a a_1 → Prop},
(∀ (x : X₁ ⊕ X₂), motive x x ⋯) →
(∀ (x₀ y₀ : S) (h : (CategoryTheory.ConcreteCategory.hom g) x₀ = (CategoryTheory.ConcreteCategory.hom g) y₀),
motive (Sum.inl ((Categ... | null | false |
CategoryTheory.MonoOver.mk_obj | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X A : C} (f : A ⟶ X) [hf : CategoryTheory.Mono f],
(CategoryTheory.MonoOver.mk f).obj = CategoryTheory.Over.mk f | null | true |
Equiv.Perm.support_swap | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {x y : α}, x ≠ y → (Equiv.swap x y).support = {x, y} | null | true |
LinearMap.hasNoetherianRange_iff_quotient_ker | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_3} [inst : Ring K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] {f : V →ₗ[K] V₂}, f.HasNoetherianRange ↔ IsNoetherian K (V ⧸ f.ker) | null | true |
_private.Std.Sat.AIG.RefVecOperator.Zip.0.Std.Sat.AIG.RefVec.zip._proof_7 | Std.Sat.AIG.RefVecOperator.Zip | ∀ {len : ℕ}, ¬0 ≤ len → False | null | false |
_private.Mathlib.Algebra.Ring.Int.Defs.0.Int.cast_mul_eq_zsmul_cast._simp_1_1 | Mathlib.Algebra.Ring.Int.Defs | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
instGroupObjOppositeOpensCarrierOfPresheafSmoothSheaf._proof_10 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : Topo... | null | false |
List.sortedGT_nil | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α], [].SortedGT | null | true |
CategoryTheory.Sum.functorEquivFunctorCompSndIso | Mathlib.CategoryTheory.Sums.Products | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{A' : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] →
{B : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} B] →
(CategoryTheory.Sum.functorEquiv A A' B).functor.comp
(CategoryTheo... | Composing the forward direction of `functorEquiv` with the second projection is the same as
precomposition with `inr_ A A'`. | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraided_map_hom_hom_app | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.CommMon C} (f : X ⟶ Y)
(x : CategoryTheory.Discrete PUnit.{u + 1}),
((CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraided C)... | null | true |
Submodule.Quotient.distribSMul' | Mathlib.LinearAlgebra.Quotient.Defs | {R : Type u_1} →
{M : Type u_2} →
[inst : Ring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{S : Type u_3} →
[inst_3 : SMul S R] →
[inst_4 : DistribSMul S M] → [IsScalarTower S R M] → (P : Submodule R M) → DistribSMul S (M ⧸ P) | null | true |
RingCat.instCoeSortType | Mathlib.Algebra.Category.Ring.Basic | CoeSort RingCat (Type u) | null | true |
AffineMap.coe_comp | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} {V3 : Type u_6} {P3 : Type u_7}
[inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1]
[inst_4 : AddCommGroup V2] [inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2] [inst_7 : AddCommGroup V3]
[ins... | Composition of affine maps acts as applying the two functions. | true |
Set.mem_himp_iff | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α} {a : α}, a ∈ s ⇨ t ↔ a ∈ s → a ∈ t | null | true |
smoothSheafCommRing.ι_forgetStalk_inv | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : Topo... | null | true |
Lean.instHashableModuleIdx | Lean.Environment | Hashable Lean.ModuleIdx | null | true |
Shrink.instAddZeroClass._proof_1 | Mathlib.Algebra.Group.Shrink | ∀ {α : Type u_2} [inst : Small.{u_1, u_2} α] [inst_1 : AddZeroClass α] (a : Shrink.{u_1, u_2} α), 0 + a = a | null | false |
CategoryTheory.Oplax.StrongTrans.Hom.of.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} [inst_2 : SizeOf B] [inst_3 : SizeOf C]
(as : CategoryTheory.Oplax.StrongTrans.Modification η θ), sizeOf { as := as } = 1 + sizeOf as | null | true |
CategoryTheory.tensorClosed | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X Y : C} →
CategoryTheory.Closed X →
CategoryTheory.Closed Y → CategoryTheory.Closed (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | If `X` and `Y` are closed then `X ⊗ Y` is.
This isn't an instance because it's not usually how we want to construct internal homs,
we'll usually prove all objects are closed uniformly.
| true |
CategoryTheory.Bicategory.LeftLift.whiskering._proof_6 | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a} {x : B} (h : x ⟶ c)
{X Y Z : CategoryTheory.Bicategory.LeftLift f g} (f_1 : X ⟶ Y) (g_1 : Y ⟶ Z),
CategoryTheory.Bicategory.LeftLift.homMk
(CategoryTheory.Bicategory.whiskerLeft h
(CategoryTheory.StructuredArrow.... | null | false |
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] (k : α) (best : Option (α × β)) (size : ℕ) (k' : α) (v' : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go k best (Std.DTreeMap.Internal.Impl.inner size k' v' l r) =
match compare k k' with
| Ordering.gt => Std.DTr... | null | true |
MeasureTheory.SimpleFunc.extend_apply | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
(f₁ : MeasureTheory.SimpleFunc α γ) {g : α → β} (hg : MeasurableEmbedding g) (f₂ : MeasureTheory.SimpleFunc β γ)
(x : α), (f₁.extend g hg f₂) (g x) = f₁ x | null | true |
USize.and_self | Init.Data.UInt.Bitwise | ∀ {a : USize}, a &&& a = a | null | true |
Lean.Lsp.InlayHintTooltip.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintTooltip → Sort u} →
(t : Lean.Lsp.InlayHintTooltip) →
((text : String) → motive (Lean.Lsp.InlayHintTooltip.plaintext text)) →
((markup : Lean.Lsp.MarkupContent) → motive (Lean.Lsp.InlayHintTooltip.markdown markup)) → motive t | null | false |
Std.DTreeMap.Internal.Const.instSliceableImplRcoSlice | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
Std.Rco.Sliceable (Std.DTreeMap.Internal.Impl α fun x => β) α (Std.DTreeMap.Internal.Const.RcoSlice α β) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.strictMonoOn_artanh._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ x ∈ Set.Ioo (-1) 1, 0 < 1 + x | null | false |
DividedPowers.SubDPIdeal.instTop | Mathlib.RingTheory.DividedPowers.SubDPIdeal | {A : Type u_1} → [inst : CommSemiring A] → {I : Ideal A} → {hI : DividedPowers I} → Top hI.SubDPIdeal | `I` is a sub-dp-ideal of itself. | true |
BddOrd.Hom._mkInternal.sizeOf_spec | Mathlib.Order.Category.BddOrd | ∀ {X Y : BddOrd} (hom' : BoundedOrderHom ↑X.toPartOrd ↑Y.toPartOrd), sizeOf { hom' := hom' } = 1 + sizeOf hom' | null | false |
Std.DTreeMap.getKeyLT? | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → α → Option α | Tries to retrieve the largest key that is less than the given key,
returning `none` if no such key exists.
| true |
CategoryTheory.StructuredArrow.commaMapEquivalenceUnitIso | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{L : CategoryTheory.Functor C T} →
{R : CategoryTheory.Functor D T} →
... | The unit establishing the equivalence `StructuredArrow.commaMapEquivalence`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.