name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.LawfulOrderMax.of_le_max._auto_1 | Init.Data.Order.Factories | Lean.Syntax | null | false |
Lean.Omega.IntList.gcd_dvd_dot_left | Init.Omega.IntList | ∀ (xs ys : Lean.Omega.IntList), ↑xs.gcd ∣ xs.dot ys | null | true |
Polynomial.revAt | Mathlib.Algebra.Polynomial.Reverse | ℕ → ℕ ↪ ℕ | If `i ≤ N`, then `revAt N i` returns `N - i`, otherwise it returns `i`.
Essentially, this embedding is only used for `i ≤ N`.
The advantage of `revAt N i` over `N - i` is that `revAt` is an involution.
| true |
PNat.mk_one | Mathlib.Data.PNat.Defs | ∀ {h : 0 < 1}, ⟨1, h⟩ = 1 | null | true |
CategoryTheory.WithInitial.coconeEquiv_inverse_obj_pt_hom | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
{X : C} {K : CategoryTheory.Functor J (CategoryTheory.Under X)}
(t : CategoryTheory.Limits.Cocone (CategoryTheory.WithInitial.liftFromUnder.obj K)),
(CategoryTheory.WithInitial.coconeEquiv.inverse... | null | true |
_private.Lean.Meta.InferType.0.Lean.Meta.isProp.match_1 | Lean.Meta.InferType | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → ((x : Lean.Expr) → motive x) → motive type | null | false |
MulEquiv.piCongrRight._proof_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {η : Type u_1} {Ms : η → Type u_2} {Ns : η → Type u_3} [inst : (j : η) → Mul (Ms j)] [inst_1 : (j : η) → Mul (Ns j)]
(es : (j : η) → Ms j ≃* Ns j),
Function.LeftInverse (Equiv.piCongrRight fun j => (es j).toEquiv).invFun
(Equiv.piCongrRight fun j => (es j).toEquiv).toFun | null | false |
Std.DHashMap.Raw.Const.isEmpty_insertMany_list | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {l : List (α × β)}, (Std.DHashMap.Raw.Const.insertMany m l).isEmpty = (m.isEmpty && l.isEmpty) | null | true |
Aesop.RegularRule.instToFormat | Aesop.Rule | Std.ToFormat Aesop.RegularRule | null | true |
Subsemigroup.inclusion.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] {S T : Subsemigroup M} (h : S ≤ T),
Subsemigroup.inclusion h = (MulMemClass.subtype S).codRestrict T ⋯ | null | true |
_private.Mathlib.Probability.Distributions.SetBernoulli.0.ProbabilityTheory.setBernoulli_empty._proof_1_1 | Mathlib.Probability.Distributions.SetBernoulli | ∀ {ι : Type u_1} {p : ↑unitInterval} (s : Set (Set ι)), ∅ ∈ s → {t | t ∈ s ∧ t ⊆ ∅} = {∅} | null | false |
Fintype.eq_of_subsingleton_of_prod_eq | Mathlib.Data.Fintype.BigOperators | ∀ {M : Type u_4} [inst : CommMonoid M] {ι : Type u_5} [Subsingleton ι] {s : Finset ι} {f : ι → M} {b : M},
∏ i ∈ s, f i = b → ∀ i ∈ s, f i = b | If a product of a `Finset` of a subsingleton type has a given
value, so do the terms in that product. | true |
PiNat.exists_disjoint_cylinder | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} [inst : (n : ℕ) → TopologicalSpace (E n)] [∀ (n : ℕ), DiscreteTopology (E n)]
{s : Set ((n : ℕ) → E n)}, IsClosed s → ∀ {x : (n : ℕ) → E n}, x ∉ s → ∃ n, Disjoint s (PiNat.cylinder x n) | null | true |
Subalgebra.rTensorBot._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Subalgebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S]
(A : Subalgebra R S), IsScalarTower R R ↥A | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_filter_key_eq_length_iff._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, ((List.filter p l).length = l.length) = ∀ a ∈ l, p a = true | null | false |
_private.Init.Data.List.Monadic.0.List.mapM'.match_1.eq_1 | Init.Data.List.Monadic | ∀ {α : Type u_1} (motive : List α → Sort u_2) (h_1 : Unit → motive []) (h_2 : (a : α) → (l : List α) → motive (a :: l)),
(match [] with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_1 () | null | true |
SimpleGraph.Walk.edgeSet_copy | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v u' v' : V} (p : G.Walk u v) (hu : u = u') (hv : v = v'),
(p.copy hu hv).edgeSet = p.edgeSet | null | true |
Lean.Core.State.nextMacroScope | Lean.CoreM | Lean.Core.State → Lean.MacroScope | Next macro scope. We use macro scopes to avoid accidental name capture. | true |
ZNum.cmp._sparseCasesOn_2 | Mathlib.Data.Num.Basic | {motive : ZNum → Sort u} →
(t : ZNum) →
((a : PosNum) → motive (ZNum.neg a)) →
((a : PosNum) → motive (ZNum.pos a)) → (Nat.hasNotBit 6 t.ctorIdx → motive t) → motive t | null | false |
KaehlerDifferential.DLinearMap._proof_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
IsScalarTower R (TensorProduct R S S) (TensorProduct R S S) | null | false |
sbtw_pointReflection_of_ne | Mathlib.Analysis.Convex.Between | ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] {x y : P},
x ≠ y → Sbtw R y x ((AffineEquiv.pointReflection R x) y) | null | true |
Nat.cast_pow_eq_one | Mathlib.Algebra.Ring.CharZero | ∀ {R : Type u_2} {n : ℕ} [inst : Semiring R] [CharZero R] {a : ℕ}, n ≠ 0 → (↑a ^ n = 1 ↔ a = 1) | null | true |
_private.Mathlib.GroupTheory.Perm.Fin.0.Fin.cycleRange_of_le._proof_1_7 | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} {i j : Fin n}, i ≤ j → ¬i = j → i < j | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.ConnectedComponent.walk_toSimpleGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p ≍ p | null | false |
CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.mkLawfulDayConvolutionMonoidalCategoryStruct._proof_3 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ (C : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} C] (V : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (D : Type u_2) [inst_4 : CategoryTheory.Category.{u_1, u_2} D]
[inst_5 : CategoryTheory.MonoidalCa... | null | false |
Filter.EventuallyLE.mul_le_mul | Mathlib.Order.Filter.Ring | ∀ {α : Type u} {β : Type v} [inst : MulZeroClass β] [inst_1 : Preorder β] [PosMulMono β] [MulPosMono β] {l : Filter α}
{f₁ f₂ g₁ g₂ : α → β}, f₁ ≤ᶠ[l] f₂ → g₁ ≤ᶠ[l] g₂ → 0 ≤ᶠ[l] g₁ → 0 ≤ᶠ[l] f₂ → f₁ * g₁ ≤ᶠ[l] f₂ * g₂ | null | true |
Lean.Meta.Grind.Goal.getENode? | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Goal → Lean.Expr → Option Lean.Meta.Grind.ENode | Returns `some n` if `e` has already been "internalized" into the
Otherwise, returns `none`s.
| true |
UniqueFactorizationMonoid.primeFactors.eq_1 | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
(a : M), UniqueFactorizationMonoid.primeFactors a = (UniqueFactorizationMonoid.normalizedFactors a).toFinset | null | true |
Pi.single_apply_addCommute | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} [inst : DecidableEq I] [inst_1 : (i : I) → AddZeroClass (f i)] (x : (i : I) → f i)
(i j : I), AddCommute (Pi.single i (x i)) (Pi.single j (x j)) | The injection into an additive pi group with the same values commutes. | true |
List.filterMap_eq_map_iff_forall_eq_some | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} {f : α → Option β} {g : α → β} {l : List α},
List.filterMap f l = List.map g l ↔ ∀ x ∈ l, f x = some (g x) | null | true |
Invertible.mulLeft_symm_apply | Mathlib.Algebra.Group.Invertible.Basic | ∀ {α : Type u} [inst : Monoid α] {a : α} (x : Invertible a) (b : α) (x_1 : Invertible (a * b)),
(x.mulLeft b).symm x_1 = invertibleOfInvertibleMul a b | null | true |
HomologicalComplex.HomologySequence.snakeInput._proof_19 | Mathlib.Algebra.Homology.HomologySequence | 0 < 3 + 1 | null | false |
Lean.AxiomVal.mk | Lean.Declaration | Lean.ConstantVal → Bool → Lean.AxiomVal | null | true |
MeasureTheory.OuterMeasure.le_smul_caratheodory | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u_1} (a : ENNReal) (m : MeasureTheory.OuterMeasure α), m.caratheodory ≤ (a • m).caratheodory | null | true |
HomotopicalAlgebra.CofibrantObject.HoCat.bifibrantResolution'._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
{X₁ X₂ X₃ : HomotopicalAlgebra.CofibrantObject C} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃),
CategoryTheory.CategoryStruct.comp (HomotopicalAlgebra.CofibrantObject.toHoCat.map X₁.iBifibrantResolutionObj)
(Homotopica... | null | false |
Besicovitch.SatelliteConfig.centerAndRescale._proof_7 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {N : ℕ} {τ : ℝ}
(a : Besicovitch.SatelliteConfig E N τ),
∀ i < Fin.last N,
dist ((a.r (Fin.last N))⁻¹ • (a.c i - a.c (Fin.last N)))
((a.r (Fin.last N))⁻¹ • (a.c (Fin.last N) - a.c (Fin.last N))) ≤
(a.r (Fin.last N))⁻¹ * a.r ... | null | false |
SimpleGraph.two_mul_card_edgeFinset | Mathlib.Combinatorics.SimpleGraph.DegreeSum | ∀ {V : Type u} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj],
2 * G.edgeFinset.card =
{x |
match x with
| (x, y) => G.Adj x y}.card | null | true |
FunLike.subNegZeroMonoid._proof_3 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : Neg F] [inst_2 : SubNegZeroMonoid β]
[IsNegApply F α β] (f : F), ⇑(-f) = -⇑f | null | false |
FiniteDimensional.range_orthonormalBasisSingleton | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : Unique ι] (h : Module.finrank 𝕜 E = 1) {v : E}
(hv : ‖v‖ = 1), Set.range ⇑(FiniteDimensional.orthonormalBasisSingleton ι 𝕜 h v hv) = {v} | null | true |
Aesop.GoalOrigin.droppedMVar | Aesop.Tree.Data | Aesop.GoalOrigin | null | true |
Module.Baer.ExtensionOfMaxAdjoin.extendIdealTo | Mathlib.Algebra.Module.Injective | {R : Type u} →
[inst : Ring R] →
{Q : Type v} →
[inst_1 : AddCommGroup Q] →
[inst_2 : Module R Q] →
{M : Type u_1} →
{N : Type u_2} →
[inst_3 : AddCommGroup M] →
[inst_4 : AddCommGroup N] →
[inst_5 : Module R M] →
... | Since we assumed `Q` being Baer, the linear map `x ↦ f' (x • y) : I ⟶ Q` extends to `R ⟶ Q`,
call this extended map `φ` | true |
Ideal.normalizationMonoid | Mathlib.RingTheory.DedekindDomain.Ideal.Basic | {A : Type u_2} → [inst : CommRing A] → StrongNormalizationMonoid (Ideal A) | **Alias** of `Ideal.strongNormalizationMonoid`. | true |
Std.toList_roi_eq_toList_rci_of_isSome_succ? | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.Rxi.IsAlwaysFinite α] {lo : α} (h : (Std.PRange.succ? lo).isSome = true),
lo<...*.toList = (Std.PRange.succ? lo).get h...*.toList | null | true |
Aesop.instDecidableRelPremiseIndexLe | Aesop.Forward.PremiseIndex | DecidableRel fun x1 x2 => x1 ≤ x2 | null | true |
Polynomial.coeff_det_X_add_C_zero | Mathlib.LinearAlgebra.Matrix.Polynomial | ∀ {n : Type u_1} {α : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A B : Matrix n n α),
(Polynomial.X • A.map ⇑Polynomial.C + B.map ⇑Polynomial.C).det.coeff 0 = B.det | null | true |
CategoryTheory.ShortComplex.ShortExact.singleδ._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex C},
S.ShortExact → (S.map (HomologicalComplex.single C (ComplexShape.up ℤ) 0)).ShortExact | null | false |
Stream'.WSeq.drop.match_1 | Mathlib.Data.WSeq.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey_eq_minKey!._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Lean.Meta.synthAppInstances | Lean.Meta.Tactic.Apply | Lean.Name → Lean.MVarId → Array Lean.Expr → Array Lean.BinderInfo → Bool → Bool → Lean.MetaM Unit | null | true |
Finset.coe_vadd._simp_1 | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : VAdd α β] (s : Finset α) (t : Finset β),
↑s +ᵥ ↑t = ↑(s +ᵥ t) | null | false |
ProofWidgets.InteractiveCode | ProofWidgets.Component.Basic | ProofWidgets.Component ProofWidgets.InteractiveCodeProps | Present pretty-printed code as interactive text.
The most common use case is to instantiate this component from a `Lean.Expr`. To do so, you must
eagerly pretty-print the `Expr` using `Widget.ppExprTagged`. See also `InteractiveExpr`. | true |
RBTree.RBNode.setRed.eq_2 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1}, RBTree.RBNode.nil.setRed = RBTree.RBNode.nil | null | true |
USize.neg_inj | Init.Data.UInt.Lemmas | ∀ {a b : USize}, -a = -b ↔ a = b | null | true |
Matrix.toLinearEquiv._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M], SMulCommClass R R M | null | false |
le_ciInf_exists | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] {p : ι → Prop} {f : Exists p → α},
⨅ i, ⨅ (h : p i), f ⋯ ≤ ⨅ (ih : Exists p), f ih | null | true |
gal_C_isSolvable | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} [inst : Field F] (x : F), Group.IsSolvable (Polynomial.C x).Gal | null | true |
CategoryTheory.PullbackShift.natTrans.eq_1 | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] [inst_3 : CategoryTheory.HasShift C B] (φ : A →+ B) {D : Type u_4}
[inst_4 : CategoryTheory.Category.{v_2, u_4} D] [inst_5 : CategoryTheory.HasShift D B]
{F G : CategoryTheory... | null | true |
PowerSeries.IsWeierstrassDivisionAt.rec | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | {A : Type u_1} →
[inst : CommRing A] →
{f g q : PowerSeries A} →
{r : Polynomial A} →
{I : Ideal A} →
{motive : f.IsWeierstrassDivisionAt g q r I → Sort u} →
((degree_lt : r.degree < ↑((PowerSeries.map (Ideal.Quotient.mk I)) g).order.toNat) →
(eq_mul_add : f = g... | null | false |
codisjoint_ofDual_iff._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a b : αᵒᵈ},
Codisjoint (OrderDual.ofDual a) (OrderDual.ofDual b) = Disjoint a b | null | false |
ArchimedeanClass.instAddCommMonoid._private_5 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] (x : ArchimedeanClass R),
x + 0 = x | null | false |
Lean.Lsp.LeanClientCapabilities.mk.inj | Lean.Data.Lsp.Capabilities | ∀ {incrementalDiagnosticSupport? silentDiagnosticSupport? : Option Bool}
{rpcWireFormat? : Option Lean.Lsp.RpcWireFormat}
{incrementalDiagnosticSupport?_1 silentDiagnosticSupport?_1 : Option Bool}
{rpcWireFormat?_1 : Option Lean.Lsp.RpcWireFormat},
{ incrementalDiagnosticSupport? := incrementalDiagnosticSupport... | null | true |
Lean.Elab.Do.InferControlInfo.ofElem | Lean.Elab.Do.InferControlInfo | Lean.DoElem → Lean.Elab.TermElabM Lean.Elab.Do.ControlInfo | null | true |
IntervalIntegrable.continuousOn_smul | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} [inst : NormedAddCommGroup E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ} {f : ℝ → 𝕜}
{g : ℝ → E} [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 E] [IsBoundedSMul 𝕜 E],
IntervalIntegrable g μ a b → ContinuousOn f (Set.uIcc a b) → IntervalIntegrable (fun x => f x • g x) μ a b | null | true |
CategoryTheory.IsGroupoid.casesOn | Mathlib.CategoryTheory.Groupoid | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.IsGroupoid C → Sort u_1} →
(t : CategoryTheory.IsGroupoid C) →
((all_isIso : ∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.IsIso f) → motive ⋯) → motive t | null | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplex.0.CochainComplex.HomComplex.Cochain.δ_single._proof_1_5 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {p : ℤ} (p'' : ℤ), p'' + 1 = p → p = p'' + 1 | null | false |
continuousOn_pi' | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} [inst : TopologicalSpace α] {ι : Type u_5} {X : ι → Type u_6}
[inst_1 : (i : ι) → TopologicalSpace (X i)] {f : α → (i : ι) → X i} {s : Set α},
(∀ (i : ι), ContinuousOn (fun y => f y i) s) → ContinuousOn f s | null | true |
Mathlib.Meta.FunProp.instReprLambdaTheoremArgs.repr | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheoremArgs → ℕ → Std.Format | null | true |
IsApproximateAddSubgroup.image | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {A : Set G} {K : ℝ} {F : Type u_2} {H : Type u_3} [inst_1 : AddGroup H]
[inst_2 : FunLike F G H] [AddMonoidHomClass F G H] (f : F),
IsApproximateAddSubgroup K A → IsApproximateAddSubgroup K (⇑f '' A) | null | true |
Std.DTreeMap.Internal.Impl.getKey_maxKey! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α],
t.WF → ∀ {he : Std.DTreeMap.Internal.Impl.contains t.maxKey! t = true}, t.getKey t.maxKey! he = t.maxKey! | null | true |
USize.toBitVec_add | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a + b).toBitVec = a.toBitVec + b.toBitVec | null | true |
CategoryTheory.instMonoidalSkeletonInverseSkeletonEquivalence._proof_16 | Mathlib.CategoryTheory.Monoidal.Skeleton | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C],
autoParam
(∀ (X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.instMonoidalSkeletonInverseSkeletonEquivalence._aux_12
(CategoryTheory.MonoidalCategoryStruct.tensor... | null | false |
CategoryTheory.Limits.colimitCoconeOfCoequalizerAndCoproduct._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_3} [inst_1 : CategoryTheory.SmallCategory J]
(F : CategoryTheory.Functor J C) [inst_2 : CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor F.obj)]
[inst_3 : CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor fun... | null | false |
Std.Time.Week.Offset.toSeconds | Std.Time.Date.Unit.Week | Std.Time.Week.Offset → Std.Time.Second.Offset | Convert `Week.Offset` into `Second.Offset`.
| true |
SymbolicDynamics.FullShift.mulFullShift | Mathlib.Dynamics.SymbolicDynamics.Basic | (A : Type u_1) →
(G : Type u_2) → [inst : TopologicalSpace A] → [inst_1 : Monoid G] → SymbolicDynamics.FullShift.MulSubshift A G | Example: the **full shift** on alphabet `A` over the multiplicative monoid `G`.
It is the subshift whose underlying set is the set of all configurations
`G → A`. | true |
Int.addLeft_one_isCycle | Mathlib.GroupTheory.Perm.Cycle.Basic | (Equiv.addLeft 1).IsCycle | null | true |
Quiver.Path.nil_ne_cons | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b : V} (p : Quiver.Path a b) (e : b ⟶ a), Quiver.Path.nil ≠ p.cons e | null | true |
_private.Mathlib.Analysis.Analytic.Basic.0.hasFPowerSeriesAt_iff._simp_1_9 | Mathlib.Analysis.Analytic.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CompleteLinearOrder.himp_bot | Mathlib.Order.CompleteLattice.Defs | ∀ {α : Type u_4} [self : CompleteLinearOrder α] (a : α), a ⇨ ⊥ = aᶜ | `aᶜ` is defined as `a ⇨ ⊥` | true |
NonemptyFinLinOrd.dual._proof_1 | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ (X : NonemptyFinLinOrd),
NonemptyFinLinOrd.ofHom (OrderHom.dual (LinOrd.Hom.hom (CategoryTheory.CategoryStruct.id X).hom)) =
CategoryTheory.CategoryStruct.id ↧(↑X.toLinOrd)ᵒᵈ | null | false |
Convert.elabCheapConfig | Mathlib.Tactic.Convert | Lean.Syntax → optParam Convert.CheapConfig { } → optParam Bool true → Lean.Elab.Tactic.TacticM Convert.CheapConfig | Internal elaborator for `Convert.CheapConfig`: use `Convert.elabConfig` instead. | true |
NFA.evalFrom_iUnion | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} (M : NFA α σ) {ι : Sort u_1} (s : ι → Set σ) (x : List α),
M.evalFrom (⋃ i, s i) x = ⋃ i, M.evalFrom (s i) x | null | true |
PresentedAddMonoid.lift.eq_1 | Mathlib.Algebra.PresentedMonoid.Basic | ∀ {α : Type u_3} {M : Type u_4} [inst : AddMonoid M] (f : α → M) {rels : FreeAddMonoid α → FreeAddMonoid α → Prop}
(h : ∀ (a b : FreeAddMonoid α), rels a b → (FreeAddMonoid.lift f) a = (FreeAddMonoid.lift f) b),
PresentedAddMonoid.lift f h = (addConGen rels).lift (FreeAddMonoid.lift f) ⋯ | null | true |
Submodule.sInf_orthogonal | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(s : Set (Submodule 𝕜 E)), ⨅ K ∈ s, Kᗮ = (sSup s)ᗮ | The inf of a set of orthogonal subspaces equals the subspace orthogonal to the sup. | true |
USize.instIsAlwaysFinite_1 | Init.Data.Range.Polymorphic.UInt | Std.Rxo.IsAlwaysFinite USize | null | true |
CategoryTheory.Functor.IsRepresentedBy.representableBy_homEquiv_apply | Mathlib.CategoryTheory.RepresentedBy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
{x : F.obj (Opposite.op X)} (h : F.IsRepresentedBy x) {Y : C} (f : Y ⟶ X),
h.representableBy.homEquiv f = (CategoryTheory.ConcreteCategory.hom (F.map f.op)) x | null | true |
_private.Mathlib.LinearAlgebra.QuadraticForm.Dual.0.LinearMap.BilinForm.linearIndependent_of_pairwise_le_zero._proof_1_3 | Mathlib.LinearAlgebra.QuadraticForm.Dual | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : LinearOrder R] (s : Finset ι) (c : ι → R),
{i ∈ s | 0 < c i} ∪ {i ∈ s | 0 < -c i} ⊆ s | null | false |
Bialgebra.TensorProduct.rid_tmul | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Bialgebra S A] [inst_4 : Algebra R A] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R S A] (r : R) (a : A),
(Bialgebra.TensorProduct.rid R S A) (a ⊗ₜ[R] r) = r • a | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.erase_dup.noConfusion | Lean.Meta.Tactic.Grind.AC.Types | {P : Sort u} →
{c c' : Lean.Meta.Grind.AC.EqCnstr} →
Lean.Meta.Grind.AC.EqCnstrProof.erase_dup c = Lean.Meta.Grind.AC.EqCnstrProof.erase_dup c' → (c = c' → P) → P | null | false |
MonomialOrder.le_withBotDegree | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {f : MvPolynomial σ R} {d : σ →₀ ℕ},
d ∈ f.support → m.toWithBotSyn ↑d ≤ m.toWithBotSyn (m.withBotDegree f) | null | true |
AddSubgroup.coe_add._simp_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) (x y : ↥H), ↑x + ↑y = ↑(x + y) | null | false |
Units.exists0 | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {p : G₀ˣ → Prop}, (∃ g, p g) ↔ ∃ g, ∃ (hg : g ≠ 0), p (Units.mk0 g hg) | In a group with zero, an existential over a unit can be rewritten in terms of `Units.mk0`. | true |
ByteArray.validateUTF8_eq_true_iff._simp_1 | Init.Data.String.Basic | ∀ {b : ByteArray}, (b.validateUTF8 = true) = b.IsValidUTF8 | null | false |
Std.IterM.toIter | Init.Data.Iterators.Basic | {α β : Type w} → Std.IterM Id β → Std.Iter β | Converts a monadic iterator (`IterM Id β`) over `Id` into a pure iterator (`Iter β`).
| true |
Submonoid.coe_equivMapOfInjective_apply | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {N : Type u_2} [inst : MulOneClass N] {M : Type u_5} [inst_1 : MulOneClass M] (S : Submonoid M) (f : M →* N)
(hf : Function.Injective ⇑f) (x : ↥S), ↑((S.equivMapOfInjective f hf) x) = f ↑x | null | true |
Measurable.untopD | Mathlib.MeasureTheory.Constructions.BorelSpace.WithTop | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι]
[inst_3 : MeasurableSpace ι] [BorelSpace ι] {α : Type u_2} {mα : MeasurableSpace α} (d : ι) {f : α → WithTop ι},
Measurable f → Measurable fun x => WithTop.untopD d (f x) | null | true |
UniformSpace.Completion.instNormedRing._proof_9 | Mathlib.Analysis.Normed.Module.Completion | ∀ (A : Type u_1) [inst : SeminormedRing A], ↑0 = 0 | null | false |
Lean.Elab.Term.SyntheticMVarKind.typeClass.noConfusion | Lean.Elab.Term.TermElabM | {P : Sort u} →
{extraErrorMsg? extraErrorMsg?' : Option Lean.MessageData} →
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg? =
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg?' →
(extraErrorMsg? = extraErrorMsg?' → P) → P | null | false |
SheafOfModules.overMapUnitIso_inv_val_app_hom_apply | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | ∀ {D : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} D] {K : CategoryTheory.GrothendieckTopology D}
{R : CategoryTheory.Sheaf K RingCat} {X Y : D} (f : X ⟶ Y) (x : (CategoryTheory.Over X)ᵒᵖ)
(x_1 : ↑(((SheafOfModules.overMap R f).obj (SheafOfModules.unit (R.over Y))).val.obj x)),
(ModuleCat.Hom.hom ((SheafOfM... | null | true |
add_left_surjective | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] (a : G), Function.Surjective fun x => a + x | null | true |
CategoryTheory.ObjectProperty.IsClosedUnderFiniteLimits.instHasFiniteLimitsFullSubcategory | Mathlib.CategoryTheory.ObjectProperty.FiniteLimits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderFiniteLimits] [CategoryTheory.Limits.HasFiniteLimits C],
CategoryTheory.Limits.HasFiniteLimits P.FullSubcategory | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.