name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Repr.addAppParen | Init.Data.Repr | Std.Format → ℕ → Std.Format | Adds parentheses to `f` if the precedence `prec` from the context is at least that of function
application.
Together with `reprArg`, this can be used to correctly parenthesize function application
syntax.
| true |
Rep.coinvariantsTensorIndNatIso_inv_app | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u} [inst : CommRing k] {G H : Type u} [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{u, u, u} k G) (X : Rep.{u, u, u} k H),
(Rep.coinvariantsTensorIndNatIso φ A).inv.app X = Rep.coinvariantsTensorIndInv φ A X | null | true |
CategoryTheory.Limits.monoCoprodOfHasZeroMorphisms | Mathlib.CategoryTheory.Limits.MonoCoprod | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C],
CategoryTheory.Limits.MonoCoprod C | null | true |
Complex.sinh_zero | Mathlib.Analysis.Complex.Trigonometric | Complex.sinh 0 = 0 | null | true |
WithSeminorms.withSeminorms_eq | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{p : SeminormFamily 𝕜 E ι} [t : TopologicalSpace E], WithSeminorms p → t = p.moduleFilterBasis.topology | null | true |
CategoryTheory.Limits.coneUnopOfCoconeEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} J] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_3, u_1} C] {F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ}
{X Y Z : (CategoryTheory.Limits.Cocone F)ᵒᵖ} (f : Y ⟶ X) (g : Z ⟶ Y),
{ hom := (CategoryTheory.CategoryStruct.comp g f).unop.hom.unop, w := ⋯ } =
C... | null | false |
GradedAlgHom.coe_ofClass | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {ι : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : Grade... | null | true |
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 |
Std.WP.WPMonad.wp_tryCatch_lift_OptionT_apply_eq | Std.WP.Monad.Lemmas | ∀ {Pred : Type u} {EPred : Type u_1} {ε : Type u} {m : Type u → Type v} [inst : Monad m]
[inst_1 : Std.WP.Assertion Pred] [inst_2 : Std.WP.Assertion EPred] [inst_3 : Std.WP.WPMonad m Pred EPred]
[inst_4 : MonadExceptOf ε m] {α : Type u} {post : α → Pred} {epost : (Unit → Pred) × EPred} (x : OptionT m α)
(h : ε → ... | null | 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 |
_private.Mathlib.Computability.Ackermann.0.ack_three._proof_1_1 | Mathlib.Computability.Ackermann | ∀ (n : ℕ), 3 ≤ n + 3 | null | false |
AddSubgroup.instNontrivialSubtypeMemTop | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] [Nontrivial G], Nontrivial ↥⊤ | null | true |
AlgebraicGeometry.Scheme.ofArrows_mem_smallEtaleTopology_iff | Mathlib.AlgebraicGeometry.Sites.Etale | ∀ {X : AlgebraicGeometry.Scheme} {W : X.Etale} {ι : Type u_1} {Z : ι → X.Etale} (f : (i : ι) → Z i ⟶ W),
CategoryTheory.Sieve.ofArrows Z f ∈ X.smallEtaleTopology W ↔ ⋃ i, Set.range ⇑(f i).left = Set.univ | null | true |
MeasureTheory.measureReal_union_add_inter'._auto_3 | Mathlib.MeasureTheory.Measure.Real | Lean.Syntax | 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 |
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 |
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 |
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 |
Lean.Order.instMonadTailStateRefT'._proof_1 | Init.Internal.Order.MonadTail | ∀ {ω σ : Type} {m : Type → Type} [inst : Monad m] [inst_1 : Lean.Order.MonadTail m] (α : Type) [inst_2 : Nonempty α]
{c : ReaderT (ST.Ref ω σ) m α → Prop}, Lean.Order.chain c → Exists (Lean.Order.is_sup c) | 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 |
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 |
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 |
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.VectorMeasure.coe_neg | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {F : Type u_2} {α : Type u_4} {β : Type u_5} [inst : FunLike F α β] [inst_1 : Neg F] [inst_2 : Neg β]
[IsNegApply F α β] (f : F), ⇑(-f) = -⇑f | **Alias** of `FunLike.coe_neg`. | 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 |
Inclusion.HypArg.rec | Mathlib.Tactic.Inclusion.ExtensionAPI.Attr | {motive : Inclusion.HypArg → Sort u} →
((elemIdx setIdx proofIdx : ℕ) → motive { elemIdx := elemIdx, setIdx := setIdx, proofIdx := proofIdx }) →
(t : Inclusion.HypArg) → motive t | null | false |
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 |
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 |
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.Lean.Elab.InfoTree.Util.0.Lean.Elab.InfoTree.goalsAt?.hasNestedTactic | Lean.Elab.InfoTree.Util | String.Pos.Raw → String.Pos.Raw → String.Pos.Raw → Lean.Elab.InfoTree → Bool | null | true |
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 |
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 |
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 |
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.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 |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.expandTypeAscription._regBuiltin.Lean.Elab.Term.expandTypeAscription.declRange_3 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
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 |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Basic.0.AlgebraicGeometry.Scheme.IdealSheafData.le_support_iff_le_vanishingIdeal._simp_1_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData}, (I ≤ J) = ∀ (U : ↑X.affineOpens), I.ideal U ≤ J.ideal U | null | false |
IsUniformAddGroup.uniformContinuous_iff_isOpen_ker | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {hom : Type u_3}
[inst_3 : UniformSpace β] [DiscreteTopology β] [inst_5 : AddGroup β] [IsUniformAddGroup β] [inst_7 : FunLike hom α β]
[inst_8 : AddMonoidHomClass hom α β] {f : hom}, UniformContinuous ⇑f ↔ IsOpen ↑(↑... | A homomorphism from a uniform additive group to a discrete uniform additive group
is continuous if and only if its kernel is open. | true |
Filter.Tendsto.units.eq_1 | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {N : Type u_4} [inst : TopologicalSpace N] [inst_1 : Monoid N] [inst_2 : ContinuousMul N]
[inst_3 : T2Space N] {f : ι → Nˣ} {r₁ r₂ : N} {l : Filter ι} [inst_4 : l.NeBot]
(h₁ : Filter.Tendsto (fun x => ↑(f x)) l (nhds r₁)) (h₂ : Filter.Tendsto (fun x => ↑(f x)⁻¹) l (nhds r₂)),
h₁.units h₂ = { val ... | null | true |
AffineEquiv.group._proof_5 | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {V₁ : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (n : ℕ) (a : P₁ ≃ᵃ[k] P₁), a ^ ↑n.succ = a ^ ↑n * a | null | false |
Function.Surjective.nonUnitalNonAssocRing | Mathlib.Algebra.Ring.InjSurj | {R : Type u_1} →
{S : Type u_2} →
(f : R → S) →
Function.Surjective f →
[inst : Add S] →
[inst_1 : Mul S] →
[inst_2 : Zero S] →
[inst_3 : Neg S] →
[inst_4 : Sub S] →
[inst_5 : SMul ℕ S] →
[inst_6 : SMul ℤ S] →
... | Pushforward a `NonUnitalNonAssocRing` instance along a surjective function. | true |
IsClosed.add_left_of_isCompact | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G] {s t : Set G},
IsClosed t → IsCompact s → IsClosed (s + t) | null | true |
Set.PartiallyWellOrderedOn.minBadSeqOfBadSeq._proof_2 | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_1} (r : α → α → Prop) (rk : α → ℕ) (s : Set α) (n : ℕ) (f : ℕ → α),
Set.PartiallyWellOrderedOn.IsBadSeq r s f →
∃ k g, (∀ m < n, f m = g m) ∧ Set.PartiallyWellOrderedOn.IsBadSeq r s g ∧ rk (g n) = k | null | false |
Std.Time.Modifier.z.elim | Std.Time.Format.Modifier | {motive : Std.Time.Modifier → Sort u} →
(t : Std.Time.Modifier) →
t.ctorIdx = 30 → ((presentation : Std.Time.ZoneName) → motive (Std.Time.Modifier.z presentation)) → motive t | null | false |
CategoryTheory.SpectralSequence.rec | Mathlib.Algebra.Homology.SpectralSequence.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{motive : CategoryTheory.SpectralSequence C c r₀ → Sort u} →
((page :
(r : ℤ) → autoPa... | null | false |
_private.Lean.Elab.ElabRules.0.Lean.Elab.Command.elabElabRulesAux._sparseCasesOn_3 | Lean.Elab.ElabRules | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Lean.Grind.CommRing.SPolResult.recOn | Lean.Meta.Sym.Arith.Poly | {motive : Lean.Grind.CommRing.SPolResult → Sort u} →
(t : Lean.Grind.CommRing.SPolResult) →
((spol : Lean.Grind.CommRing.Poly) →
(k₁ : ℤ) →
(m₁ : Lean.Grind.CommRing.Mon) →
(k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) → motive { spol := spol, k₁ := k₁, m₁ := m₁, k₂ := k₂, ... | null | false |
UInt64.toBitVec_ofNat' | Init.Data.UInt.Lemmas | ∀ (n : ℕ), (UInt64.ofNat n).toBitVec = BitVec.ofNat 64 n | null | true |
Lean.CollectFVars.State.ctorIdx | Lean.Util.CollectFVars | Lean.CollectFVars.State → ℕ | null | false |
StrictConcaveOn.eq_of_isMaxOn | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommMonoid β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : AddCommMonoid E]
[inst_7 : SMul 𝕜 E] [inst_8 : Module 𝕜 β] [PosSMulMono 𝕜 β] {f : E → β} {s : Set E} {x y : E}... | A strictly concave function admits at most one global maximum. | true |
CategoryTheory.strict_initial | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] {A : C}
[CategoryTheory.Closed A] {I : C} (t : CategoryTheory.Limits.IsInitial I) (f : A ⟶ I), CategoryTheory.IsIso f | If an initial object `I` exists in a CCC then it is a strict initial object,
i.e. any morphism to `I` is an iso.
This actually shows a slightly stronger version: any morphism to an initial object from an
exponentiable object is an isomorphism.
| true |
DerivedCategory.Plus.isLE_ι_obj_iff | Mathlib.Algebra.Homology.DerivedCategory.Plus | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] (X : DerivedCategory.Plus C) (n : ℤ), (DerivedCategory.Plus.ι.obj X).IsLE n ↔ X.IsLE n | null | true |
Lean.Meta.Grind.SplitSource.guard.injEq | Lean.Meta.Tactic.Grind.Types | ∀ (origin origin_1 : Lean.Meta.Grind.Origin),
(Lean.Meta.Grind.SplitSource.guard origin = Lean.Meta.Grind.SplitSource.guard origin_1) = (origin = origin_1) | null | true |
Std.DTreeMap.Raw.Const.getD_union_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
m₁.WF →
m₂.WF →
∀ {k : α} {fallback : β},
k ∉ m₁ → Std.DTreeMap.Raw.Const.getD (m₁ ∪ m₂) k fallback = Std.DTreeMap.Raw.Const.getD m₂ k fallback | null | true |
nhdsSet_Ioi | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderClosedTopology α] {a : α},
nhdsSet (Set.Ioi a) = Filter.principal (Set.Ioi a) | null | true |
Int.gcd_ne_zero_right | Init.Data.Int.Gcd | ∀ {b a : ℤ}, b ≠ 0 → a.gcd b ≠ 0 | null | true |
CategoryTheory.Limits.Multicofork.ofSigmaCofork_ι_app_left | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
{I : CategoryTheory.Limits.MultispanIndex J C} {c : CategoryTheory.Limits.Cofan I.left}
(hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right}
(a : CategoryTheory.Limits.Cofork (I.fstSig... | null | true |
_private.Mathlib.Analysis.Convex.Segment.0.openSegment_subset_union._simp_1_2 | Mathlib.Analysis.Convex.Segment | ∀ {k : Type u_2} {V1 : Type u_3} {P1 : Type u_4} [inst : CommRing k] [inst_1 : AddCommGroup V1]
[inst_2 : AddTorsor V1 P1] [inst_3 : Module k V1] (c : P1) (r : k) (p : P1),
(AffineMap.lineMap c p) r = (AffineMap.homothety c r) p | null | false |
TwoSidedIdeal.leftModule._proof_3 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] (I : TwoSidedIdeal R) (x : R) (x_1 : ↥I),
I.coeAddMonoidHom (x • x_1) = I.coeAddMonoidHom (x • x_1) | null | false |
jacobiSym | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ℤ → ℕ → ℤ | The Jacobi symbol of `a` and `b` | true |
AlgebraicTopology.DoldKan.N₁Γ₀_hom_app | Mathlib.AlgebraicTopology.DoldKan.GammaCompN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ),
AlgebraicTopology.DoldKan.N₁Γ₀.hom.app K =
CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKan.Γ₀.splitting K).toKaroubi... | null | true |
PolynomialModule.exists | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{P : PolynomialModule R M → Prop}, (∃ p, P p) ↔ ∃ q, P { coeff := q } | null | true |
InitialSeg.apply_wCovBy_apply_iff._simp_1 | Mathlib.Order.SuccPred.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {a b : α} [inst : PartialOrder α] [inst_1 : PartialOrder β] (f : α ≤i β),
(f a ⩿ f b) = (a ⩿ b) | null | false |
IsUnital.toMonoid._proof_2 | Mathlib.Algebra.Group.Monoid | ∀ {A : Type u_1} [inst : Semigroup A] [inst_1 : IsUnital A] (n : ℕ) (x : A), x ^ (n + 1) = x ^ n * x | null | false |
Finset.singletonZeroHom_apply | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Zero α] (a : α), Finset.singletonZeroHom a = {a} | null | true |
Matroid.dual_isBase_iff' | Mathlib.Combinatorics.Matroid.Dual | ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M✶.IsBase B ↔ M.IsBase (M.E \ B) ∧ B ⊆ M.E | null | true |
CategoryTheory.Functor.OplaxMonoidal.ofBifunctor.secondMap₃_app_app_app | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D}
(δ : CategoryTheory.MonoidalCategory.curriedTensorPost F ⟶ Catego... | null | true |
ArchimedeanClass.instFieldFiniteResidueField._proof_17 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K]
(a b c : ArchimedeanClass.FiniteResidueField K), a * b * c = a * (b * c) | null | false |
_private.Lean.Message.0.Lean.MessageData.stripNestedTags.stripNestedNamePrefix._sunfold | Lean.Message | Lean.Name → Lean.Name | null | false |
Mathlib.Tactic.IntervalCases.Methods.mk.noConfusion | Mathlib.Tactic.IntervalCases | {P : Sort u} →
{initLB initUB : Lean.Expr → Lean.MetaM (Mathlib.Tactic.IntervalCases.Bound × Lean.Expr × Lean.Expr)} →
{proveLE proveLT : Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr} →
{roundUp roundDown : Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr} →
{eval : Lean.Expr → L... | null | false |
IsCentralScalar.op_smul_eq_smul | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_9} {α : Type u_10} {inst : SMul M α} {inst_1 : SMul Mᵐᵒᵖ α} [self : IsCentralScalar M α] (m : M) (a : α),
MulOpposite.op m • a = m • a | The right and left actions of `M` on `α` are equal. | true |
_private.Mathlib.Analysis.Fourier.AddCircleMulti.0.UnitAddTorus.hasSum_mFourier_series_L2._simp_1_1 | Mathlib.Analysis.Fourier.AddCircleMulti | ∀ {d : Type u_1} [inst : Fintype d], UnitAddTorus.mFourierLp 2 = ⇑UnitAddTorus.mFourierBasis | null | false |
SlashInvariantForm.instIsSMulApplyUpperHalfPlaneComplex | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} [inst : Γ.HasDetOne] {α : Type u_2} [inst_1 : SMul α ℂ]
[inst_2 : IsScalarTower α ℂ ℂ], IsSMulApply α (SlashInvariantForm Γ k) UpperHalfPlane ℂ | null | true |
CategoryTheory.Prefunctor.toQuivHom | Mathlib.CategoryTheory.Category.Quiv | {C D : Type u} → [inst : Quiver C] → [inst_1 : Quiver D] → C ⥤q D → (↧C ⟶ ↧D) | Prefunctors between quivers define arrows in `Quiv`. | true |
MeasurableSpace.CountablyGenerated.casesOn | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | {α : Type u_3} →
[m : MeasurableSpace α] →
{motive : MeasurableSpace.CountablyGenerated α → Sort u} →
(t : MeasurableSpace.CountablyGenerated α) →
((isCountablyGenerated : ∃ b, b.Countable ∧ m = MeasurableSpace.generateFrom b) → motive ⋯) → motive t | null | false |
CategoryTheory.nerve | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | (C : Type u) → [CategoryTheory.Category.{v, u} C] → SSet | The nerve of a category | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.