name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Elab.AssertExists.0.Lean.Elab.Command.elabImportPath._regBuiltin.Lean.Elab.Command.elabImportPath.docString_3 | Lean.Elab.AssertExists | IO Unit | null | false |
Real.image_exp_Ioo | Mathlib.Analysis.SpecialFunctions.Exp | ∀ (a b : ℝ), Real.exp '' Set.Ioo a b = Set.Ioo (Real.exp a) (Real.exp b) | null | true |
instDecidableEqComposition.decEq._proof_3 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (a : List ℕ) (a_1 : ∀ {i : ℕ}, i ∈ a → 0 < i) (a_2 : a.sum = n) (b : List ℕ) (b_1 : ∀ {i : ℕ}, i ∈ b → 0 < i)
(b_2 : b.sum = n),
¬a = b →
¬{ blocks := a, blocks_pos := a_1, blocks_sum := a_2 } = { blocks := b, blocks_pos := b_1, blocks_sum := b_2 } | null | false |
MeasureTheory.L1.SimpleFunc.setToL1SCLM'._proof_3 | Mathlib.MeasureTheory.Integral.SetToL1.SimpleFunc | ∀ (E : Type u_1) [inst : NormedAddCommGroup E], ContinuousAdd E | null | false |
Multipliable.prod_mul_tprod_nat_add | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {G : Type u_2} [inst : CommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [T2Space G] {f : ℕ → G}
(k : ℕ), Multipliable f → (∏ i ∈ Finset.range k, f i) * ∏' (i : ℕ), f (i + k) = ∏' (i : ℕ), f i | null | true |
CategoryTheory.CostructuredArrow.Hom.w_assoc | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor C D} {T : D} {X Y : CategoryTheory.CostructuredArrow S T} (f : X ⟶ Y) {Z : D} (h : T ⟶ Z),
CategoryTheory.CategoryStruct.comp (S.map (CategoryTheory.CostructuredArrow.H... | null | true |
_private.Batteries.Tactic.ShowUnused.0.Batteries.Tactic.ShowUnused.visit.visitExpr._unsafe_rec | Batteries.Tactic.ShowUnused | Lean.Environment → Lean.Expr → StateM Lean.NameSet Unit | null | false |
Pi.instSemilatticeInf.eq_1 | Mathlib.Order.Lattice | ∀ {ι : Type u_1} {α' : ι → Type u_2} [inst : (i : ι) → SemilatticeInf (α' i)],
Pi.instSemilatticeInf =
{ toPartialOrder := Pi.partialOrder, inf := fun x y i => x i ⊓ y i, inf_le_left := ⋯, inf_le_right := ⋯,
le_inf := ⋯ } | null | true |
_private.Init.CbvSimproc.0.Lean.Parser.«_aux_Init_CbvSimproc___macroRules_Lean_Parser_command__Cbv_simproc____(_):=__1».match_1 | Init.CbvSimproc | (motive :
Option (Lean.TSyntax [`Lean.Parser.Tactic.simpPre, `Lean.Parser.Tactic.simpPost, `Lean.Parser.cbvSimprocEval]) →
Sort u_1) →
(phase? :
Option (Lean.TSyntax [`Lean.Parser.Tactic.simpPre, `Lean.Parser.Tactic.simpPost, `Lean.Parser.cbvSimprocEval])) →
((phase? : Lean.TSyntax [`Lean.Parser.T... | null | false |
Complex.differentiable_exp._simp_1 | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ], Differentiable 𝕜 Complex.exp = True | null | false |
CategoryTheory.Limits.pullbackConeEquivBinaryFan._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : Y ⟶ X} {g : Z ⟶ X}
(c : CategoryTheory.Limits.PullbackCone f g),
CategoryTheory.CategoryStruct.comp c.fst (CategoryTheory.Over.mk f).hom =
CategoryTheory.CategoryStruct.comp c.fst (CategoryTheory.Over.mk f).hom | null | false |
Array.range_eq_range' | Init.Data.Array.Range | ∀ {n : ℕ}, Array.range n = Array.range' 0 n | null | true |
Array.countP_reverse | Init.Data.Array.Count | ∀ {α : Type u_1} {p : α → Bool} {xs : Array α}, Array.countP p xs.reverse = Array.countP p xs | null | true |
_private.Mathlib.Combinatorics.Matroid.Rank.Finite.0.Matroid.isRkFinite_iff_exists_isBasis'.match_1_1 | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X : Set α} (motive : (∃ I, M.IsBasis' I X ∧ I.Finite) → Prop)
(x : ∃ I, M.IsBasis' I X ∧ I.Finite), (∀ (w : Set α) (hIX : M.IsBasis' w X) (hI : w.Finite), motive ⋯) → motive x | null | false |
HahnSeries.SummableFamily.pow_finite_co_support | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : AddCommMonoid Γ] [inst_1 : LinearOrder Γ] [inst_2 : IsOrderedCancelAddMonoid Γ]
[inst_3 : CommRing R] {x : HahnSeries Γ R}, 0 < x.orderTop → ∀ (g : Γ), {a | ((fun n => x ^ n) a).coeff g ≠ 0}.Finite | null | true |
Besicovitch.TauPackage.noConfusion | Mathlib.MeasureTheory.Covering.Besicovitch | {P : Sort u} →
{β : Type u_1} →
{α : Type u_2} →
{t : Besicovitch.TauPackage β α} →
{β' : Type u_1} →
{α' : Type u_2} →
{t' : Besicovitch.TauPackage β' α'} →
β = β' → α = α' → t ≍ t' → Besicovitch.TauPackage.noConfusionType P t t' | null | false |
GaloisConnection.l_unique | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {u : α → β} {l : β → α},
GaloisConnection l u →
∀ {u' : α → β} {l' : β → α}, GaloisConnection l' u' → (∀ (a : α), u a = u' a) → ∀ {b : β}, l b = l' b | null | true |
Std.Time.FormatType.match_1 | Std.Time.Format.Basic | (motive : Std.Time.FormatString → Sort u_1) →
(x : Std.Time.FormatString) →
((entry : Std.Time.Modifier) →
(xs : List Std.Time.FormatPart) → motive (Std.Time.FormatPart.modifier entry :: xs)) →
((val : String) → (xs : List Std.Time.FormatPart) → motive (Std.Time.FormatPart.string val :: xs)) →
... | null | false |
Ordering.isLE_gt | Init.Data.Ord.Basic | Ordering.gt.isLE = false | null | true |
Std.Async.Signal.sigquit | Std.Async.Signal | Std.Async.Signal | Quit program.
| true |
IsNormableSpace.toPseudoMetrizableSpace | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ (𝕜 : Type u_2) (E : Type u_6) [inst : NormedField 𝕜] [ha : AddCommGroup E] [hm : Module 𝕜 E] [t : TopologicalSpace E]
[hn : IsNormableSpace 𝕜 E], TopologicalSpace.PseudoMetrizableSpace E | A normable space is metrizable. Not an instance as the field of scalars can not be guessed
by typeclass inference. | true |
CategoryTheory.Limits.pushoutCoconeOfRightIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} → (f : X ⟶ Y) → (g : X ⟶ Z) → [CategoryTheory.IsIso g] → CategoryTheory.Limits.PushoutCocone f g | If `f : X ⟶ Z` is iso, then `Y ⨿[X] Z ≅ Y`. This is the explicit colimit cocone. | true |
AlgebraicGeometry.IsFinite.casesOn | Mathlib.AlgebraicGeometry.Morphisms.Finite | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsFinite f → Sort u} →
(t : AlgebraicGeometry.IsFinite f) →
([toIsAffineHom : AlgebraicGeometry.IsAffineHom f] →
(finite_app :
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U ... | null | false |
PNat.factorMultiset_gcd | Mathlib.Data.PNat.Factors | ∀ (m n : ℕ+), (m.gcd n).factorMultiset = m.factorMultiset ⊓ n.factorMultiset | The gcd and lcm operations on positive integers correspond
to the inf and sup operations on multisets. | true |
AddAut.addConj_apply | Mathlib.Algebra.Group.End | ∀ {G : Type u_3} [inst : AddGroup G] (g h : G), (AddAut.addConj g) h = g + h + -g | null | true |
FirstOrder.Language.ElementarySubstructure.recOn | Mathlib.ModelTheory.ElementarySubstructures | {L : FirstOrder.Language} →
{M : Type u_1} →
[inst : L.Structure M] →
{motive : L.ElementarySubstructure M → Sort u} →
(t : L.ElementarySubstructure M) →
((toSubstructure : L.Substructure M) →
(isElementary' : toSubstructure.IsElementary) →
motive { toSubstruc... | null | false |
Lean.Meta.matchHEq? | Lean.Meta.MatchUtil | Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) | null | true |
CategoryTheory.Limits.isLimitEquivFanOfIsThin._proof_8 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] [Quiver.IsThin C] {J : Type u_3}
[inst_2 : CategoryTheory.Category.{u_1, u_3} J] {K : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cone K)
(h : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fan.mk c.pt c.π.app)) (s : CategoryTheory.Limi... | null | false |
Int.add_lt_add_of_lt_of_le | Init.Data.Int.Order | ∀ {a b c d : ℤ}, a < b → c ≤ d → a + c < b + d | null | true |
UInt8.toUInt32_ofFin | Init.Data.UInt.Lemmas | ∀ {n : Fin UInt8.size}, (UInt8.ofFin n).toUInt32 = UInt32.ofNatLT ↑n ⋯ | null | true |
Real.Lp_add_le_tsum_of_nonneg | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} {f g : ι → ℝ} {p : ℝ},
1 ≤ p →
(∀ (i : ι), 0 ≤ f i) →
(∀ (i : ι), 0 ≤ g i) →
(Summable fun i => f i ^ p) →
(Summable fun i => g i ^ p) →
(Summable fun i => (f i + g i) ^ p) ∧
(∑' (i : ι), (f i + g i) ^ p) ^ (1 / p) ≤
(∑' (i : ι), f i... | **Minkowski inequality**: the `L_p` seminorm of the infinite sum of two vectors is less than or
equal to the infinite sum of the `L_p`-seminorms of the summands, if these infinite sums both
exist. A version for `ℝ`-valued functions. For an alternative version, convenient if the infinite
sums are already expressed as `p... | true |
Finset.empty | Mathlib.Data.Finset.Empty | {α : Type u_1} → Finset α | The empty finset | true |
ContinuousMap.instCommMonoidWithZeroOfContinuousMul | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : CommMonoidWithZero β] → [ContinuousMul β] → CommMonoidWithZero C(α, β) | null | true |
Submonoid.closure_singleton_eq | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M] (x : M), Submonoid.closure {x} = MonoidHom.mrange ((powersHom M) x) | null | true |
Metric.eball_top | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α), Metric.eball x ⊤ = Set.univ | null | true |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'.congr_simp | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{obj obj' : (i : ι) → ↑(F.obj { as := Opp... | null | true |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.ctorIdx | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.TerminalReplacementOutcome✝ → ℕ | null | false |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.filtrationOfSet_eq_natural._simp_1_3 | Mathlib.Probability.Process.Filtration | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Path._sizeOf_inst | Mathlib.Topology.Path | {X : Type u_1} → {inst : TopologicalSpace X} → (x y : X) → [SizeOf X] → SizeOf (Path x y) | null | false |
Pi.Lex.lt_iff_of_unique | Mathlib.Order.PiLex | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : Unique ι] [inst_1 : (i : ι) → LT (β i)] [inst_2 : Preorder ι]
{x y : Lex ((i : ι) → β i)}, x < y ↔ x default < y default | null | true |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.lcm_dvd_iff._simp_1_3 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : SemigroupWithZero α] (a : α), (a ∣ 0) = True | null | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Add.0.differentiableWithinAt_comp_add_left._simp_1_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} {s : Set E} (a : E),
HasFDerivWithinAt (fun x => f (a + x)) f' s x = Has... | null | false |
Array.forIn_map | Init.Data.Array.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} {init : γ} [inst : Monad m] [LawfulMonad m]
{xs : Array α} {g : α → β} {f : β → γ → m (ForInStep γ)},
forIn (Array.map g xs) init f = forIn xs init fun a y => f (g a) y | null | true |
_private.Mathlib.Data.Set.NAry.0.Set.image2_distrib_subset_left._proof_1_1 | Mathlib.Data.Set.NAry | ∀ {α : Type u_2} {β : Type u_4} {β' : Type u_6} {γ : Type u_5} {γ' : Type u_7} {δ : Type u_3} {ε : Type u_1} {s : Set α}
{t : Set β} {u : Set γ} {f : α → δ → ε} {g : β → γ → δ} {f₁ : α → β → β'} {f₂ : α → γ → γ'} {g' : β' → γ' → ε},
(∀ (a : α) (b : β) (c : γ), f a (g b c) = g' (f₁ a b) (f₂ a c)) →
Set.image2 f ... | null | false |
Finset.insert_nonempty._simp_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), (insert a s).Nonempty = True | null | false |
ZNum.addCommGroup._proof_2 | Mathlib.Data.Num.ZNum | ∀ (a : ZNum), 0 • a = 0 | null | false |
Function.locallyFinsuppWithin.supported._proof_3 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] (Y : Type u_2) [inst_1 : AddGroup Y] (U s : Set X)
{a b : Function.locallyFinsuppWithin U Y},
a ∈ {D | D.support ⊆ s} → b ∈ {D | D.support ⊆ s} → (Function.support fun x => a x + b x) ⊆ s | null | false |
Polynomial.Bivariate.aeval_eq_map_swap | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (x : A)
(p : Polynomial (Polynomial R)),
(Polynomial.aeval (Polynomial.C x)) p = (Polynomial.mapAlgHom (Polynomial.aeval x)) (Polynomial.Bivariate.swap p) | null | true |
List.zipWithM.loop.eq_def | Init.Data.List.Monadic | ∀ {m : Type u → Type v} [inst : Monad m] {α : Type w} {β : Type x} {γ : Type u} (f : α → β → m γ) (x : List α)
(x_1 : List β) (x_2 : Array γ),
List.zipWithM.loop f x x_1 x_2 =
match x, x_1, x_2 with
| a :: as, b :: bs, acc => do
let __do_lift ← f a b
List.zipWithM.loop f as bs (acc.push __do_lif... | null | true |
Finset.card_le_card_mul_left_of_injective | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {s t : Finset α} {a : α},
a ∈ s → IsLeftRegular a → t.card ≤ (s * t).card | See `card_le_card_mul_left` for a more convenient but less general version for types with a
left-cancellative multiplication.
| true |
Algebra.Presentation.instCommRingCore._proof_67 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ},
autoParam (∀ (n : ℕ) (a : P.Core), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
AddMonoidAlgebra.modOf_add_divOf | Mathlib.Algebra.MonoidAlgebra.Division | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCommMonoid G] [inst_2 : IsCancelAdd G]
(x : AddMonoidAlgebra k G) (g : G), x.modOf g + AddMonoidAlgebra.of' k G g * x.divOf g = x | null | true |
List.findFinIdx?_singleton | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {p : α → Bool}, List.findFinIdx? p [a] = if p a = true then some ⟨0, ⋯⟩ else none | null | true |
DirectLimit.Ring.of._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_1) {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonAssocSemir... | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.ofSlice_ne_endPos._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {q r : (s.slice p₀ p₁ h).Pos},
(q < r) = (String.Pos.ofSlice q < String.Pos.ofSlice r) | null | false |
MeasureTheory.measureReal_nonneg._simp_1 | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, (0 ≤ μ.real s) = True | null | false |
Ideal.ramificationIdx_spec | Mathlib.NumberTheory.RamificationInertia.Ramification | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal R} {P : Ideal S}
{n : ℕ}, Ideal.map (algebraMap R S) p ≤ P ^ n → ¬Ideal.map (algebraMap R S) p ≤ P ^ (n + 1) → p.ramificationIdx' P = n | **Alias** of `Ideal.ramificationIdx'_spec`. | true |
iSup₂_le_iSup | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] (κ : ι → Sort u_8) (f : ι → α), ⨆ i, ⨆ x, f i ≤ ⨆ i, f i | null | true |
AlgebraicClosure.isAlgebraic | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u) [inst : Field k], Algebra.IsAlgebraic k (AlgebraicClosure k) | null | true |
_private.Lean.Meta.Tactic.Grind.LawfulEqCmp.0.Lean.Meta.Grind.getLawfulEqCmpThm?.go?.match_6 | Lean.Meta.Tactic.Grind.LawfulEqCmp | (motive : Lean.Expr → Sort u_1) →
(__x : Lean.Expr) →
((binderName : Lean.Name) →
(α' b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName α' b binderInfo)) →
((x : Lean.Expr) → motive x) → motive __x | null | false |
DirectSum.instLieRingSubtypeMemSubmodule._proof_2 | Mathlib.Algebra.Lie.Graded | ∀ {ι : Type u_1} {R : Type u_3} {L : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid ι] [inst_2 : CommRing R]
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ℒ : ι → Submodule R L) [inst_5 : GradedLieAlgebra ℒ]
(x x_1 x_2 : DirectSum ι fun i => ↥(ℒ i)),
(DirectSum.decomposeLinearEquiv ℒ)
⁅(DirectSu... | null | false |
Quantale.mul_bot | Mathlib.Algebra.Order.Quantale | ∀ {α : Type u_3} [inst : Semigroup α] [inst_1 : CompleteLattice α] [IsQuantale α] {x : α}, x * ⊥ = ⊥ | null | true |
WeierstrassCurve.Jacobian.negAddY_of_Z_eq_zero_right | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P Q : Fin 3 → R},
W'.Equation Q → Q 2 = 0 → W'.negAddY P Q = (-(Q 0 * P 2)) ^ 3 * W'.negY P | null | true |
ChainComplex.mk.eq_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(X₀ X₁ X₂ : V) (d₀ : X₁ ⟶ X₀) (d₁ : X₂ ⟶ X₁) (s : CategoryTheory.CategoryStruct.comp d₁ d₀ = 0)
(succ :
(S : CategoryTheory.ShortComplex V) →
(X₃ : V) ×' (d₂ : X₃ ⟶ S.X₁) ×' CategoryTheory.Category... | null | true |
Option.le.eq_3 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (val : α), Option.le r (some val) none = False | null | true |
CategoryTheory.Bimon.trivialTo | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → (A : CategoryTheory.Bimon C) → CategoryTheory.Bimon.trivial C ⟶ A | The bimonoid morphism from the trivial bimonoid to any bimonoid. | true |
Finsupp.sum_add_index | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : DecidableEq α] [inst_1 : AddZeroClass M]
[inst_2 : AddCommMonoid N] {f g : α →₀ M} {h : α → M → N},
(∀ a ∈ f.support ∪ g.support, h a 0 = 0) →
(∀ a ∈ f.support ∪ g.support, ∀ (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ + h a b₂) → (f + g).sum h = f.sum h + g.sum h | Taking the product under `h` is an additive homomorphism of finsupps, if `h` is an
additive homomorphism on the support. This is a more general version of
`Finsupp.sum_add_index'`; the latter has simpler hypotheses. | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.take_drop._proof_1_3 | Mathlib.Data.Seq.Basic | ∀ {α : Type u_1} {s : Stream'.Seq α} {n m : ℕ} (i : ℕ),
m + i + 1 ≤ (Stream'.Seq.take n s).length → m + i < (Stream'.Seq.take n s).length | null | false |
_private.Init.Data.Array.BasicAux.0.PSigma.casesOn._arg_pusher | Init.Data.Array.BasicAux | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
tendsto_bdd_div_atTop_nhds_zero | Mathlib.Topology.Algebra.Order.Field | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [OrderTopology 𝕜] {l : Filter α} {f g : α → 𝕜} {b B : 𝕜},
(∀ᶠ (x : α) in l, b ≤ f x) →
(∀ᶠ (x : α) in l, f x ≤ B) → Filter.Tendsto g l Filter.atTop → Filter.Tendsto (fun x => f... | If `g` tends to `atTop` and there exist constants `b B : 𝕜` such that eventually
`b ≤ f x| ≤ B`, then the quotient `f / g` tends to zero. | true |
Asymptotics.IsBigO.mul_isLittleO | Mathlib.Analysis.Asymptotics.Ring | ∀ {α : Type u_1} {R : Type u_4} [inst : SeminormedRing R] {S : Type u_7} [inst_1 : NormedRing S] [NormMulClass S]
{l : Filter α} {f₁ f₂ : α → R} {g₁ g₂ : α → S},
f₁ =O[l] g₁ → f₂ =o[l] g₂ → (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x | null | true |
SheafOfModules.mk.sizeOf_spec | Mathlib.Algebra.Category.ModuleCat.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : SizeOf C] (val : PresheafOfModules R.obj)
(isSheaf : CategoryTheory.Presheaf.IsSheaf J val.presheaf), sizeOf { val := val, isSheaf := isSheaf } = 1 + sizeOf val | null | true |
CoheytingAlgebra.toOrderTop | Mathlib.Order.Heyting.Basic | {α : Type u_4} → [self : CoheytingAlgebra α] → OrderTop α | null | true |
_private.Batteries.Data.List.Basic.0.List.tailsTR.go.eq_def | Batteries.Data.List.Basic | ∀ {α : Type u_1} (l : List α) (acc : Array (List α)),
List.tailsTR.go✝ l acc =
match l with
| [] => acc.toListAppend [[]]
| head :: xs => List.tailsTR.go✝ xs (acc.push l) | null | true |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.1956376046._hygCtx._hyg.1.noConfusion | ProofWidgets.Component.Basic | {P : Sort u} →
{t t' : ProofWidgets.RpcEncodablePacket✝} →
t = t' →
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.1956376046._hygCtx._hyg.1.noConfusionType P t t' | null | false |
Lean.Language.Lean.instToSnapshotTreeCommandResultSnapshot | Lean.Language.Lean.Types | Lean.Language.ToSnapshotTree Lean.Language.Lean.CommandResultSnapshot | null | true |
RatFunc.isCoprime_num_denom | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] (x : RatFunc K), IsCoprime x.num x.denom | null | true |
HomotopyEquiv.refl_homotopyInvHomId | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} (C : HomologicalComplex V c), (HomotopyEquiv.refl C).homotopyInvHomId = Homotopy.ofEq ⋯ | null | true |
Mathlib.Tactic.ClickSuggestions.Result.rec | Mathlib.Tactic.ClickSuggestions.SectionState | {α : Type} →
{motive : Mathlib.Tactic.ClickSuggestions.Result α → Sort u} →
((filtered : Option ProofWidgets.Html) →
(unfiltered : ProofWidgets.Html) →
(key : α) →
(pattern : ProofWidgets.Html) →
motive { filtered := filtered, unfiltered := unfiltered, key := key, patte... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.StronglyRegular.0.SimpleGraph.IsSRGWith.matrix_eq._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(G.neighborSet v)],
(G.neighborSet v).toFinset = G.neighborFinset v | null | false |
SeminormClass.mk | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {F : Type u_12} {𝕜 : outParam (Type u_13)} {E : outParam (Type u_14)} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E]
[inst_2 : SMul 𝕜 E] [inst_3 : FunLike F E ℝ] [toAddGroupSeminormClass : AddGroupSeminormClass F E ℝ],
(∀ (f : F) (a : 𝕜) (x : E), f (a • x) = ‖a‖ * f x) → SeminormClass F 𝕜 E | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isLinearSet_iff_exists_matrix.match_1_1 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_1} {s : Set (ι → ℕ)} (v : ι → ℕ) (n : ℕ) (motive : (∃ f, s = v +ᵥ Set.range ⇑f) → Prop)
(x : ∃ f, s = v +ᵥ Set.range ⇑f), (∀ (f : (Fin n → ℕ) →+ ι → ℕ) (hf : s = v +ᵥ Set.range ⇑f), motive ⋯) → motive x | null | false |
AddCon.comap_rel._simp_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] {f : M → N} (H : ∀ (x y : M), f (x + y) = f x + f y)
{c : AddCon N} {x y : M}, (AddCon.comap f H c) x y = c (f x) (f y) | null | false |
CategoryTheory.Functor.PreservesZeroMorphisms.recOn | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
{F : CategoryTheory.Functor C D} →
... | null | false |
Affine.Simplex.eq_centroid_iff_sum_vsub_eq_zero | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} [CharZero k] {s : Affine.Simplex k P n} {p : P},
p = s.centroid ↔ ∑ i, (s.points i -ᵥ p) = 0 | A point is centroid if and only if the sum of vectors from the point to all vertices is zero. | true |
Vector.set_eq_push_extract_append_extract | Init.Data.Vector.Extract | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} (h : i < n) {a : α},
xs.set i a h = Vector.cast ⋯ ((xs.extract 0 i).push a ++ xs.extract (i + 1)) | null | true |
TendstoUniformlyOn.tendsto_comp | Mathlib.Topology.UniformSpace.UniformApproximation | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {x : α} {p : Filter ι} {g : ι → α},
TendstoUniformlyOn F f p s →
ContinuousWithinAt f s x → Filter.Tendsto g p (nhdsWithin x s) → Filter.Tendsto (fun n => F n (g n)) p (nh... | If `Fₙ` tends uniformly to `f` on a set `s`, and `gₙ` tends to `x` within `s`, then `Fₙ gₙ`
tends to `f x` if `f` is continuous at `x` within `s`. | true |
NumberField.Units.dirichletUnitTheorem.seq.eq_2 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (w₁ : NumberField.InfinitePlace K) {B : ℕ}
(hB : NumberField.mixedEmbedding.minkowskiBound K 1 < ↑(NumberField.mixedEmbedding.convexBodyLTFactor K) * ↑B)
(n : ℕ), NumberField.Units.dirichletUnitTheorem.seq K w₁ hB n.succ = ⟨⋯.choose, ⋯⟩ | null | true |
CategoryTheory.Bicategory.InducedBicategory.bicategory_rightUnitor_inv_hom | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b : CategoryTheory.Bicategory.InducedBicategory C F} (x : a ⟶ b),
(CategoryTheory.Bicategory.rightUnitor x).inv.hom = (CategoryTheory.Bicategory.rightUnitor x.hom).inv | null | true |
Subgroup.rank_commutator_le_card | Mathlib.GroupTheory.Commutator.Finite | ∀ (G : Type u_1) [inst : Group G] [inst_1 : Finite ↑(commutatorSet G)],
Group.rank ↥(commutator G) ≤ Nat.card ↑(commutatorSet G) | null | true |
_private.Mathlib.RingTheory.Ideal.Maps.0.Module.annihilator_prod._simp_1_6 | Mathlib.RingTheory.Ideal.Maps | ∀ {α : Sort u_1} [Nonempty α] (p : α → Prop) (q : Prop), ((∀ (x : α), p x) ∧ q) = ∀ (x : α), p x ∧ q | null | false |
Lean.MessageDataContext.ctorIdx | Lean.Message | Lean.MessageDataContext → ℕ | null | false |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory.0.CategoryTheory.Triangulated.AbelianSubcategory.mono_ιK._simp_1_3 | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
Cardinal.toNat_eq_one | Mathlib.SetTheory.Cardinal.ToNat | ∀ {c : Cardinal.{u}}, Cardinal.toNat c = 1 ↔ c = 1 | null | true |
_private.Init.Data.UInt.Bitwise.0.USize.shiftLeft_add._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : USize}, (a < b) = (a.toNat < b.toNat) | null | false |
Zsqrtd.im_star | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} (z : ℤ√d), (star z).im = -z.im | null | true |
MeasurableSet.Subtype.instBooleanAlgebra._proof_2 | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] {x y : Subtype MeasurableSet}, ↑x ⊆ ↑y ↔ ↑x ⊆ ↑y | null | false |
MulAction.ctorIdx | Mathlib.Algebra.Group.Action.Defs | {α : Type u_9} → {β : Type u_10} → {inst : Monoid α} → MulAction α β → ℕ | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Exp.0.Real.isLittleO_exp_comp_exp_comp._simp_1_5 | Mathlib.Analysis.SpecialFunctions.Exp | ∀ (a : Prop), (False → a) = True | null | false |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.Icc_subset_Ico_iff.match_1_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α} (motive : a₂ ≤ a₁ ∧ b₁ < b₂ → Prop) (x : a₂ ≤ a₁ ∧ b₁ < b₂),
(∀ (h : a₂ ≤ a₁) (h' : b₁ < b₂), motive ⋯) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.