name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.cosh_artanh._proof_1_6 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {x : ℝ}, x ∈ Set.Ioo (-1) 1 → 0 ≤ 1 + x | null | false |
Equiv.Perm.cycleFactorsFinset_eq_singleton_self_iff | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α}, f.cycleFactorsFinset = {f} ↔ f.IsCycle | null | true |
_private.Init.Data.Format.Basic.0.Std.Format.FlattenAllowability.shouldFlatten._sparseCasesOn_1 | Init.Data.Format.Basic | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Std.ExtTreeSet.get?_ofList_of_contains_eq_false | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : BEq α] [Std.LawfulBEqCmp cmp] {l : List α}
{k : α}, l.contains k = false → (Std.ExtTreeSet.ofList l cmp).get? k = none | null | true |
LinearOrder.OfStdArgs.lawfulOrderOrd | Mathlib.Order.Std | ∀ {α : Type u_1} (self : LinearOrder.OfStdArgs α),
let this := self.le;
let this_1 := self.lt;
let this_2 := ⋯;
let this_3 := ⋯;
let this_4 := self.decidableEq;
let this_5 := self.decidableLT;
Std.LawfulOrderOrd α | `Ord` is compatible with ≤. | true |
_private.Init.Data.Range.Polymorphic.Basic.0.Std.Rxo.size_eq_zero_iff_not_le.match_1_3 | Init.Data.Range.Polymorphic.Basic | ∀ {α : Type u_1} (motive : Option α → Prop) (x : Option α),
(x = none → motive none) → (∀ (b : α), x = some b → motive (some b)) → motive x | null | false |
Set.Nonempty.div_zero | Mathlib.Algebra.GroupWithZero.Pointwise.Set.Basic | ∀ {α : Type u_1} [inst : GroupWithZero α] {s : Set α}, s.Nonempty → s / 0 = 0 | null | true |
_private.Mathlib.Analysis.PSeries.0.NNReal.summable_schlomilch_iff._simp_1_1 | Mathlib.Analysis.PSeries | ∀ {β : Type u_2} {f : β → NNReal}, Summable f = (∑' (b : β), ↑(f b) ≠ ⊤) | null | false |
Mathlib.Tactic.Ring.Common.Overlap.rec | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
{e : Q(«$α»)} →
{motive : Mathlib.Tactic.Ring.Common.Overlap bt sα e → Sort u} →
((x : Q(Mathlib.Meta.NormNum.IsNat «$e» 0)) → motive (Mathlib.Tactic.Ring.Common.Overlap.zero x)) →
... | null | false |
_private.Mathlib.Order.DirSupClosed.0.dirSupInaccOn_iff_forall_sSup._simp_1_2 | Mathlib.Order.DirSupClosed | ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {s : Set α} {a : α}, IsLUB s a = (sSup s = a) | null | false |
Lean.Grind.CommRing.Mon.denote.eq_1 | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α),
Lean.Grind.CommRing.Mon.denote ctx Lean.Grind.CommRing.Mon.unit = 1 | null | true |
ProofWidgets.RefreshComponent.RpcEncodablePacket.«_@».ProofWidgets.Component.RefreshComponent.311896448._hygCtx._hyg.1.casesOn | ProofWidgets.Component.RefreshComponent | {motive : ProofWidgets.RefreshComponent.RpcEncodablePacket✝ → Sort u} →
(t : ProofWidgets.RefreshComponent.RpcEncodablePacket✝) →
((state oldIdx : Lean.Json) → motive { state := state, oldIdx := oldIdx }) → motive t | null | false |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.isNat_dvd_false.match_1_1 | Mathlib.Tactic.NormNum.Basic | ∀
(motive :
(x x_1 x_2 x_3 x_4 : ℕ) →
Mathlib.Meta.NormNum.IsNat x x_2 → Mathlib.Meta.NormNum.IsNat x_1 x_3 → x_3.mod x_2 = x_4.succ → Prop)
(x x_1 x_2 x_3 x_4 : ℕ) (x_5 : Mathlib.Meta.NormNum.IsNat x x_2) (x_6 : Mathlib.Meta.NormNum.IsNat x_1 x_3)
(x_7 : x_3.mod x_2 = x_4.succ),
(∀ (n n_1 c : ℕ) (e :... | null | false |
Lean.Meta.Grind.Arith.CommRing.Semiring.natCastFn? | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.Semiring → Option Lean.Expr | null | true |
_private.Mathlib.Tactic.ClickSuggestions.GRewrite.0.Mathlib.Tactic.ClickSuggestions.gcongrBackward | Mathlib.Tactic.ClickSuggestions.GRewrite | Lean.Name → Lean.Expr → Bool → Lean.MetaM (Array Mathlib.Tactic.ClickSuggestions.GrwPos) | Given the relation for grewriting at the given position, figure out all of the
subrelations that could also be used. | true |
CategoryTheory.Limits.MultispanIndex.map_left | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Multiequalizer | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {J : CategoryTheory.Limits.MultispanShape}
(d : CategoryTheory.Limits.MultispanIndex J C) (F : CategoryTheory.Functor C D) (i : J.L),
(d.map F).left i = F.obj (d.left i) | null | true |
TopologicalSpace.Opens.adjunction_counit_app_self | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U : TopologicalSpace.Opens ↑X), ⋯.adjunction.counit.app U = CategoryTheory.eqToHom ⋯ | null | true |
_private.Mathlib.SetTheory.ZFC.VonNeumann.0.ZFSet.vonNeumann_of_isSuccPrelimit._simp_1_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {o : Ordinal.{u}} {x : ZFSet.{u}}, (x ∈ ZFSet.vonNeumann o) = (x.rank < o) | null | false |
CategoryTheory.Mat_.isoBiproductEmbedding._proof_4 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_1} (M : CategoryTheory.Mat_ C) (i j : M.ι), j = i → M.X j = M.X i | null | false |
Equiv.addCommMonoid._proof_2 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : AddCommMonoid β] (x y : α),
e (e.symm (e.toFun x + e.toFun y)) = e.toFun x + e.toFun y | null | false |
Lean.Lsp.CodeActionOptions.noConfusionType | Lean.Data.Lsp.CodeActions | Sort u → Lean.Lsp.CodeActionOptions → Lean.Lsp.CodeActionOptions → Sort u | null | false |
RingOfIntegers.ZModXQuotSpanEquivQuotSpan.eq_1 | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {θ : NumberField.RingOfIntegers K} {p : ℕ}
[inst_2 : Fact (Nat.Prime p)] (hp : ¬p ∣ RingOfIntegers.exponent θ),
RingOfIntegers.ZModXQuotSpanEquivQuotSpan hp =
(Ideal.quotientEquivAlgOfEq ℤ ⋯).toRingEquiv.trans
(((Ideal.span {Polynomial.map (Ideal.... | null | true |
AddSubsemigroup.mem_sSup_of_directed_on | Mathlib.Algebra.Group.Subsemigroup.Membership | ∀ {M : Type u_2} [inst : Add M] {S : Set (AddSubsemigroup M)},
DirectedOn (fun x1 x2 => x1 ≤ x2) S → ∀ {x : M}, x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s | null | true |
ByteArray.data_mkEmpty | Batteries.Data.ByteArray | ∀ (cap : ℕ), (ByteArray.emptyWithCapacity cap).data = #[] | null | true |
String.Legacy.Iterator.prev | Init.Data.String.Iterator | String.Legacy.Iterator → String.Legacy.Iterator | Moves the iterator's position backward by one character, unconditionally.
The position is not changed if the iterator is at the beginning of the string.
| true |
Std.DTreeMap.valuesIter | Std.Data.DTreeMap.Iterator | {α β : Type u} → {cmp : α → α → Ordering} → Std.DTreeMap α (fun x => β) cmp → Std.Iter β | Returns a finite iterator over the values of a tree map.
The iterator yields the values in order and then terminates.
The key and value types must live in the same universe.
**Termination properties:**
* `Finite` instance: always
* `Productive` instance: always
| true |
_private.Mathlib.Algebra.ContinuedFractions.Translations.0.GenContFract.contsAux.match_3.eq_3 | Mathlib.Algebra.ContinuedFractions.Translations | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ.succ),
(match n.succ.succ with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ.succ => h_3 n) =
h_3 n | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.integral_1_div_log_sq_le._simp_1_10 | Mathlib.NumberTheory.Chebyshev | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Batteries.Tactic._aux_Batteries_Tactic_NoMatch___elabRules_Batteries_Tactic_funDot_1 | Batteries.Tactic.NoMatch | Lean.Elab.Term.TermElab | The syntax `fun.` has been deprecated in favor of `nofun`. | false |
groupCohomology.cocyclesMap_id_comp_assoc | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A B C : Rep.{u, u, u} k G} (φ : A ⟶ B) (ψ : B ⟶ C) (n : ℕ)
{Z : ModuleCat k} (h : groupCohomology.cocycles C n ⟶ Z),
CategoryTheory.CategoryStruct.comp
(groupCohomology.cocyclesMap (MonoidHom.id G) (CategoryTheory.CategoryStruct.comp φ ψ) n) h =
Cat... | null | true |
MeasureTheory.Egorov.iUnionNotConvergentSeq.eq_1 | Mathlib.MeasureTheory.Function.Egorov | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace α} [inst : PseudoEMetricSpace β]
{μ : MeasureTheory.Measure α} {s : Set α} {ε : ENNReal} {f : ι → α → β} {g : α → β} [inst_1 : SemilatticeSup ι]
[inst_2 : Nonempty ι] [inst_3 : Countable ι] (hε : 0 < ε) (hf : ∀ (n : ι), Measurable fun a => edist (f... | null | true |
«term_⊼_» | Mathlib.Data.Set.Sups | Lean.TrailingParserDescr | The point-wise infimum `a ⊓ b` of `a, b : α`. | true |
Multiset.le_add_sub | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, s ≤ t + (s - t) | null | true |
Real.convexOn_mul_log | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ConvexOn ℝ (Set.Ici 0) fun x => x * Real.log x | null | true |
ContMDiffWithinAt.contMDiffOn | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | If a function is `C^m` within a set at a point, for some finite `m`, then it is `C^m` within
this set on a neighborhood of the basepoint. | true |
Cardinal.le_mk_iff_exists_set | Mathlib.SetTheory.Cardinal.Order | ∀ {c : Cardinal.{u}} {α : Type u}, c ≤ Cardinal.mk α ↔ ∃ p, Cardinal.mk ↑p = c | null | true |
Std.ExtTreeSet.max_insert | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
(t.insert k).max ⋯ = t.max?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | null | true |
_private.Std.Data.String.ToNat.0.Nat.isNat_repr._proof_1_1 | Std.Data.String.ToNat | ¬0 < 10 → False | null | false |
ModuleCon.mk.inj | Mathlib.Algebra.Module.Congruence.Defs | ∀ {S : Type u_2} {M : Type u_3} {inst : Add M} {inst_1 : SMul S M} {toAddCon : AddCon M}
{smul : ∀ (s : S) {x y : M}, toAddCon.toSetoid x y → toAddCon.toSetoid (s • x) (s • y)} {toAddCon_1 : AddCon M}
{smul_1 : ∀ (s : S) {x y : M}, toAddCon_1.toSetoid x y → toAddCon_1.toSetoid (s • x) (s • y)},
{ toAddCon := toAd... | null | true |
NormedCommGroup.toENormedCommMonoid._proof_2 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_1} [inst : NormedCommGroup E] (x : E), ‖x‖ₑ = 0 ↔ x = 1 | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Ψ_even._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {m n : ℤ}, Even (m - n) = (Even m ↔ Even n) | null | false |
MvQPF.Pi.P | Mathlib.Data.QPF.Multivariate.Constructions.Sigma | {n : ℕ} → {A : Type u} → (F : A → TypeVec.{u} n → Type u) → [(α : A) → MvQPF (F α)] → MvPFunctor.{u} n | polynomial functor representation of a dependent product | true |
LieDerivation.toLinearMapLieHom._proof_4 | Mathlib.Algebra.Lie.Derivation.Basic | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L], IsScalarTower R R L | null | false |
Lean.Compiler.LCNF.Simp.Context.inlineStackOccs | Lean.Compiler.LCNF.Simp.SimpM | Lean.Compiler.LCNF.Simp.Context → Lean.PHashMap Lean.Name ℕ | Mapping from declaration names to number of occurrences at `inlineStack`
| true |
instAddCommGroupFreeAbelianGroup._proof_20 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ (α : Type u_1),
autoParam (∀ (n : ℕ) (a : FreeAbelianGroup α), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
Lean.Grind.NoopConfig.gen._inherited_default | Init.Grind.Config | ℕ | null | false |
Lean.Meta.SplitKind.ctorElimType | Lean.Meta.Tactic.SplitIf | {motive : Lean.Meta.SplitKind → Sort u} → ℕ → Sort (max 1 u) | null | false |
Multiset.mem_filter | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} {s : Multiset α}, a ∈ Multiset.filter p s ↔ a ∈ s ∧ p a | null | true |
Aesop.ExtractScriptM.run | Aesop.Tree.ExtractScript | {α : Type} → Aesop.ExtractScriptM α → Aesop.TreeM (Aesop.Script.UScript × Bool) | null | true |
Function.Injective.semigroup | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : Semigroup M₂] →
(f : M₁ → M₂) → Function.Injective f → (∀ (x y : M₁), f (x * y) = f x * f y) → Semigroup M₁ | A type endowed with `*` is a semigroup, if it admits an injective map that preserves `*` to
a semigroup. See note [reducible non-instances]. | true |
_private.Mathlib.Data.Int.Fib.Basic.0.Int.fib_add_natCast._proof_1_7 | Mathlib.Data.Int.Fib.Basic | ∀ (n : ℤ) (m : ℕ),
Int.fib (↑m - 1) * Int.fib n + Int.fib ↑m * Int.fib (n + 1) + Int.fib ↑m * Int.fib n +
Int.fib (↑m + 1) * Int.fib (n + 1) =
Int.fib (n - 1) * Int.fib ↑(m + 2) + Int.fib n * Int.fib (↑(m + 2) + 1) | null | false |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getBoolLit._sparseCasesOn_1 | Lean.Compiler.LCNF.Simp.ConstantFold | {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 |
CategoryTheory.Functor.mapMonFunctor._proof_7 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(D : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(X : CategoryTheory.LaxMonoidalFunctor C D),
{ app := fun A => CategoryTheory.Mon.Hom.mk' ((Catego... | null | false |
ContinuousAlternatingMap.coe_mk | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] (f : ContinuousMultilinearMap R (fun x => M) N)
(h : ∀ (v : ι → M) (i j : ... | null | true |
Set.Countable.sUnion_iff | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set (Set α)}, s.Countable → ((⋃₀ s).Countable ↔ ∀ a ∈ s, a.Countable) | null | true |
Lean.Lsp.TextEdit.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.TextEdit → Sort u} →
(t : Lean.Lsp.TextEdit) →
((range : Lean.Lsp.Range) →
(newText : String) →
(leanExtSnippet? : Option Lean.Lsp.SnippetString) →
(annotationId? : Option String) →
motive
{ range := range, newText := newText, leanExtS... | null | false |
Monotone.div_const | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Semifield α] [inst_1 : PartialOrder α] [PosMulReflectLT α] {β : Type u_3} [inst_3 : Preorder β]
{f : β → α}, Monotone f → ∀ {c : α}, 0 ≤ c → Monotone fun x => f x / c | null | true |
Lean.Server.FileWorker.AbsoluteLspSemanticToken.priority | Lean.Server.FileWorker.SemanticHighlighting | Lean.Server.FileWorker.AbsoluteLspSemanticToken → ℕ | In case of overlap, higher-priority tokens will take precedence | true |
_private.Mathlib.Topology.Bornology.Constructions.0.Bornology.isBounded_pi._simp_1_3 | Mathlib.Topology.Bornology.Constructions | ∀ {ι : Type u_1} {α : ι → Type u_2} {t : (i : ι) → Set (α i)}, (∀ (i : ι), (t i).Nonempty) = (Set.univ.pi t).Nonempty | null | false |
_private.Init.Data.Repr.0.List.repr._sparseCasesOn_1 | Init.Data.Repr | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
HasFDerivAtFilter.sub_const | 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} {L : Filter (E × E)} (c : F), HasFDerivAtFilter f f' L → HasFDerivAtFilter (fun x ... | **Alias** of the reverse direction of `hasFDerivAtFilter_sub_const_iff`. | true |
WeierstrassCurve.IsCharTwoJEqZeroNF.casesOn | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | {R : Type u_1} →
[inst : CommRing R] →
{W : WeierstrassCurve R} →
{motive : W.IsCharTwoJEqZeroNF → Sort u} →
(t : W.IsCharTwoJEqZeroNF) → ((a₁ : W.a₁ = 0) → (a₂ : W.a₂ = 0) → motive ⋯) → motive t | null | false |
GaloisInsertion.l_sInf_u_image | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : α → β} {u : β → α} [inst : CompleteLattice α] [inst_1 : CompleteLattice β]
(gi : GaloisInsertion l u) (s : Set β), l (sInf (u '' s)) = sInf s | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.realizeValue.match_9 | Lean.Meta.Basic | (motive : Except Lean.Exception ((String × Except Lean.Exception Dynamic) × Lean.Core.State) → Sort u_1) →
(res? : Except Lean.Exception ((String × Except Lean.Exception Dynamic) × Lean.Core.State)) →
((output : String) →
(res? : Except Lean.Exception Dynamic) → (st : Lean.Core.State) → motive (Except.ok ... | null | false |
CategoryTheory.Functor.leftExtensionEquivalenceOfIso₁_inverse_map_right | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_5, u_5} D]
{L L' : CategoryTheory.Functor C D} (iso₁ : L ≅ L') (F : CategoryTheory.Functor C H)
{Y X :
CategoryTheory.Comma (Categor... | null | true |
CentroidHom.starCenterIsoCentroid._proof_11 | Mathlib.Algebra.Star.CentroidHom | ∀ {α : Type u_1} [inst : NonAssocSemiring α] [inst_1 : StarRing α] (a : ↥(NonUnitalStarSubsemiring.center α)),
CentroidHom.starCenterToCentroid.toFun (star a) = star (CentroidHom.starCenterToCentroid.toFun a) | null | false |
iteratedDerivWithin_vcomp_three | Mathlib.Analysis.Calculus.IteratedDeriv.FaaDiBruno | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {g : E → F} {f : 𝕜 → E}
{s : Set 𝕜} {t : Set E} {x : 𝕜},
ContDiffWithinAt 𝕜 3 g t (f x) →
ContDiffWith... | null | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.updateCell.match_3.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β)
(motive : Std.DTreeMap.Internal.Impl.SizedBalancedTree α β (l.size - 1) (l.size + 1) → Sort u_3)
(newL : Std.DTreeMap.Internal.Impl α β) (h₁ : newL.Balanced) (h₂ : l.size - 1 ≤ newL.size)
(h₃ : newL.size ≤ l.size + 1)
(h_1 :
(newL : St... | null | true |
_private.Mathlib.Topology.Algebra.Group.TopologicalAbelianization.0.TopologicalAbelianization.commGroup._simp_5 | Mathlib.Topology.Algebra.Group.TopologicalAbelianization | ∀ {G : Type u_3} [inst : Group G] (a : G) (m n : ℤ), a ^ m * a ^ n = a ^ (m + n) | null | false |
NonarchimedeanGroup.cauchySeq_of_tendsto_div_nhds_one | Mathlib.Topology.Algebra.InfiniteSum.Nonarchimedean | ∀ {G : Type u_2} [inst : CommGroup G] [inst_1 : UniformSpace G] [IsUniformGroup G] [NonarchimedeanGroup G] {f : ℕ → G},
Filter.Tendsto (fun n => f (n + 1) / f n) Filter.atTop (nhds 1) → CauchySeq f | Let `G` be a nonarchimedean abelian group, and let `f : ℕ → G` be a function
such that the quotients `f (n + 1) / f n` tend to one. Then the function is a Cauchy sequence. | true |
IsLocalizedModule.isInteger_add | Mathlib.Algebra.Module.LocalizedModule.Int | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_3}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') {x y : M'},
IsLocalizedModule.IsInteger f x → IsLocalizedModule.IsInteger f y → IsLocalizedModule.IsInteger f (x + y) | null | true |
SetRel.id_subset_iff | Mathlib.Basic.Rel | ∀ {α : Type u_1} {R : SetRel α α}, SetRel.id ⊆ R ↔ R.IsRefl | null | true |
forall_self_imp | Init.PropLemmas | ∀ (P : Prop) (Q : P → Prop), (∀ (p : P), P → Q p) ↔ ∀ (p : P), Q p | null | true |
Std.DTreeMap.Internal.Impl.Tree.balanced_impl | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} {size : ℕ} (self : Std.DTreeMap.Internal.Impl.Tree α β size), self.impl.Balanced | The tree is balanced. | true |
CochainComplex.mappingConeHomOfDegreewiseSplitXIso.eq_1 | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ))
(σ : (n : ℤ) → (S.map (HomologicalComplex.eval C (ComplexShape.up ℤ) n)).Splitting)
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] (p q : ℤ) (hpq : p ... | null | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.Expr.denote_toPoly'_go._simp_1_10 | Init.Data.Int.Linear | ∀ (a b c : ℤ), a * (b * c) = a * b * c | null | false |
WithTop.untopD_natCast | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : NatCast α] (d : α) (n : ℕ), WithTop.untopD d ↑n = ↑n | null | true |
CategoryTheory.Limits.CoconeMorphism.hom_inv_id | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {c d : CategoryTheory.Limits.Cocone F} (f : c ≅ d),
CategoryTheory.CategoryStruct.comp f.hom.hom f.inv.hom = CategoryTheory.CategoryStruct.id c.pt | null | true |
GradedMonoid.smul_mk | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {α : Type u_3} {A : ι → Type u_2} [inst : (i : ι) → SMul α (A i)] {i : ι} (c : α) (a : A i),
c • GradedMonoid.mk i a = GradedMonoid.mk i (c • a) | null | true |
Prod.instInvolutiveInv | Mathlib.Algebra.Group.Prod | {M : Type u_3} → {N : Type u_4} → [InvolutiveInv M] → [InvolutiveInv N] → InvolutiveInv (M × N) | null | true |
Nat.one_le_cast._simp_1 | Mathlib.Data.Nat.Cast.Order.Basic | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{n : ℕ}, (1 ≤ ↑n) = (1 ≤ n) | null | false |
CategoryTheory.Bicategory.whisker_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [self : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g') (h : c ⟶ d),
CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerLeft f η) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator f g h).hom
(CategoryTheory.Ca... | null | true |
Mathlib.Meta.Positivity.int_div_nonneg_of_nonneg_of_pos | Mathlib.Tactic.Positivity.Basic | ∀ {a b : ℤ}, 0 ≤ a → 0 < b → 0 ≤ a / b | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.alterKey.match_1 | Std.Data.Internal.List.Associative | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → (Unit → motive none) → ((v : β) → motive (some v)) → motive x | null | false |
Group.instResiduallyFiniteOfFinite | Mathlib.GroupTheory.ResiduallyFinite | ∀ {G : Type u_1} [inst : Group G] [Finite G], Group.ResiduallyFinite G | null | true |
Lean.Meta.RefinedDiscrTree.Key.opaque | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Lean.Meta.RefinedDiscrTree.Key | An opaque variable. This key only matches with `Key.star`. | true |
RingEquiv.toSemilinearEquiv._proof_3 | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] (f : R ≃+* S), RingHomInvPair ↑f.symm ↑f | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Basic.0.MvPowerSeries.coeff_prod._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
_private.Lean.Meta.Sym.Simp.Theorems.0.Lean.Meta.Sym.Simp.isPermAux.match_1 | Lean.Meta.Sym.Simp.Theorems | (motive : Option ℕ → Sort u_1) → (x : Option ℕ) → (Unit → motive none) → ((pj' : ℕ) → motive (some pj')) → motive x | null | false |
List.forall_map_iff | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} {l : List α} {p : β → Prop} (f : α → β),
List.Forall p (List.map f l) ↔ List.Forall (p ∘ f) l | null | true |
Aesop.NormalizationState.isProvenByNormalization | Aesop.Tree.Data | Aesop.NormalizationState → Bool | null | true |
Measurable.measurableSet_preimage_iff_preimage_val | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {X : Type u_3} {Z : Type u_5} [inst : MeasurableSpace X] [StandardBorelSpace X] [inst_2 : MeasurableSpace Z]
{f : X → Z} [MeasurableSpace.CountablySeparated ↑(Set.range f)],
Measurable f → ∀ {s : Set Z}, MeasurableSet (f ⁻¹' s) ↔ MeasurableSet (Subtype.val ⁻¹' s) | If `f : X → Z` is a Borel measurable map from a standard Borel space to a
countably separated measurable space then the preimage of a set `s` is measurable
if and only if the set is measurable in `Set.range f`. | true |
CategoryTheory.Limits.createsColimitsOfSizeOfOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[CategoryTheory.CreatesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.op] →
CategoryTheory.CreatesColimitsOfSize.{w, w', v₁, ... | If `F.op : Cᵒᵖ ⥤ Dᵒᵖ` creates limits, then `F : C ⥤ D` creates colimits. | true |
Std.Async.System.GroupId.rec | Std.Async.System | {motive : Std.Async.System.GroupId → Sort u} →
((toNat : ℕ) → motive { toNat := toNat }) → (t : Std.Async.System.GroupId) → motive t | null | false |
SSet.Edge.InvStruct.ofEq | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | {X : SSet} →
{x₀ x₁ y₀ y₁ : X.obj (Opposite.op { len := 0 })} →
{hom : SSet.Edge x₀ x₁} → {hom' : SSet.Edge y₀ y₁} → hom.InvStruct → hom.edge = hom'.edge → hom'.InvStruct | Transports an inverse for `hom` along an equality of 1-simplices `hom = hom'`.
I.e. constructs an inverse for `hom'` from an inverse for `hom`. | true |
ProbabilityTheory.IdentDistrib.variance_eq | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} {f : α → ℝ} {g : β → ℝ},
ProbabilityTheory.IdentDistrib f g μ ν → ProbabilityTheory.variance f μ = ProbabilityTheory.variance g ν | null | true |
NormedAddGroupHom.Equalizer.liftEquiv._proof_3 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_3} {V₁ : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W} (φ : { φ // f.comp φ = g.comp φ }),
(fun ψ => ⟨(NormedAddGroupHom.Equalizer.ι f g).comp ψ, ⋯⟩) ((fun φ => NormedAddGroupHom.Equaliz... | null | false |
lt_tsub_iff_left | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} {a b c : α} [inst : LinearOrder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α],
a < b - c ↔ c + a < b | See `lt_tsub_iff_left_of_le` for a weaker statement in a partial order. | true |
Finset.mulDistribMulAction._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] [inst_1 : Monoid α] [inst_2 : Monoid β]
[inst_3 : MulDistribMulAction α β] (a : α) (s : Finset β), ↑(a • s) = a • ↑s | null | false |
Set.PairwiseDisjoint.subset_of_biUnion_subset_biUnion | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {ι : Type u_2} {f : ι → Set α} {s t : Set ι},
(s ∪ t).PairwiseDisjoint f → (∀ i ∈ s, (f i).Nonempty) → ⋃ i ∈ s, f i ⊆ ⋃ i ∈ t, f i → s ⊆ t | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.