name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
vectorSpan_range_eq_span_range_vsub_left | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {ι : Type u_4} (p : ι → P) (i0 : ι),
vectorSpan k (Set.range p) = Submodule.span k (Set.range fun i => p i0 -ᵥ p i) | The `vectorSpan` of an indexed family is the span of the pairwise subtractions with a given
point on the left. | true |
MeasureTheory.lpNorm_sub_comm | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} [inst : NormedAddCommGroup E] (f g : α → E) (p : ENNReal)
(μ : MeasureTheory.Measure α), MeasureTheory.lpNorm (f - g) p μ = MeasureTheory.lpNorm (g - f) p μ | null | true |
Aesop.SimpResult.solved | Aesop.Search.Expansion.Simp | Lean.Meta.Simp.UsedSimps → Aesop.SimpResult | null | true |
_private.Mathlib.Computability.Ackermann.0.ack_three._proof_1_1 | Mathlib.Computability.Ackermann | 1 ≤ 2 | null | false |
AddSubgroup.instNontrivialSubtypeMemTop | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] [Nontrivial G], Nontrivial ↥⊤ | null | true |
Vector.push_mk._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} {size : xs.size = n} (x : α), (xs.push x).size = n + 1 | null | false |
StrictAntiOn.add_const | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f : β → α} {s : Set β}
[AddRightStrictMono α], StrictAntiOn f s → ∀ (c : α), StrictAntiOn (fun x => f x + c) s | null | true |
ULift.isAddRegular_up._simp_1 | Mathlib.Algebra.Regular.ULift | ∀ {R : Type v} [inst : Add R] {a : R}, IsAddRegular { down := a } = IsAddRegular a | null | false |
_private.Init.Data.String.Iterate.0.String.Slice.RevPosIterator.finitenessRelation._simp_2 | Init.Data.String.Iterate | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
lpInftySubalgebra | Mathlib.Analysis.Normed.Lp.lpSpace | (𝕜 : Type u_1) →
{I : Type u_5} →
(B : I → Type u_6) →
[inst : NormedField 𝕜] →
[inst_1 : (i : I) → NormedRing (B i)] →
[inst_2 : (i : I) → NormedAlgebra 𝕜 (B i)] → [∀ (i : I), NormOneClass (B i)] → Subalgebra 𝕜 (PreLp B) | The `𝕜`-subalgebra of elements of `∀ i : α, B i` whose `lp` norm is finite. This is `lp E ∞`,
with extra structure. | true |
AddSubgroup.isAddQuotientCoveringMap | Mathlib.Topology.Covering.Quotient | ∀ {G : Type u_4} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] (S : AddSubgroup G),
IsDiscrete ↑S → IsAddQuotientCoveringMap QuotientAddGroup.mk ↥S.op | null | true |
Std.ExtTreeSet.getLED | Std.Data.ExtTreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeSet α cmp → α → α → α | Tries to retrieve the largest element that is less than or equal to the
given element, returning `fallback` if no such element exists.
| true |
MeasureTheory.integrable_neg_iff | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β}, MeasureTheory.Integrable (-f) μ ↔ MeasureTheory.Integrable f μ | null | true |
AlgebraicGeometry.Scheme.height_of_isClosed | Mathlib.AlgebraicGeometry.Scheme | ∀ {X : AlgebraicGeometry.Scheme} {x : ↥X}, IsClosed {x} → Order.height x = 0 | null | true |
Std.DHashMap.Internal.Raw₀.forall_mem_keys_iff_forall_contains_getKey | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF → ∀ {p : α → Prop}, (∀ k ∈ (↑m).keys, p k) ↔ ∀ (k : α) (h : m.contains k = true), p (m.getKey k h) | null | true |
_private.Std.Http.Data.Headers.Name.0.Std.Http.Header.Name.transferEncoding._proof_1 | Std.Http.Data.Headers.Name | Std.Http.Header.IsValidHeaderName "transfer-encoding" | null | false |
Fin.Icc_sub_one_eq_Ico | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} {a b : Fin n}, 0 < b → Finset.Icc a (b - 1) = Finset.Ico a b | null | true |
MeasureTheory.measureReal_union_add_inter'._auto_3 | Mathlib.MeasureTheory.Measure.Real | Lean.Syntax | null | false |
ZFSet.mem_prod._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {x y z : ZFSet.{u}}, (z ∈ x.prod y) = ∃ a ∈ x, ∃ b ∈ y, z = a.pair b | null | false |
Decidable.peirce | Init.PropLemmas | ∀ (a b : Prop) [Decidable a], ((a → b) → a) → a | null | true |
OrderAddMonoidIso.toMultiplicativeLeft | Mathlib.Algebra.Order.Hom.TypeTags | {G : Type u_1} →
{H : Type u_2} →
[inst : AddCommMonoid G] →
[inst_1 : PartialOrder G] →
[inst_2 : CommMonoid H] → [inst_3 : PartialOrder H] → (G ≃+o Additive H) ≃ (Multiplicative G ≃*o H) | Reinterpret `G ≃+o Additive H` as `Multiplicative G ≃*o H`. | true |
Matrix.charmatrix.congr_simp | Mathlib.LinearAlgebra.Matrix.Charpoly.Basic | ∀ {R : Type u_1} [inst : CommRing R] {n : Type u_4} {inst_1 : DecidableEq n} [inst_2 : DecidableEq n]
[inst_3 : Fintype n] (M M_1 : Matrix n n R),
M = M_1 → ∀ (a a_1 : n), a = a_1 → ∀ (a_2 a_3 : n), a_2 = a_3 → M.charmatrix a a_2 = M_1.charmatrix a_1 a_3 | null | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizeImpl | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → ℕ → optParam (Option Lean.Expr) none → Lean.Meta.Grind.GoalM Unit | null | true |
Set.div_empty | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Div α] {s : Set α}, s / ∅ = ∅ | null | true |
Int.sub_max_sub_left | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), max (a - b) (a - c) = a - min b c | null | true |
RingHomInvPair.casesOn | Mathlib.Algebra.Ring.CompTypeclasses | {R₁ : Type u_1} →
{R₂ : Type u_2} →
[inst : Semiring R₁] →
[inst_1 : Semiring R₂] →
{σ : R₁ →+* R₂} →
{σ' : R₂ →+* R₁} →
{motive : RingHomInvPair σ σ' → Sort u} →
(t : RingHomInvPair σ σ') →
((comp_eq : σ'.comp σ = RingHom.id R₁) → (comp_eq₂ : σ.co... | null | false |
finsum_mem_image' | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] {f : α → M} {s : Set β} {g : β → α},
Set.InjOn g (s ∩ Function.support (f ∘ g)) → ∑ᶠ (i : α) (_ : i ∈ g '' s), f i = ∑ᶠ (j : β) (_ : j ∈ s), f (g j) | The sum of `f y` over `y ∈ g '' s` equals the sum of `f (g i)` over `s` provided that
`g` is injective on `s ∩ support (f ∘ g)`. | true |
ProbabilityTheory.meas_ge_le_evariance_div_sq | Mathlib.Probability.Moments.Variance | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ},
MeasureTheory.AEStronglyMeasurable X μ →
∀ {c : NNReal}, c ≠ 0 → μ {ω | ↑c ≤ |X ω - ∫ (x : Ω), X x ∂μ|} ≤ ProbabilityTheory.evariance X μ / ↑c ^ 2 | **Chebyshev's inequality** for `ℝ≥0∞`-valued variance. | true |
Std.DTreeMap.Internal.Impl.isEmpty_eq_isEmpty_erase_and_not_contains | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
(k : α),
t.isEmpty = ((Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.isEmpty && !Std.DTreeMap.Internal.Impl.contains k t) | null | true |
MeasureTheory.Measure.measurable_bind' | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {g : α → MeasureTheory.Measure β},
Measurable g → Measurable fun m => m.bind g | null | true |
ContMDiffVAdd | Mathlib.Geometry.Manifold.Algebra.SMul | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
ModelWithCorners 𝕜 E H →
{H' : Type u_4} →
... | Basic typeclass stating that the additive action of `G` on `M` is Cⁿ as a function `G × M → M`.
Unlike with `ContMDiffAdd` (the class stating that addition `G × G → G` within a single type `G` is
Cⁿ), we do not extend `IsManifold` because `ContMDiffVAdd` contains more
explicit arguments than `IsManifold` and so `ContMD... | true |
Polynomial.coeff_opRingEquiv | Mathlib.RingTheory.Polynomial.Opposites | ∀ {R : Type u_1} [inst : Semiring R] (p : (Polynomial R)ᵐᵒᵖ) (n : ℕ),
((Polynomial.opRingEquiv R) p).coeff n = MulOpposite.op ((MulOpposite.unop p).coeff n) | null | true |
IsLocalization.algebraLid | Mathlib.RingTheory.Localization.BaseChange | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
(A : Type u_2) →
[inst_1 : CommSemiring A] →
[inst_2 : Algebra R A] →
[IsLocalization S A] →
(B : Type u_5) →
[inst_4 : Semiring B] →
[inst_5 : Algebra R B] → [inst_6 ... | If `A` is a localization of `R`, tensoring an `A`-algebra with `A` over `R` does nothing. | true |
CategoryTheory.SimplicialObject.σ₀Iter_δ'._auto_3 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | Lean.Syntax | null | false |
_private.Mathlib.MeasureTheory.Integral.MeanInequalities.0.ENNReal.lintegral_mul_rpow_le_lintegral_rpow_mul_lintegral_rpow._simp_1_1 | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ (x : ENNReal) (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) | null | false |
CategoryTheory.Functor.IsHomLift.casesOn | Mathlib.CategoryTheory.FiberedCategory.HomLift | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₂} 𝒳] →
[inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮] →
{p : CategoryTheory.Functor 𝒳 𝒮} →
{motive : {R S : 𝒮} → {a b : 𝒳} → (x : R ⟶ S) → (x_1 : a ⟶ b) → p.IsHomLift x x_1 → Sort u} →
{R S : 𝒮} →
... | null | false |
BitVec.extractLsb'_toNat | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (s m : ℕ) (x : BitVec n), (BitVec.extractLsb' s m x).toNat = x.toNat >>> s % 2 ^ m | null | true |
ContinuousMultilinearMap.ofSubsingleton._proof_3 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ (R : Type u_4) {ι : Type u_3} (M₂ : Type u_1) (M₃ : Type u_2) [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] [inst_5 : TopologicalSpace M₂]
[inst_6 : TopologicalSpace M₃] (f : ContinuousMultilinearMap R (fun x => M₂) M₃), Continuous (⇑f ∘ ... | null | false |
_private.Mathlib.Algebra.CharZero.Defs.0.charZero_of_inj_zero._simp_1_1 | Mathlib.Algebra.CharZero.Defs | ∀ {G : Type u_1} [inst : Add G] [IsRightCancelAdd G] {a b c : G}, (b + a = c + a) = (b = c) | null | false |
OrderDual.instNonAssocSemiring._proof_4 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : NonAssocSemiring R],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
ContinuousAddEquiv.trans | Mathlib.Topology.Algebra.ContinuousMonoidHom | {M : Type u_1} →
{N : Type u_2} →
[inst : TopologicalSpace M] →
[inst_1 : TopologicalSpace N] →
[inst_2 : Add M] →
[inst_3 : Add N] →
{L : Type u_3} → [inst_4 : Add L] → [inst_5 : TopologicalSpace L] → M ≃ₜ+ N → N ≃ₜ+ L → M ≃ₜ+ L | The composition of two ContinuousAddEquiv. | true |
Option.not_lt_none._simp_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α] {a : Option α}, (a < none) = False | null | false |
Std.Time.Internal.Bounded.LE.ofFin | Std.Time.Internal.Bounded | {hi : ℕ} → Fin hi.succ → Std.Time.Internal.Bounded.LE 0 ↑hi | Convert a `Fin` to a `Bounded.LE`.
| true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_333 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
2 ≤ List.count w [a, g a, g (g a)] →
¬[g a, g (g a)].Nodup →
∀ (w_1 : α) (h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] 1] <
... | null | false |
GroupTopology.casesOn | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u} →
[inst : Group α] →
{motive : GroupTopology α → Sort u_1} →
(t : GroupTopology α) →
((toTopologicalSpace : TopologicalSpace α) →
(toIsTopologicalGroup : IsTopologicalGroup α) →
motive { toTopologicalSpace := toTopologicalSpace, toIsTopologicalGroup := toIsTopo... | null | false |
Finset.monotone_sym2 | Mathlib.Data.Finset.Sym | ∀ {α : Type u_1}, Monotone Finset.sym2 | null | true |
CategoryTheory.TwistShiftData._sizeOf_1 | Mathlib.CategoryTheory.Shift.Twist | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{A : Type w} →
{inst_1 : AddMonoid A} →
{inst_2 : CategoryTheory.HasShift C A} → [SizeOf C] → [SizeOf A] → CategoryTheory.TwistShiftData C A → ℕ | null | false |
Dynamics.mem_ball_dynEntourage_comp | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {X : Type u_1} (T : X → X) (n : ℕ) {U : SetRel X X} [U.IsSymm] (x y : X),
(UniformSpace.ball x (Dynamics.dynEntourage T U n) ∩ UniformSpace.ball y (Dynamics.dynEntourage T U n)).Nonempty →
x ∈ UniformSpace.ball y (Dynamics.dynEntourage T (U.comp U) n) | null | true |
Fin.add_def | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (a b : Fin n), a + b = ⟨(↑a + ↑b) % n, ⋯⟩ | null | true |
Finset.coe_sigma._simp_1 | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Finset ι) (t : (i : ι) → Finset (α i)),
((↑s).sigma fun i => ↑(t i)) = ↑(s.sigma t) | null | false |
ValuativeRel.valuation_surjective | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {K : Type u_3} [inst : DivisionRing K] [inst_1 : ValuativeRel K], Function.Surjective ⇑(ValuativeRel.valuation K) | null | true |
_private.Init.Data.SInt.Lemmas.0.ISize.ofIntLE_lt_iff_lt._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {x y : ISize}, (x < y) = (x.toInt < y.toInt) | null | false |
MeasureTheory.lintegral_mul_left_eq_self | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_1 : Group G] [MeasurableMul G]
[μ.IsMulLeftInvariant] (f : G → ENNReal) (g : G), ∫⁻ (x : G), f (g * x) ∂μ = ∫⁻ (x : G), f x ∂μ | Translating a function by left-multiplication does not change its Lebesgue integral
with respect to a left-invariant measure. | true |
MeasureTheory.VectorMeasure.coe_neg | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommGroup M] [inst_1 : TopologicalSpace M]
[inst_2 : IsTopologicalAddGroup M] (v : MeasureTheory.VectorMeasure α M), ↑(-v) = -↑v | null | true |
ValuationSubring.ofPrime_idealOfLE | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (R S : ValuationSubring K) (h : R ≤ S), R.ofPrime (R.idealOfLE S h) = S | null | true |
_private.Mathlib.Data.Set.Card.0.Set.odd_card_insert_iff._simp_1_3 | Mathlib.Data.Set.Card | ∀ {p : Prop} [Decidable p], (¬¬p) = p | null | false |
Lean.Grind.CommRing.Mon.sharesVar._unsafe_rec | Lean.Meta.Sym.Arith.Poly | Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Bool | null | false |
Nat.add_left_inj | Init.Data.Nat.Lemmas | ∀ {m k n : ℕ}, m + n = k + n ↔ m = k | null | true |
Valuation.IsTrivialOn.mk._flat_ctor | Mathlib.RingTheory.Valuation.Basic | ∀ {Γ₀ : Type u_4} [inst : LinearOrderedCommMonoidWithZero Γ₀] {B : Type u_7} {A : Type u_8} [inst_1 : CommSemiring A]
[inst_2 : Ring B] [inst_3 : Algebra A B] {v : Valuation B Γ₀},
(∀ (a : A), a ≠ 0 → v ((algebraMap A B) a) = 1) → Valuation.IsTrivialOn A v | null | false |
instTopologicalSpacePreStoneCech | Mathlib.Topology.Compactification.StoneCech | {α : Type u} → [inst : TopologicalSpace α] → TopologicalSpace (PreStoneCech α) | null | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategorySnd_pullback_obj | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) (Z : CategoryTheory.Over Y),
(CategoryTheory.ChosenPullbacksAlong.pullback (CategoryTheory.SemiCartesianMonoidalCategory.snd X Y)).obj Z =
CategoryTheory.Over.mk (CategoryTheory.MonoidalCa... | null | true |
_private.Mathlib.Analysis.Matrix.Order.0.Matrix.PosDef.hadamard._simp_1_1 | Mathlib.Analysis.Matrix.Order | ∀ {α : Type u_1} (s : Finset α) [inst : DecidablePred fun x => x ∈ s], s.attach = Finset.subtype (fun x => x ∈ s) s | null | false |
Nat.coprime_factorial_iff | Mathlib.Data.Nat.Prime.Factorial | ∀ {m n : ℕ}, m ≠ 1 → (m.Coprime n.factorial ↔ n < m.minFac) | null | true |
_private.Lean.Meta.Tactic.Cbv.CbvSimproc.0.Lean.Meta.Tactic.Cbv.getCbvSimprocFromDeclImpl._sparseCasesOn_2 | Lean.Meta.Tactic.Cbv.CbvSimproc | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
SimplexCategory.Truncated.morphismProperty_eq_top._proof_4 | Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty | ∀ {d : ℕ}, ∀ n < d, { len := n + 1 }.len ≤ d | null | false |
SkewPolynomial.erase.eq_1 | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (p : SkewPolynomial R),
SkewPolynomial.erase n p = (SkewMonoidAlgebra.erase (Multiplicative.ofAdd n)) p | null | true |
Lean.Grind.Linarith.Poly.norm.eq_2 | Init.Grind.Ordered.Linarith | ∀ (k : ℤ) (v : Lean.Grind.Linarith.Var) (p_2 : Lean.Grind.Linarith.Poly),
(Lean.Grind.Linarith.Poly.add k v p_2).norm = Lean.Grind.Linarith.Poly.insert k v p_2.norm | null | true |
Affine.Simplex.PointsWithCircumcenterIndex.ctorIdx | Mathlib.Geometry.Euclidean.Circumcenter | {n : ℕ} → Affine.Simplex.PointsWithCircumcenterIndex n → ℕ | null | false |
Subsemigroup.topEquiv_symm_apply_coe | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (x : M), ↑(Subsemigroup.topEquiv.symm x) = x | null | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.map_addNatEmb_Ioi._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
_private.Aesop.Tree.Check.0.Aesop.MVarClusterRef.checkMVars.checkNormMVars.match_1 | Aesop.Tree.Check | (motive : Aesop.NormalizationState → Sort u_1) →
(x : Aesop.NormalizationState) →
(Unit → motive Aesop.NormalizationState.notNormal) →
((postMetaState : Lean.Meta.SavedState) →
(script : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep))) →
motive (Aesop.Normalization... | null | false |
IncidenceAlgebra.instAddCommGroup._proof_5 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : AddCommGroup 𝕜] [inst_1 : LE α] (f g : IncidenceAlgebra 𝕜 α), ⇑(f - g) = ⇑f - ⇑g | null | false |
Finset.isPWO_support_mulAntidiagonal | Mathlib.Data.Finset.MulAntidiagonal | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelMonoid α] {s t : Set α}
{hs : s.IsPWO} {ht : t.IsPWO}, {a | (Finset.mulAntidiagonal hs ht a).Nonempty}.IsPWO | null | true |
_private.Mathlib.Analysis.BoxIntegral.Box.SubboxInduction.0.BoxIntegral.Box.mem_splitCenterBox._simp_1_4 | Mathlib.Analysis.BoxIntegral.Box.SubboxInduction | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
CategoryTheory.ShortComplex.ShortExact.d_eq_zero_of_f_eq_d_apply | Mathlib.Algebra.Homology.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type v}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[inst_3 : CategoryTheory.HasForget₂ C Ab] [inst_4 : CategoryTheory.Abelian C]
[inst_5 : (CategoryTheory.forget₂ C... | In the short exact sequence of complexes
```
0 0 0
| | |
v v v
...-> X_1,i -----> X_1,j --d--> X_1,k ->...
| | |
| f | |
v v v
...-> X_2,i --d--> X_... | true |
NonUnitalStarSubalgebra.instNonUnitalCommRing._proof_6 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : NonUnitalRing A] [inst_2 : StarRing A]
[inst_3 : Module R A] [inst_4 : IsScalarTower R A A] [inst_5 : SMulCommClass R A A]
(a b : ↥(NonUnitalStarSubalgebra.center R A)), a + b = b + a | null | false |
CategoryTheory.Limits.hasBinaryProduct_zero_right | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[CategoryTheory.Limits.HasZeroMorphisms C] (X : C), CategoryTheory.Limits.HasBinaryProduct X 0 | null | true |
Std.DTreeMap.Internal.instIteratorRxcIteratorIdSigma | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} → [inst : Ord α] → Std.Iterator (Std.DTreeMap.Internal.RxcIterator α β) Id ((a : α) × β a) | null | true |
Mathlib.Tactic.DepRewrite.Conv.depRewriteTarget | Mathlib.Tactic.DepRewrite | Lean.Syntax → Bool → optParam Mathlib.Tactic.DepRewrite.Config { } → Lean.Elab.Tactic.TacticM Unit | Apply `rewrite!` to the goal. | true |
CategoryTheory.Limits.PullbackCone.combine._proof_6 | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Pullbacks | ∀ {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] {F G H : CategoryTheory.Functor D C} (f : F ⟶ H) (g : G ⟶ H)
(c : (X : D) → CategoryTheory.Limits.PullbackCone (f.app X) (g.app X))
(hc : (X : D) → CategoryTheory.Limits.IsLimit (c X)) (x ... | null | false |
Array.findIdx?_eq_some_iff_findIdx_eq | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool} {i : ℕ},
Array.findIdx? p xs = some i ↔ i < xs.size ∧ Array.findIdx p xs = i | null | true |
Std.toList_roo_eq_toList_rco_of_isSome_succ? | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxo.IsAlwaysFinite α] {lo hi : α} (h : (Std.PRange.succ? lo).isSome = true),
(lo<...hi).toList = (((Std.PRange.succ? l... | null | true |
CategoryTheory.Equivalence.congrFullSubcategory_inverse | Mathlib.CategoryTheory.ObjectProperty.Equivalence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{P : CategoryTheory.ObjectProperty C} {Q : CategoryTheory.ObjectProperty D} (e : C ≌ D)
[inst_2 : Q.IsClosedUnderIsomorphisms] (h : Q.inverseImage e.functor = P),
(e.congrFullSubcategory h).inverse... | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.List.getValue_filter_containsKey._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValue a l h) = Std.Internal.List.getValue? a l | null | false |
Finset.range_subset_range | Mathlib.Data.Finset.Range | ∀ {n m : ℕ}, Finset.range n ⊆ Finset.range m ↔ n ≤ m | null | true |
IntermediateField.fg_bot | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E], ⊥.FG | null | true |
Submodule.coe_mapIic_apply | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M)
(q : Submodule R ↥p), ↑(p.mapIic q) = Submodule.map p.subtype q | null | true |
UniformSpace.Core.recOn | Mathlib.Topology.UniformSpace.Defs | {α : Type u} →
{motive : UniformSpace.Core α → Sort u_1} →
(t : UniformSpace.Core α) →
((uniformity : Filter (α × α)) →
(refl : Filter.principal SetRel.id ≤ uniformity) →
(symm : Filter.Tendsto Prod.swap uniformity uniformity) →
(comp : (uniformity.lift' fun s => SetRel.c... | null | false |
_private.Mathlib.Algebra.Order.GroupWithZero.Basic.0.inv_lt_one_iff₀._simp_1_1 | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b < a) = ¬a ≤ b | null | false |
Lean.Meta.SimpCongrTheorems.noConfusionType | Lean.Meta.Tactic.Simp.SimpCongrTheorems | Sort u → Lean.Meta.SimpCongrTheorems → Lean.Meta.SimpCongrTheorems → Sort u | null | false |
cfc_comp_re._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.RealImaginaryPart | Lean.Syntax | null | false |
_private.Lean.Namespace.0.Lean.namespacesExt | Lean.Namespace | Lean.PersistentEnvExtension Lean.Name Lean.Name Lean.State✝ | Environment extension for tracking all `namespace` declared by users.
| true |
Finset.map_disjSum | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Finset α} {t : Finset β} (f : α ⊕ β ↪ γ),
Finset.map f (s.disjSum t) =
(Finset.map (Function.Embedding.inl.trans f) s).disjUnion (Finset.map (Function.Embedding.inr.trans f) t) ⋯ | null | true |
CategoryTheory.CartesianMonoidalCategory.lift_snd_comp_fst_comp | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {W X Y Z : C} (g : W ⟶ X) (g' : Y ⟶ Z),
CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMono... | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.expandTypeAscription._regBuiltin.Lean.Elab.Term.expandTypeAscription.declRange_3 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
RootPairing.Equiv.weightEquiv_inv | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (g : P.Aut),
RootPairing.Equiv.weightEquiv P P g⁻¹ = (RootPairing.Equiv.weightEquiv P P g)⁻¹ | null | true |
Polynomial.prod_multiset_X_sub_C_dvd | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (p : Polynomial R),
(Multiset.map (fun a => Polynomial.X - Polynomial.C a) p.roots).prod ∣ p | The product `∏ (X - a)` for `a` inside the multiset `p.roots` divides `p`. | true |
Turing.TM1to1.Λ'._sizeOf_inst | Mathlib.Computability.TuringMachine.PostTuringMachine | (Γ : Type u_1) →
(Λ : Type u_2) → (σ : Type u_3) → [SizeOf Γ] → [SizeOf Λ] → [SizeOf σ] → SizeOf (Turing.TM1to1.Λ' Γ Λ σ) | null | false |
CategoryTheory.IsCofiltered.SmallCofilteredIntermediate._proof_1 | Mathlib.CategoryTheory.Filtered.Small | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.IsCofilteredOrEmpty C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_4, u_2} D] (F : CategoryTheory.Functor D C),
CategoryTheory.EssentiallySmall.{max u_1 u_2, u_1, u_3}
(CategoryTheory.IsCofiltered.cofilteredClosure F... | null | false |
HNNExtension.NormalWord.ReducedWord.ctorIdx | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} → {inst : Group G} → {A B : Subgroup G} → HNNExtension.NormalWord.ReducedWord G A B → ℕ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.