name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Set.kernImage_empty | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Set.kernImage f ∅ = (Set.range f)ᶜ | null | true |
IsCoveringMap.coe_monodromy_mk | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X}
(cov : IsCoveringMap p) {x y : X} (γ : Path x y) (e : ↑(p ⁻¹' {x})),
↑(cov.monodromy (Path.Homotopic.Quotient.mk γ) e) = (cov.liftPath ↑γ ↑e ⋯) 1 | null | true |
Subgroup.le_set_normalizer_iff | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {s : Set G},
H ≤ Subgroup.normalizer s ↔ ∀ h ∈ H, ∀ g ∈ s, h * g * h⁻¹ ∈ s | null | true |
Std.DTreeMap.Internal.Impl.containsThenInsertIfNew!_snd_eq_insertIfNew! | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α β) (a : α) (b : β a),
(Std.DTreeMap.Internal.Impl.containsThenInsertIfNew! a b t).2 = Std.DTreeMap.Internal.Impl.insertIfNew! a b t | null | true |
CategoryTheory.MorphismProperty.Comma.isoMk_inv_right | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory... | null | true |
TopCat.GlueData.MkCore.t'._proof_5 | Mathlib.Topology.Gluing | ∀ (h : TopCat.GlueData.MkCore) (i j k : h.J)
(x :
{ p //
(CategoryTheory.ConcreteCategory.hom (h.V i j).inclusion') p.1 =
(CategoryTheory.ConcreteCategory.hom (h.V i k).inclusion') p.2 }),
↑((CategoryTheory.ConcreteCategory.hom (h.t i j)) (↑x).1) ∈ h.V j k | null | false |
String.Slice.Pattern.Model.IsLongestRevMatch.casesOn | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.Model.PatternModel pat] →
{s : String.Slice} →
{pos : s.Pos} →
{motive : String.Slice.Pattern.Model.IsLongestRevMatch pat pos → Sort u} →
(t : String.Slice.Pattern.Model.IsLongestRevMatch pat pos) →
((isRevMatc... | null | false |
Set.image_neg_of_apply_neg_eq | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : InvolutiveNeg α] {s : Set α} {f g : α → β},
(∀ x ∈ s, f (-x) = g x) → f '' (-s) = g '' s | null | true |
BddAbove.of_closure | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] {s : Set α}, BddAbove (closure s) → BddAbove s | null | true |
LinearMap.mul''._proof_1 | Mathlib.Algebra.Algebra.Bilinear | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (a : A)
(x : TensorProduct R A A), (LinearMap.mul' R A).toFun (a • x) = (RingHom.id A) a • (LinearMap.mul' R A).toFun x | null | false |
Qq._aux_Qq_Commands___elabRules_Qq_termBy_elabq__1 | Qq.Commands | Lean.Elab.Term.TermElab | `by_elabq` is the Qq analogue to `by_elab` which allows executing arbitrary `TermElabM` code in
place of a term. In contrast to `by_elab`, the local context can be directly accessed as quoted
expressions and the return type is Q-annotated.
Example:
```
def f (x : Prop) [Decidable x] : Int :=
by_elabq
Lean.logInfo... | false |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.map_dual._simp_1_6 | Mathlib.Combinatorics.Matroid.Map | ∀ {a b : Prop}, (a ∧ b ↔ a) = (a → b) | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.instIteratorIdSearchStep.match_3.splitter | Init.Data.String.Pattern.String | (s : String.Slice) →
(motive :
Std.IterStep (Std.IterM Id (String.Slice.Pattern.SearchStep s)) (String.Slice.Pattern.SearchStep s) → Sort u_1) →
(x : Std.IterStep (Std.IterM Id (String.Slice.Pattern.SearchStep s)) (String.Slice.Pattern.SearchStep s)) →
((it' : Std.IterM Id (String.Slice.Pattern.Search... | null | true |
Filter.limsInf_le_of_le | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {f : Filter α} {a : α},
autoParam (Filter.IsBounded (fun x1 x2 => x2 ≤ x1) f) Filter.limsInf_le_of_le._auto_1 →
(∀ (b : α), (∀ᶠ (n : α) in f, b ≤ n) → b ≤ a) → f.limsInf ≤ a | null | true |
Batteries.CodeAction.getExplicitArgs._unsafe_rec | Batteries.CodeAction.Misc | Lean.Expr → Array Lean.Name → Array Lean.Name | null | false |
IsPrecomplete.map_algebraMap_iff | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] {I : Ideal R} {M : Type u_4} [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : CommRing S] [inst_4 : Module S M] [inst_5 : Algebra R S] [IsScalarTower R S M],
IsPrecomplete (Ideal.map (algebraMap R S) I) M ↔ IsPrecomplete I M | null | true |
PosNum.ldiff._sparseCasesOn_1 | Mathlib.Data.Num.Bitwise | {motive : PosNum → Sort u} →
(t : PosNum) → ((a : PosNum) → motive a.bit0) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
instSemiringCorner._aux_8 | Mathlib.RingTheory.Idempotents | {R : Type u_1} → (e : R) → [inst : NonUnitalSemiring R] → (idem : IsIdempotentElem e) → ℕ → idem.Corner → idem.Corner | null | false |
OptionT.instMonadAttach | Init.Control.Option | {m : Type u → Type v} → [Monad m] → [MonadAttach m] → MonadAttach (OptionT m) | null | true |
_private.Init.Data.SInt.Lemmas.0.Int16.le_total._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {x y : Int16}, (x ≤ y) = (x.toInt ≤ y.toInt) | null | false |
Stream'.get_of_bisim._f | Mathlib.Data.Stream.Init | ∀ {α : Type u} (R : Stream' α → Stream' α → Prop),
Stream'.IsBisimulation R →
∀ (x : ℕ)
(f :
Nat.below (motive := fun x =>
∀ {s₁ s₂ : Stream' α}, R s₁ s₂ → s₁.get x = s₂.get x ∧ R (Stream'.drop (x + 1) s₁) (Stream'.drop (x + 1) s₂))
x)
{s₁ s₂ : Stream' α}, R s₁ s₂ → s₁.get ... | null | false |
RestrictScalars.addEquiv | Mathlib.Algebra.Algebra.RestrictScalars | (R : Type u_1) → (S : Type u_2) → (M : Type u_3) → [inst : AddCommMonoid M] → RestrictScalars R S M ≃+ M | `RestrictScalars.addEquiv` is the additive equivalence with the original module. | true |
MeasureTheory.Measure.count_ne_zero | Mathlib.MeasureTheory.Measure.Count | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α}, s.Nonempty → MeasureTheory.Measure.count s ≠ 0 | **Alias** of the reverse direction of `MeasureTheory.Measure.count_ne_zero_iff`. | true |
Matrix.ofArray.eq_1 | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {R : Type u_5} {m n : ℕ} (A : Array R) (hA : A.size = m * n) (i : Fin m) (j : Fin n),
Matrix.ofArray A hA i j = A[i.mkDivMod j] | null | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.getElem_succ_leftInvSeq_alternatingWord._simp_1_2 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {G : Type u_1} [inst : Mul G] [IsRightCancelMul G] (a : G) {b c : G}, (b * a = c * a) = (b = c) | null | false |
UpperHemicontinuousWithinAt.union | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_3} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → Set β} {s : Set α}
{x : α},
UpperHemicontinuousWithinAt f s x →
UpperHemicontinuousWithinAt g s x → UpperHemicontinuousWithinAt (fun x => f x ∪ g x) s x | Pointwise unions of upper hemicontinuous maps are upper hemicontinuous. | true |
ENNReal.eq_top_of_forall_nnreal_le | Mathlib.Basic.ENNReal.Inv | ∀ {x : ENNReal}, (∀ (r : NNReal), ↑r ≤ x) → x = ⊤ | null | true |
AlgebraicGeometry.instCompactSpaceCarrierCarrierCommRingCatPullbackSchemeOfQuasiCompact | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [AlgebraicGeometry.QuasiCompact f] [CompactSpace ↥Y],
CompactSpace ↥(CategoryTheory.Limits.pullback f g) | null | true |
_private.Mathlib.Data.List.Interleave.0.List.Interleaves.mono.match_1_1 | Mathlib.Data.List.Interleave | ∀ {α : Type u_1} {r : α → α → Prop} (motive : (x x_1 : List α) → List.Interleaves r x x_1 → Prop) (x x_1 : List α)
(x_2 : List.Interleaves r x x_1),
(∀ (_ : Unit), motive [] [] ⋯) →
(∀ (a : α), motive [] [a] ⋯) →
(∀ (a b : α) (hab : r a b) (l₁ l₂ : List α) (hl : List.Interleaves r l₁ (b :: l₂)),
... | null | false |
Cycle.formPerm_eq_self_of_notMem | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Cycle α) (h : s.Nodup), ∀ x ∉ s, (s.formPerm h) x = x | null | true |
InnerProductSpace.Core.norm_eq_sqrt_re_inner | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), ‖x‖ = √(RCLike.re (inner 𝕜 x x)) | null | true |
CategoryTheory.Sheaf.over | Mathlib.CategoryTheory.Sites.Over | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
CategoryTheory.Sheaf J A → (X : C) → CategoryTheory.Sheaf (J.over X) A | Given `F : Sheaf J A` and `X : C`, this is the pullback of `F` on `J.over X`. | true |
_private.Mathlib.Algebra.Homology.Embedding.Connect.0.CochainComplex.ConnectData.d_comp_d._proof_1_6 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (m p : ℤ), m + 1 = p → ∀ (n : ℕ), Int.negSucc (n + 1 + 1) + 1 = m → m = Int.negSucc (n + 1) | null | false |
IsCoprime.neg_neg | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y : R}, IsCoprime x y → IsCoprime (-x) (-y) | null | true |
StandardEtalePair.instCommRingRing._proof_6 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R) (a : P.Ring), 0 + a = a | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_of_not_smulOverflow._proof_1_7 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
x.toInt * y.toInt < 2 ^ w ∧ -2 ^ w ≤ x.toInt * y.toInt → ¬x.toInt * y.toInt < (2 ^ (w + 1) + 1) / 2 → False | null | false |
VectorFourier.fourierIntegral.eq_1 | Mathlib.Analysis.Fourier.FourierTransform | ∀ {𝕜 : Type u_1} [inst : CommRing 𝕜] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : MeasurableSpace V] {W : Type u_3} [inst_4 : AddCommGroup W] [inst_5 : Module 𝕜 W] {E : Type u_4}
[inst_6 : NormedAddCommGroup E] [inst_7 : NormedSpace ℂ E] (e : AddChar 𝕜 Circle) (μ : MeasureTheory.Mea... | null | true |
CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
[inst_1 : W.HasLeftCalculusOfFractions] →
{X Y : C} →
(s : X ⟶ Y) →
W s →
((CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj Y ⟶
... | The morphism in `Localization W` that is the formal inverse of a morphism
which belongs to `W`. | true |
essInf_antitone_measure._auto_1 | Mathlib.MeasureTheory.Function.EssSup | Lean.Syntax | null | false |
ModuleCat.addCommGroupObj._proof_23 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (ModuleCat R)) (j : J) (a b : (F.comp (CategoryTheory.forget (ModuleCat R))).obj j),
a + b = b + a | null | false |
_private.Lean.Parser.Tactic.Doc.0.Lean.Parser.Tactic.Doc.isTactic._sparseCasesOn_1 | Lean.Parser.Tactic.Doc | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
PredSubOrder.mk._flat_ctor | Mathlib.Algebra.Order.SuccPred | {α : Type u_1} →
[inst : Preorder α] →
[inst_1 : Sub α] →
[inst_2 : One α] →
(pred : α → α) →
(∀ (a : α), pred a ≤ a) →
(∀ {a : α}, a ≤ pred a → IsMin a) →
(∀ {a b : α}, a < b → a ≤ pred b) → (∀ (x : α), pred x = x - 1) → PredSubOrder α | null | false |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.WF.merge'.match_1_5 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} {le : α → α → Bool} {n : ℕ} (r₁ : ℕ) (t₁ t₂ : Batteries.BinomialHeap.Imp.Heap α) (a : α)
(n_1 : Batteries.BinomialHeap.Imp.HeapNode α)
(motive :
Batteries.BinomialHeap.Imp.Heap.WF le n
(Batteries.BinomialHeap.Imp.Heap.merge le t₁ (Batteries.BinomialHeap.Imp.Heap.cons r₁.succ a n_1 t₂)... | null | false |
DyckWord.equivTree_apply | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord), DyckWord.equivTree p = p.toTree | null | true |
Std.LawfulOrderMax.rec | Init.Data.Order.Classes | {α : Type u} →
[inst : Max α] →
[inst_1 : LE α] →
{motive : Std.LawfulOrderMax α → Sort u_1} →
([toMaxEqOr : Std.MaxEqOr α] → [toLawfulOrderSup : Std.LawfulOrderSup α] → motive ⋯) →
(t : Std.LawfulOrderMax α) → motive t | null | false |
Ideal.prod_span_singleton | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {ι : Type u_2} (s : Finset ι) (I : ι → R),
∏ i ∈ s, Ideal.span {I i} = Ideal.span {∏ i ∈ s, I i} | null | true |
_private.Mathlib.Data.List.OfFn.0.List.find?_ofFn_eq_some._proof_1_5 | Mathlib.Data.List.OfFn | ∀ {n : ℕ} (i : Fin n), ∀ j < ↑i, j < n | null | false |
Lean.ModuleDoc.casesOn | Lean.DocString.Extension | {motive : Lean.ModuleDoc → Sort u} →
(t : Lean.ModuleDoc) →
((doc : String) →
(declarationRange : Lean.DeclarationRange) → motive { doc := doc, declarationRange := declarationRange }) →
motive t | null | false |
Polynomial.toFinsuppIsoLinear | Mathlib.Algebra.Polynomial.Basic | (R : Type u) → [inst : Semiring R] → Polynomial R ≃ₗ[R] AddMonoidAlgebra R ℕ | Linear isomorphism between `R[X]` and `R[ℕ]`. This is just an
implementation detail, but it can be useful to transfer results from `Finsupp` to polynomials. | true |
Nat.sqrt.iter._unsafe_rec | Init.Data.Nat.Sqrt.Basic | ℕ → ℕ → ℕ | null | false |
Real.sin_sq_pi_over_two_pow | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℕ), Real.sin (Real.pi / 2 ^ (n + 1)) ^ 2 = 1 - (Real.sqrtTwoAddSeries 0 n / 2) ^ 2 | null | true |
_private.Mathlib.Topology.Homotopy.HSpaces.0.HSpace.prod._simp_2 | Mathlib.Topology.Homotopy.HSpaces | ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b₁ b₂ : β}, ((a₁, b₁) = (a₂, b₂)) = (a₁ = a₂ ∧ b₁ = b₂) | null | false |
Topology.isEmbedding_sigmoid | Mathlib.Analysis.SpecialFunctions.Sigmoid | Topology.IsEmbedding unitInterval.sigmoid | null | true |
ContinuousOrderHom.instContinuousOrderHomClass | Mathlib.Topology.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : Preorder α] [inst_2 : TopologicalSpace β]
[inst_3 : Preorder β], ContinuousOrderHomClass (α →Co β) α β | null | true |
differentiableAt_natCast | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] [inst_7 : NatCast F] (n : ℕ) (x : E), DifferentiableAt 𝕜 (↑n) x | null | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Partial.0.hasStrictFDerivAt_uncurry_coprod.match_1_1 | Mathlib.Analysis.Calculus.FDeriv.Partial | {E₁ : Type u_1} →
{E₂ : Type u_2} →
(motive : (E₁ × E₂) × E₁ × E₂ → Sort u_3) → (x : (E₁ × E₂) × E₁ × E₂) → ((v w : E₁ × E₂) → motive (v, w)) → motive x | null | false |
Std.DTreeMap.Internal.Impl.Const.maxEntry.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : Type u_2} →
(motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α fun x => β) →
(x_1 : x.isEmpty = false) →
((size : ℕ) →
(k : α) →
(v : β) →
(l : Std... | null | false |
intervalIntegral.integral_finset_sum | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
{ι : Type u_8} {s : Finset ι} {f : ι → ℝ → E},
(∀ i ∈ s, IntervalIntegrable (f i) μ a b) →
∫ (x : ℝ) in a..b, ∑ i ∈ s, f i x ∂μ = ∑ i ∈ s, ∫ (x : ℝ) in a..b, f i x ∂μ | **Alias** of `intervalIntegral.integral_finsetSum`. | true |
ContinuousAffineEquiv.prodAssoc_toAffineEquiv | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ (k : Type u_1) (P₁ : Type u_2) (P₂ : Type u_3) (P₃ : Type u_4) {V₁ : Type u_6} {V₂ : Type u_7} {V₃ : Type u_8}
[inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁]
[inst_4 : TopologicalSpace P₁] [inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂]
... | null | true |
CommGrpCat.coyoneda.eq_1 | Mathlib.Algebra.Category.Grp.Yoneda | CommGrpCat.coyoneda =
{
obj := fun M =>
{ obj := fun N => ↧(↑(Opposite.unop M) →* ↑N),
map := fun {X Y} f => CommGrpCat.ofHom (MonoidHom.compHom (CommGrpCat.Hom.hom f)), map_id := ⋯, map_comp := ⋯ },
map := fun {X Y} f => { app := fun N => CommGrpCat.ofHom (CommGrpCat.Hom.hom f.unop).compHom', n... | null | true |
StrictAnti.wellFoundedLT | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} [WellFoundedGT β],
StrictAnti f → WellFoundedLT α | null | true |
Filter.tendsto_atTop_mono' | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] (l : Filter α) ⦃f₁ f₂ : α → β⦄,
f₁ ≤ᶠ[l] f₂ → Filter.Tendsto f₁ l Filter.atTop → Filter.Tendsto f₂ l Filter.atTop | null | true |
_private.Mathlib.NumberTheory.EllipticDivisibilitySequence.0.IsEllipticNet.rel_odd._proof_1_2 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] (W : ℤ → R) (m : ℤ),
IsEllipticNet.rel W (m + 1) m 1 0 = W (2 * m + 1) * W 1 ^ 3 - W (m + 2) * W m ^ 3 + W (m - 1) * W (m + 1) ^ 3 | null | false |
segment_eq_image' | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [AddRightMono 𝕜] [inst_3 : AddCommGroup E]
[inst_4 : Module 𝕜 E] (x y : E), segment 𝕜 x y = (fun θ => x + θ • (y - x)) '' Set.Icc 0 1 | null | true |
Bool.le_true._simp_1 | Init.Data.Bool | ∀ (x : Bool), (x ≤ true) = True | null | false |
Finset.prod_filter | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : CommMonoid M] (p : ι → Prop) [inst_1 : DecidablePred p]
(f : ι → M), ∏ a ∈ s with p a, f a = ∏ a ∈ s, if p a then f a else 1 | null | true |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isNoncomputable.match_1 | Lean.Elab.DeclModifiers | (motive : Lean.Elab.ComputeKind → Sort u_1) →
(x : Lean.Elab.ComputeKind) →
(Unit → motive Lean.Elab.ComputeKind.noncomputable) → ((x : Lean.Elab.ComputeKind) → motive x) → motive x | null | false |
Multiset.zero_disjoint | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} (l : Multiset α), Disjoint 0 l | null | true |
CategoryTheory.CommGrpObj | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] → [CategoryTheory.BraidedCategory C] → C → Type v | Abbreviation for an unbundled commutative group object. It is a group object that is a
commutative monoid object. | true |
Fin.univ_image_get | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), Finset.image l.get Finset.univ = l.toFinset | null | true |
Complex.regularizedHGFunCoeff_eq_zero_left._auto_3 | Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric | Lean.Syntax | null | false |
Std.DTreeMap.instUnion | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Union (Std.DTreeMap α β cmp) | null | true |
Polynomial.UniversalCoprimeFactorizationRing.isCoprime_factor₁_factor₂ | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
IsCoprime ↑(Polynomial.UniversalCoprimeFactorizationRing.factor₁ m k hn p)
↑(Polynomial.UniversalCoprimeFactorizationRing.factor₂ m k hn p) | null | true |
ComplexShape.notMem_range_embeddingUpIntLE_iff | Mathlib.Algebra.Homology.Embedding.Basic | ∀ (p n : ℤ), (∀ (i : ℕ), (ComplexShape.embeddingUpIntLE p).f i ≠ n) ↔ p < n | null | true |
PMF.filter_apply_eq_zero_iff | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} {p : PMF α} {s : Set α} (h : ∃ a ∈ s, a ∈ p.support) (a : α),
(p.filter s h) a = 0 ↔ a ∉ s ∨ a ∉ p.support | null | true |
CliffordAlgebra.EvenHom._sizeOf_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
{inst : CommRing R} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} →
{Q : QuadraticForm R M} →
{A : Type u_3} →
{inst_3 : Ring A} →
{inst_4 : Algebra R A} → [SizeOf R] → [SizeOf M] → [SizeOf A] → CliffordAlgeb... | null | false |
BinaryTree.numLeaves.eq_def | Mathlib.Data.Tree.Basic | ∀ {α : Type u} (x : BinaryTree α),
x.numLeaves =
match x with
| BinaryTree.nil => 1
| BinaryTree.node value a b => a.numLeaves + b.numLeaves | null | true |
Finsupp.lcoeFun._proof_1 | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] (x y : α →₀ M), ⇑(x + y) = ⇑x + ⇑y | null | false |
_private.Mathlib.Order.Heyting.Hom.0.OrderIsoClass.toHeytingHomClass._simp_1 | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] [inst_2 : EquivLike F α β]
[OrderIsoClass F α β] (f : F) {a : α} {b : β}, (b ≤ f a) = (EquivLike.inv f b ≤ a) | null | false |
CategoryTheory.PreGaloisCategory.instPreservesColimitsOfShapeActionFintypeCatAutFunctorSingleObjFunctorToActionOfFinite | Mathlib.CategoryTheory.Galois.Action | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (F : CategoryTheory.Functor C FintypeCat)
[inst_1 : CategoryTheory.GaloisCategory C] [CategoryTheory.PreGaloisCategory.FiberFunctor F] (G : Type u_2)
[inst_3 : Group G] [Finite G],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.SingleO... | null | true |
CStarMatrix.toCLM_apply_single_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Fintype m] [inst_1 : NonUnitalCStarAlgebra A]
[inst_2 : DecidableEq m] {M : CStarMatrix m n A} {i : m} {j : n} (a : A),
(CStarMatrix.toCLM M) ((WithCStarModule.equiv A (m → A)).symm (Pi.single i a)) j = a * M i j | null | true |
_private.Lean.MetavarContext.0.Lean.DependsOn.dep.visit | Lean.MetavarContext | (Lean.FVarId → Bool) → (Lean.MVarId → Bool) → Lean.Expr → Lean.DependsOn.M✝ Bool | null | true |
ULift.instLinearOrder._proof_2 | Mathlib.Order.Lattice | ∀ {α : Type u_2} [inst : LinearOrder α] {x y : ULift.{u_1, u_2} α}, x.down < y.down ↔ x < y | null | false |
Metric.closedBall_subset_closedBall | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε₁ ε₂ : ℝ},
ε₁ ≤ ε₂ → Metric.closedBall x ε₁ ⊆ Metric.closedBall x ε₂ | null | true |
Array.extract_size_left | Init.Data.Array.Extract | ∀ {α : Type u_1} {j : ℕ} {as : Array α}, as.extract as.size j = #[] | null | true |
LinearEquiv.curry._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | ∀ (R : Type u_4) (M : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (V : Type u_1)
(V₂ : Type u_2) (x : R) (x_1 : V × V₂ → M),
(Equiv.curry V V₂ M).toFun (x • x_1) = (Equiv.curry V V₂ M).toFun (x • x_1) | null | false |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valued.integer.mem_iff._simp_1_2 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {r₁ r₂ : NNReal}, (r₁ ≤ r₂) = (↑r₁ ≤ ↑r₂) | null | false |
DirichletCharacter.LFunction_ne_zero_of_one_le_re | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N) [inst : NeZero N] ⦃s : ℂ⦄,
χ ≠ 1 ∨ s ≠ 1 → 1 ≤ s.re → DirichletCharacter.LFunction χ s ≠ 0 | If `χ` is a Dirichlet character, then `L(χ, s)` does not vanish for `s.re ≥ 1`
except when `χ` is trivial and `s = 1` (then `L(χ, s)` has a simple pole at `s = 1`). | true |
_private.Lean.Environment.0.Lean.ImportedModule.mk.injEq | Lean.Environment | ∀ (toEffectiveImport : Lean.EffectiveImport) (parts irParts : Array (Lean.ModuleData × Lean.CompactedRegion))
(needsIRTrans : Bool) (toEffectiveImport_1 : Lean.EffectiveImport)
(parts_1 irParts_1 : Array (Lean.ModuleData × Lean.CompactedRegion)) (needsIRTrans_1 : Bool),
({ toEffectiveImport := toEffectiveImport, ... | null | true |
Std.Rxo.Iterator.mk.sizeOf_spec | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : SizeOf α] (next : Option α) (upperBound : α),
sizeOf { next := next, upperBound := upperBound } = 1 + sizeOf next + sizeOf upperBound | null | true |
normalClosure_of_stabilizer_eq_top | Mathlib.GroupTheory.GroupAction.Jordan | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α],
2 < ENat.card α →
MulAction.IsMultiplyPretransitive G α 2 → ∀ {a : α}, Subgroup.normalClosure ↑(MulAction.stabilizer G a) = ⊤ | In a 2-transitive action, the normal closure of stabilizers is the full group. | true |
_private.Aesop.Util.Tactic.Ext.0.Aesop.straightLineExt.go._sparseCasesOn_5 | Aesop.Util.Tactic.Ext | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.IsCardinalPure | Mathlib.CategoryTheory.Presentable.CardinalPure | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → (κ : Cardinal.{w}) → [Fact κ.IsRegular] → {X Y : C} → (X ⟶ Y) → Prop | Given a regular cardinal `κ`, we say that a morphism `f : X ⟶ Y`
is `κ`-pure if for any commutative square:
```
t
X' -----> Y'
| |
l| |r
v v
X -----> Y
f
```
where `X'` and `Y'` are `κ`-presentable, there exists a morphism
`ρ : Y' ⟶ X` such that `t ≫ ρ = l`. | true |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.Basic.0.integral_cos_sq._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Subgroup.exists_smul_eq | Mathlib.GroupTheory.SchurZassenhaus | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [inst_1 : IsMulCommutative ↥H] [inst_2 : H.FiniteIndex]
[inst_3 : H.Normal], (Nat.card ↥H).Coprime H.index → ∀ (α β : H.QuotientDiff), ∃ h, h • α = β | null | true |
Relation.SymmGen | Mathlib.Logic.Relation | {α : Type u_1} → (α → α → Prop) → α → α → Prop | `SymmGen r`: symmetric closure of `r`. This is also the comparability relation, such
that `SymmGen r a b` means that either `r a b` or `r b a` (see `Mathlib.Order.Comparable`). | true |
Std.ExtTreeSet.getD_inter_of_not_mem_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k fallback : α},
k ∉ t₁ → (t₁ ∩ t₂).getD k fallback = fallback | null | true |
Field.Emb.Cardinal.strictMono_leastExt | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E],
StrictMono (Field.Emb.Cardinal.leastExt F E) | null | true |
RelEmbedding._sizeOf_1 | Mathlib.Order.RelIso.Basic | {α : Type u_5} →
{β : Type u_6} →
{r : α → α → Prop} →
{s : β → β → Prop} →
[SizeOf α] → [SizeOf β] → [(a a_1 : α) → SizeOf (r a a_1)] → [(a a_1 : β) → SizeOf (s a a_1)] → r ↪r s → ℕ | null | false |
Configuration.ProjectivePlane.ctorIdx | Mathlib.Combinatorics.Configuration | {P : Type u_1} → {L : Type u_2} → {inst : Membership P L} → Configuration.ProjectivePlane P L → ℕ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.