name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
PSigma.Lex.le | Mathlib.Data.PSigma.Order | {ι : Type u_1} → {α : ι → Type u_2} → [LT ι] → [(i : ι) → LE (α i)] → LE (Σₗ' (i : ι), α i) |
CategoryTheory.endofunctorMonoidalCategory_associator_hom_app | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (F G H : CategoryTheory.Functor C C) (X : C),
(CategoryTheory.MonoidalCategoryStruct.associator F G H).hom.app X =
CategoryTheory.CategoryStruct.id
((CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj F G) H).obj X) |
zero_zpow | Mathlib.Algebra.GroupWithZero.Basic | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] (n : ℤ), n ≠ 0 → 0 ^ n = 0 |
ContinuousWithinAt.vsub | Mathlib.Topology.Algebra.Group.AddTorsor | ∀ {V : Type u_1} {P : Type u_2} {α : Type u_3} [inst : AddGroup V] [inst_1 : TopologicalSpace V]
[inst_2 : AddTorsor V P] [inst_3 : TopologicalSpace P] [IsTopologicalAddTorsor P] [inst_5 : TopologicalSpace α]
{f g : α → P} {x : α} {s : Set α},
ContinuousWithinAt f s x → ContinuousWithinAt g s x → ContinuousWithinAt (fun x => f x -ᵥ g x) s x |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.trapezoidal_error_le_of_lt._simp_1_8 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
IsLocalization.mk'_self | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_2) [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {x : R} (hx : x ∈ M), IsLocalization.mk' S x ⟨x, hx⟩ = 1 |
CategoryTheory.GlueData.f_hasPullback | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData C) (i j k : self.J),
CategoryTheory.Limits.HasPullback (self.f i j) (self.f i k) |
lowerCentralSeries_length_eq_nilpotencyClass | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [hG : Group.IsNilpotent G], Nat.find ⋯ = Group.nilpotencyClass G |
_private.Mathlib.Topology.MetricSpace.Ultra.Basic.0.IsUltrametricDist.isOpen_closedBall._simp_1_2 | Mathlib.Topology.MetricSpace.Ultra.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, (Metric.ball x ε ⊆ Metric.closedBall x ε) = True |
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.instDecidableEqSystemUser.decEq.match_1 | Std.Internal.Async.System | (motive : Std.Internal.IO.Async.System.SystemUser → Std.Internal.IO.Async.System.SystemUser → Sort u_1) →
(x x_1 : Std.Internal.IO.Async.System.SystemUser) →
((a : String) →
(a_1 : Option Std.Internal.IO.Async.System.UserId) →
(a_2 : Option Std.Internal.IO.Async.System.GroupId) →
(a_3 : Option String) →
(a_4 : Option System.FilePath) →
(b : String) →
(b_1 : Option Std.Internal.IO.Async.System.UserId) →
(b_2 : Option Std.Internal.IO.Async.System.GroupId) →
(b_3 : Option String) →
(b_4 : Option System.FilePath) →
motive { username := a, userId := a_1, groupId := a_2, shell := a_3, homeDir := a_4 }
{ username := b, userId := b_1, groupId := b_2, shell := b_3, homeDir := b_4 }) →
motive x x_1 |
Std.Ric.Sliceable.mkSlice | Init.Data.Slice.Notation | {α : Type u} → {β : outParam (Type v)} → {γ : outParam (Type w)} → [self : Std.Ric.Sliceable α β γ] → α → Std.Ric β → γ |
Std.LawfulOrderLeftLeaningMax | Init.Data.Order.Classes | (α : Type u) → [Max α] → [LE α] → Prop |
_private.Mathlib.Topology.DiscreteSubset.0.isDiscrete_of_codiscreteWithin._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u_1} {f : Filter α} {s : Set α}, (f ⊓ Filter.principal sᶜ = ⊥) = (s ∈ f) |
Mathlib.Tactic._aux_Mathlib_Tactic_Cases___elabRules_Mathlib_Tactic_induction'_1 | Mathlib.Tactic.Cases | Lean.Elab.Tactic.Tactic |
CategoryTheory.ComposableArrows.Precomp.map_zero_one' | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C}
(f : X ⟶ F.left), CategoryTheory.ComposableArrows.Precomp.map F f 0 ⟨0 + 1, ⋯⟩ ⋯ = f |
NonUnitalSeminormedCommRing.mk | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
[toNonUnitalSeminormedRing : NonUnitalSeminormedRing α] → (∀ (a b : α), a * b = b * a) → NonUnitalSeminormedCommRing α |
_private.Mathlib.Control.Fix.0.Part.Fix.approx.match_1.eq_2 | Mathlib.Control.Fix | ∀ (motive : ℕ → Sort u_1) (i : ℕ) (h_1 : Unit → motive 0) (h_2 : (i : ℕ) → motive i.succ),
(match i.succ with
| 0 => h_1 ()
| i.succ => h_2 i) =
h_2 i |
card_vector | Mathlib.Data.Fintype.BigOperators | ∀ {α : Type u_1} [inst : Fintype α] (n : ℕ), Fintype.card (List.Vector α n) = Fintype.card α ^ n |
intervalIntegral.measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_ge' | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {ι : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {c : E}
{l l' : Filter ℝ} {lt : Filter ι} {μ : MeasureTheory.Measure ℝ} {u v : ι → ℝ} [CompleteSpace E]
[l'.IsMeasurablyGenerated] [Filter.TendstoIxxClass Set.Ioc l l'],
StronglyMeasurableAtFilter f l' μ →
Filter.Tendsto f (l' ⊓ MeasureTheory.ae μ) (nhds c) →
μ.FiniteAtFilter l' →
Filter.Tendsto u lt l →
Filter.Tendsto v lt l →
v ≤ᶠ[lt] u →
(fun t => ∫ (x : ℝ) in u t..v t, f x ∂μ + μ.real (Set.Ioc (v t) (u t)) • c) =o[lt] fun t =>
μ.real (Set.Ioc (v t) (u t)) |
PowerBasis.ofAdjoinEqTop'.congr_simp | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : Algebra R S]
[inst_4 : IsIntegrallyClosed R] [inst_5 : IsDomain S] [inst_6 : Module.IsTorsionFree R S] {x x_1 : S} (e_x : x = x_1)
(hx : IsIntegral R x) (hx' : Algebra.adjoin R {x} = ⊤),
PowerBasis.ofAdjoinEqTop' hx hx' = PowerBasis.ofAdjoinEqTop' ⋯ ⋯ |
AddSubgroup.one_le_sum_inv_index_of_leftCoset_cover | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_2} {H : ι → AddSubgroup G} {g : ι → G} {s : Finset ι},
⋃ i ∈ s, g i +ᵥ ↑(H i) = Set.univ → 1 ≤ ∑ i ∈ s, (↑(H i).index)⁻¹ |
CategoryTheory.Comon.tensorObj_comul | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A B : C) [inst_3 : CategoryTheory.ComonObj A]
[inst_4 : CategoryTheory.ComonObj B],
CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.ComonObj.comul CategoryTheory.ComonObj.comul)
(CategoryTheory.MonoidalCategory.tensorμ A A B B) |
Lean.FromJson.mk.noConfusion | Lean.Data.Json.FromToJson.Basic | {α : Type u} →
{P : Sort u_1} →
{fromJson? fromJson?' : Lean.Json → Except String α} →
{ fromJson? := fromJson? } = { fromJson? := fromJson?' } → (fromJson? ≍ fromJson?' → P) → P |
_private.Std.Sat.AIG.CachedLemmas.0.Std.Sat.AIG.mkGateCached.go.match_1.splitter | Std.Sat.AIG.CachedLemmas | (motive : Option Bool → Option Bool → Sort u_1) →
(lhsVal rhsVal : Option Bool) →
((x : Option Bool) → motive (some false) x) →
((x : Option Bool) → (x = some false → False) → motive x (some false)) →
((x : Option Bool) → (x = some false → False) → motive (some true) x) →
((x : Option Bool) → (x = some false → False) → (x = some true → False) → motive x (some true)) →
((x x_1 : Option Bool) →
(x = some false → False) →
(x_1 = some false → False) → (x = some true → False) → (x_1 = some true → False) → motive x x_1) →
motive lhsVal rhsVal |
_private.Init.Data.String.Pattern.Char.0.String.Slice.Pattern.Char.instStrictForwardPatternChar._simp_1 | Init.Data.String.Pattern.Char | ∀ {α : Type u_1} {a : α} {p : Prop} {x : Decidable p} {b : Option α},
((if p then b else none) = some a) = (p ∧ b = some a) |
SimplexCategory.factorThruImage_eq | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ CategoryTheory.Limits.image φ} [CategoryTheory.Epi e]
{i : CategoryTheory.Limits.image φ ⟶ Δ''} [CategoryTheory.Mono i],
CategoryTheory.CategoryStruct.comp e i = φ → CategoryTheory.Limits.factorThruImage φ = e |
_private.Mathlib.LinearAlgebra.Span.Defs.0.Submodule.mem_span_pair._simp_1_3 | Mathlib.LinearAlgebra.Span.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : β → Prop}, (∃ b, (∃ a, f a = b) ∧ p b) = ∃ a, p (f a) |
Rat.intCast_div_eq_divInt | Mathlib.Data.Rat.Defs | ∀ (n d : ℤ), ↑n / ↑d = Rat.divInt n d |
Module.End.isSemisimple_iff' | Mathlib.LinearAlgebra.Semisimple | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{f : Module.End R M}, f.IsSemisimple ↔ ∀ (p : ↥f.invtSubmodule), ∃ q, IsCompl p q |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.sum_density_div_card_le_density_add_eps._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
CategoryTheory.MonoidalOpposite.mopMopEquivalence.eq_1 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.MonoidalOpposite.mopMopEquivalence C =
(CategoryTheory.MonoidalOpposite.unmopEquiv Cᴹᵒᵖ).trans (CategoryTheory.MonoidalOpposite.unmopEquiv C) |
mul_finsum' | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {R : Type u_7} [inst : NonUnitalNonAssocSemiring R] (f : α → R) (r : R),
Function.HasFiniteSupport f → r * ∑ᶠ (a : α), f a = ∑ᶠ (a : α), r * f a |
Std.Internal.UV.TCP.Socket.getSockName | Std.Internal.UV.TCP | Std.Internal.UV.TCP.Socket → IO Std.Net.SocketAddress |
FinBddDistLat.inv_hom_apply | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y : FinBddDistLat} (e : X ≅ Y) (x : ↑X.toDistLat),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x |
Exists | Init.Core | {α : Sort u} → (α → Prop) → Prop |
TrivSqZeroExt.range_inlAlgHom_sup_adjoin_range_inr | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {S : Type u_1} {R : Type u} {M : Type v} [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Algebra S R] [inst_4 : Module S M] [inst_5 : Module R M] [inst_6 : Module Rᵐᵒᵖ M]
[inst_7 : SMulCommClass R Rᵐᵒᵖ M] [inst_8 : IsScalarTower S R M] [inst_9 : IsScalarTower S Rᵐᵒᵖ M],
(TrivSqZeroExt.inlAlgHom S R M).range ⊔ Algebra.adjoin S (Set.range TrivSqZeroExt.inr) = ⊤ |
Lean.Meta.Grind.AC.EqCnstrProof.below | Lean.Meta.Tactic.Grind.AC.Types | {motive_1 : Lean.Meta.Grind.AC.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.AC.EqCnstrProof → Sort u} → Lean.Meta.Grind.AC.EqCnstrProof → Sort (max 1 u) |
OrthonormalBasis.mkOfOrthogonalEqBot.congr_simp | 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 ι] {v v_1 : ι → E} (e_v : v = v_1) (hon : Orthonormal 𝕜 v)
(hsp : (Submodule.span 𝕜 (Set.range v))ᗮ = ⊥),
OrthonormalBasis.mkOfOrthogonalEqBot hon hsp = OrthonormalBasis.mkOfOrthogonalEqBot ⋯ ⋯ |
Std.TreeMap.maxKeyD | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → α |
Fin.finsetImage_val_Iic | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (a : Fin n), Finset.image Fin.val (Finset.Iic a) = Finset.Iic ↑a |
SaturatedSubmonoid.toSubmonoid | Mathlib.Algebra.Group.Submonoid.Saturation | {M : Type u_1} → [inst : MulOneClass M] → SaturatedSubmonoid M → Submonoid M |
TopologicalGroup.isOpenMap_iff_nhds_one | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] {H : Type u_1} [inst_3 : Monoid H]
[inst_4 : TopologicalSpace H] [ContinuousConstSMul H H] {F : Type u_2} [inst_6 : FunLike F G H] [MonoidHomClass F G H]
{f : F}, IsOpenMap ⇑f ↔ nhds 1 ≤ Filter.map (⇑f) (nhds 1) |
_private.Mathlib.Algebra.Algebra.Unitization.0.Unitization.isSelfAdjoint_inr._simp_1_2 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : AddMonoid R] [inst_1 : StarAddMonoid R] [inst_2 : Star A] (a : A),
star ↑a = ↑(star a) |
_private.Mathlib.AlgebraicTopology.ModelCategory.DerivabilityStructureFibrant.0.HomotopicalAlgebra.FibrantObject.instWeakEquivalenceWWeakEquivalences._simp_1 | Mathlib.AlgebraicTopology.ModelCategory.DerivabilityStructureFibrant | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C],
HomotopicalAlgebra.WeakEquivalence f = HomotopicalAlgebra.weakEquivalences C f |
FirstOrder.Language.BoundedFormula.IsQF.isPrenex | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ} {φ : L.BoundedFormula α n}, φ.IsQF → φ.IsPrenex |
QuaternionGroup.instGroup._proof_10 | Mathlib.GroupTheory.SpecificGroups.Quaternion | ∀ {n : ℕ} (n_1 : ℕ) (x : QuaternionGroup n), npowRecAuto (n_1 + 1) x = npowRecAuto n_1 x * x |
UniformContinuous.dist | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : UniformSpace β] {f g : β → α},
UniformContinuous f → UniformContinuous g → UniformContinuous fun b => dist (f b) (g b) |
_private.Lean.Server.Requests.0.Lean.Server.RequestM.findCmdParsedSnap.containsHoverPos | Lean.Server.Requests | Lean.Server.FileWorker.EditableDocument → String.Pos.Raw → Lean.Language.Lean.CommandParsedSnapshot → Bool |
AddEquiv.linearEquiv | Mathlib.Algebra.Module.TransferInstance | {α : Type u_2} →
{β : Type u_3} →
(A : Type u_4) →
[inst : Semiring A] →
[inst_1 : AddCommMonoid α] → [inst_2 : AddCommMonoid β] → [inst_3 : Module A β] → (e : α ≃+ β) → α ≃ₗ[A] β |
SSet.Truncated.ι0₂._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | (SimplexCategory.mk 2).len ≤ 2 |
finSuccEquiv'_ne_last_apply | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {i j : Fin (n + 1)} (hi : i ≠ Fin.last n), j ≠ i → (finSuccEquiv' i) j = some ((i.castLT ⋯).predAbove j) |
List.sym._unary._proof_3 | Mathlib.Data.List.Sym | ∀ {α : Type u_1} (n : ℕ) (x : α) (xs : List α),
(invImage (fun x => PSigma.casesOn x fun n a => (n, a)) Prod.instWellFoundedRelation).1 ⟨n + 1, xs⟩ ⟨n.succ, x :: xs⟩ |
MeasureTheory.SimpleFunc.instNonUnitalRing._proof_6 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonUnitalRing β]
(a b c : MeasureTheory.SimpleFunc α β), (a + b) * c = a * c + b * c |
AddCircle.EndpointIdent.recOn | Mathlib.Topology.Instances.AddCircle.Defs | {𝕜 : Type u_1} →
[inst : AddCommGroup 𝕜] →
[inst_1 : LinearOrder 𝕜] →
[inst_2 : IsOrderedAddMonoid 𝕜] →
{p a : 𝕜} →
[hp : Fact (0 < p)] →
{motive : (a_1 a_2 : ↑(Set.Icc a (a + p))) → AddCircle.EndpointIdent p a a_1 a_2 → Sort u} →
{a_1 a_2 : ↑(Set.Icc a (a + p))} →
(t : AddCircle.EndpointIdent p a a_1 a_2) → motive ⟨a, ⋯⟩ ⟨a + p, ⋯⟩ ⋯ → motive a_1 a_2 t |
Lean.Meta.Grind.Arith.Cutsat.State.rec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive : Lean.Meta.Grind.Arith.Cutsat.State → Sort u} →
((vars : Lean.PArray Lean.Expr) →
(varMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Int.Linear.Var) →
(vars' : Lean.PArray Lean.Expr) →
(varMap' : Lean.PHashMap Lean.Meta.Sym.ExprPtr Int.Linear.Var) →
(natToIntMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Lean.Expr × Lean.Expr)) →
(natDef : Lean.PHashMap Lean.Meta.Sym.ExprPtr Int.Linear.Var) →
(dvds : Lean.PArray (Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr)) →
(lowers uppers : Lean.PArray (Lean.PArray Lean.Meta.Grind.Arith.Cutsat.LeCnstr)) →
(diseqs : Lean.PArray (Lean.PArray Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr)) →
(elimEqs : Lean.PArray (Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
(elimStack : List Int.Linear.Var) →
(occurs : Lean.PArray Lean.Meta.Grind.Arith.Cutsat.VarSet) →
(assignment : Lean.PArray ℚ) →
(nextCnstrId : ℕ) →
(caseSplits : Bool) →
(conflict? : Option Lean.Meta.Grind.Arith.Cutsat.UnsatProof) →
(diseqSplits : Lean.PHashMap Int.Linear.Poly Lean.FVarId) →
(divMod : Lean.PHashSet (Lean.Expr × ℤ)) →
(toIntIds : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ)) →
(toIntInfos : Lean.PArray Lean.Meta.Grind.Arith.Cutsat.ToIntInfo) →
(toIntTermMap :
Lean.PHashMap Lean.Meta.Sym.ExprPtr
Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo) →
(toIntVarMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Expr) →
(usedCommRing : Bool) →
(nonlinearOccs : Lean.PHashMap Int.Linear.Var (List Int.Linear.Var)) →
motive
{ vars := vars, varMap := varMap, vars' := vars',
varMap' := varMap', natToIntMap := natToIntMap,
natDef := natDef, dvds := dvds, lowers := lowers,
uppers := uppers, diseqs := diseqs, elimEqs := elimEqs,
elimStack := elimStack, occurs := occurs,
assignment := assignment, nextCnstrId := nextCnstrId,
caseSplits := caseSplits, conflict? := conflict?,
diseqSplits := diseqSplits, divMod := divMod,
toIntIds := toIntIds, toIntInfos := toIntInfos,
toIntTermMap := toIntTermMap, toIntVarMap := toIntVarMap,
usedCommRing := usedCommRing,
nonlinearOccs := nonlinearOccs }) →
(t : Lean.Meta.Grind.Arith.Cutsat.State) → motive t |
BitVec.twoPow_mul_eq_shiftLeft | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec w) (i : ℕ), BitVec.twoPow w i * x = x <<< i |
CategoryTheory.Coyoneda.isIso | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y)
[CategoryTheory.IsIso (CategoryTheory.coyoneda.map f)], CategoryTheory.IsIso f |
EmbeddingLike.map_eq_one_iff._simp_2 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {F : Type u_1} {M : Type u_4} {N : Type u_5} [inst : One M] [inst_1 : One N] [inst_2 : FunLike F M N]
[EmbeddingLike F M N] [OneHomClass F M N] {f : F} {x : M}, (f x = 1) = (x = 1) |
AddEquiv.toNatLinearEquiv_trans | Mathlib.Algebra.Module.Equiv.Basic | ∀ {M : Type u_5} {M₂ : Type u_7} {M₃ : Type u_8} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] (e : M ≃+ M₂) (e₂ : M₂ ≃+ M₃),
(e.trans e₂).toNatLinearEquiv = e.toNatLinearEquiv ≪≫ₗ e₂.toNatLinearEquiv |
_private.Mathlib.Tactic.Tauto.0.Mathlib.Tactic.Tauto.«term_<;>_» | Mathlib.Tactic.Tauto | Lean.TrailingParserDescr |
CategoryTheory.NatTrans.mapElements_obj | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)} (φ : F ⟶ G)
(x : F.Elements),
(CategoryTheory.NatTrans.mapElements φ).obj x =
match x with
| ⟨X, x⟩ => ⟨X, φ.app X x⟩ |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Subset.congr_right.match_1_5 | Mathlib.SetTheory.ZFC.PSet | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (α_1 : Type u_1) (A_1 : α_1 → PSet.{u_1}) (b : (PSet.mk α_1 A_1).Type)
(motive : (∃ a, (A a).Equiv (A_1 b)) → Prop) (x : ∃ a, (A a).Equiv (A_1 b)),
(∀ (a : α) (ab : (A a).Equiv (A_1 b)), motive ⋯) → motive x |
Lean.Widget.HighlightedMsgEmbed.highlighted | Lean.Server.FileWorker.WidgetRequests | Lean.Widget.HighlightedMsgEmbed |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs.0.isLinearSet_iff._simp_1_2 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {α : Type u} {p : Finset α → Prop}, (∃ s, p s) = ∃ s, ∃ (hs : s.Finite), p hs.toFinset |
Function.locallyFinsuppWithin.instAddCommGroup._proof_7 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y]
(D : Function.locallyFinsuppWithin U Y) (n : ℤ), ⇑(n • D) = n • ⇑D |
EuclideanDomain.wellFoundedRelation | Mathlib.Algebra.EuclideanDomain.Defs | {R : Type u} → [EuclideanDomain R] → WellFoundedRelation R |
UInt64.toUSize_mod_of_dvd_usizeSize | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), b.toNat ∣ USize.size → (a % b).toUSize = a.toUSize % b.toUSize |
_private.Mathlib.Order.SuccPred.LinearLocallyFinite.0.toZ_neg._proof_1_1 | Mathlib.Order.SuccPred.LinearLocallyFinite | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] [inst_2 : IsSuccArchimedean ι] [inst_3 : PredOrder ι]
{i0 i : ι}, i < i0 → ∃ n, Order.pred^[n] i0 = i |
Lean.Lsp.Location._sizeOf_1 | Lean.Data.Lsp.Basic | Lean.Lsp.Location → ℕ |
Complex.dist_of_im_eq | Mathlib.Analysis.Complex.Norm | ∀ {z w : ℂ}, z.im = w.im → dist z w = dist z.re w.re |
Real.tendsto_eulerMascheroniSeq' | Mathlib.NumberTheory.Harmonic.EulerMascheroni | Filter.Tendsto Real.eulerMascheroniSeq' Filter.atTop (nhds Real.eulerMascheroniConstant) |
Submonoid.mem_saturation_iff | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : CommMonoid M] {s : Submonoid M} {x : M}, x ∈ s.saturation ↔ ∃ y, x * y ∈ s |
vadd_mem_nhds_self._simp_1 | Mathlib.Topology.Algebra.ConstMulAction | ∀ {G : Type u_4} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [ContinuousConstVAdd G G] {g : G} {s : Set G},
(g +ᵥ s ∈ nhds g) = (s ∈ nhds 0) |
Filter.Tendsto.add_atBot | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : AddCommGroup α] [inst_2 : LinearOrder α]
[IsOrderedAddMonoid α] [OrderTopology α] {l : Filter β} {f g : β → α} {C : α},
Filter.Tendsto f l (nhds C) → Filter.Tendsto g l Filter.atBot → Filter.Tendsto (fun x => f x + g x) l Filter.atBot |
_private.Aesop.Script.StructureStatic.0.Aesop.Script.StaticStructureM.run._proof_2 | Aesop.Script.StructureStatic | ∀ (script : Aesop.Script.UScript) (i : ℕ) (h : i ∈ [:Array.size script]),
script[i].postGoals.size = 1 → 0 < script[i].postGoals.size |
Int.floor_lt_ceil_of_lt | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsStrictOrderedRing R] {a b : R},
a < b → ⌊a⌋ < ⌈b⌉ |
MeasureTheory.volume_pi_ball | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasureTheory.MeasureSpace (α i)]
[∀ (i : ι), MeasureTheory.SigmaFinite MeasureTheory.volume] [inst_3 : (i : ι) → MetricSpace (α i)] (x : (i : ι) → α i)
{r : ℝ}, 0 < r → MeasureTheory.volume (Metric.ball x r) = ∏ i, MeasureTheory.volume (Metric.ball (x i) r) |
Dioph._aux_Mathlib_NumberTheory_Dioph___unexpand_Dioph_eq_dioph_1 | Mathlib.NumberTheory.Dioph | Lean.PrettyPrinter.Unexpander |
Std.Net.IPv4Addr.octets | Std.Net.Addr | Std.Net.IPv4Addr → Vector UInt8 4 |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex.0.NumberField.nrComplexPlaces_eq_zero_iff._simp_1_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ {α : Sort u_1} (p : α → Prop), IsEmpty (Subtype p) = ∀ (x : α), ¬p x |
FintypeCat.instFiniteAut | Mathlib.CategoryTheory.FintypeCat | ∀ (X : FintypeCat), Finite (CategoryTheory.Aut X) |
AdicCompletion.isAdicCauchy_iff | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(f : ℕ → M), AdicCompletion.IsAdicCauchy I M f ↔ ∀ (n : ℕ), f n ≡ f (n + 1) [SMOD I ^ n • ⊤] |
CategoryTheory.Functor.PullbackObjObj.mapArrowRight._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_2} {C₃ : Type u_4} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_3, u_4} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ : CategoryTheory.Arrow C₁}
{f₃ f₃' : CategoryTheory.Arrow C₃} (sq₁₃ : G.PullbackObjObj f₁.hom f₃.hom) (sq : f₃ ⟶ f₃'),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp sq₁₃.fst ((G.obj (Opposite.op f₁.left)).map sq.left))
((G.obj (Opposite.op ((CategoryTheory.Functor.id C₁).obj f₁.left))).map f₃'.hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp sq₁₃.snd ((G.obj (Opposite.op f₁.right)).map sq.right))
((G.map f₁.hom.op).app ((CategoryTheory.Functor.id C₃).obj f₃'.right)) |
Lean.Meta.Grind.Arith.CommRing.CommSemiring.noConfusionType | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Sort u → Lean.Meta.Grind.Arith.CommRing.CommSemiring → Lean.Meta.Grind.Arith.CommRing.CommSemiring → Sort u |
Std.Do.SPred.forall_nil | Std.Do.SPred.SPred | ∀ {α : Sort u_1} {P : α → Std.Do.SPred []}, Std.Do.SPred.forall P = { down := ∀ (a : α), (P a).down } |
AlternatingMap.instAddCommGroup._proof_15 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N' : Type u_3}
[inst_3 : AddCommGroup N'] [inst_4 : Module R N'] {ι : Type u_4} (a b : M [⋀^ι]→ₗ[R] N'), a + b = b + a |
Std.DTreeMap.Internal.Impl.insert._proof_24 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced →
∀ (d : Std.DTreeMap.Internal.Impl α β),
r'.size ≤ d.size → d.size ≤ r'.size + 1 → Std.DTreeMap.Internal.Impl.BalanceLPrecond d.size l'.size |
CategoryTheory.Iso.coreLeftUnitor | Mathlib.CategoryTheory.Core | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D},
F.leftUnitor.core =
(CategoryTheory.Functor.id C).coreComp F ≪≫
CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.Functor.coreId C) F.core ≪≫ F.core.leftUnitor |
CategoryTheory.ShortComplex.ShortExact.singleTriangleIso._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C] (n a a' : ℤ),
n + a = a' →
∀ (X : C) (i : ℤ),
(((HomologicalComplex.single C (ComplexShape.up ℤ) a').comp
(CategoryTheory.shiftFunctor (CochainComplex C ℤ) n)).obj
X).X
i =
((HomologicalComplex.single C (ComplexShape.up ℤ) a).obj X).X i |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.isNonarchimedean_smoothingFun._simp_1_1 | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b |
_private.Mathlib.Algebra.Order.Antidiag.Pi.0.Finset.mem_piAntidiag._proof_1_4 | Mathlib.Algebra.Order.Antidiag.Pi | ∀ {ι : Type u_1} {μ : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] {s : Finset ι} {f : ι → μ}
(e : ↥s ≃ Fin s.card),
(∀ (i : ι), f i ≠ 0 → i ∈ s) → (fun i => if hi : i ∈ s then (f ∘ Subtype.val ∘ ⇑e.symm) (e ⟨i, hi⟩) else 0) = f |
CategoryTheory.nerve.homEquiv._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {x y : CategoryTheory.ComposableArrows C 0}
(f : CategoryTheory.nerveEquiv x ⟶ CategoryTheory.nerveEquiv y),
CategoryTheory.SimplicialObject.δ (CategoryTheory.nerve C) 1 (CategoryTheory.ComposableArrows.mk₁ f) = x |
_private.Init.Data.Nat.Lemmas.0.Nat.lt_of_add_lt_add_right.match_1_1 | Init.Data.Nat.Lemmas | ∀ {k m : ℕ} (motive : (x : ℕ) → k + x < m + x → Prop) (x : ℕ) (x_1 : k + x < m + x),
(∀ (h : k + 0 < m + 0), motive 0 h) → (∀ (n : ℕ) (h : k + (n + 1) < m + (n + 1)), motive n.succ h) → motive x x_1 |
BitVec.cpopNatRec_allOnes | Init.Data.BitVec.Lemmas | ∀ {n w acc : ℕ}, n ≤ w → (BitVec.allOnes w).cpopNatRec n acc = acc + n |
Std.Slice.length_iter_eq_size | Std.Data.Iterators.Lemmas.Producers.Slice | ∀ {γ : Type u} {α β : Type v} [inst : Std.ToIterator (Std.Slice γ) Id α β] [inst_1 : Std.Iterator α Id β]
{s : Std.Slice γ} [Std.Iterators.Finite α Id] [inst_3 : Std.IteratorLoop α Id Id] [Std.LawfulIteratorLoop α Id Id]
[inst_5 : Std.Slice.SliceSize γ] [Std.Slice.LawfulSliceSize γ], s.iter.length = s.size |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_invalid_of_isInvalidContinuationByte_eq_false | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.isInvalidContinuationByte b = false →
ByteArray.utf8DecodeChar?.parseFirstByte b = ByteArray.utf8DecodeChar?.FirstByte.invalid |
Lean.EnvExtension.instInhabitedAsyncMode | Lean.Environment | Inhabited Lean.EnvExtension.AsyncMode |
_private.Mathlib.Analysis.Normed.Lp.lpSpace.0.Memℓp.const_smul._simp_1_5 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {x y : NNReal} {z : ℝ}, x ^ z * y ^ z = (x * y) ^ z |
Aesop.LIFOQueue.mk.sizeOf_spec | Aesop.Search.Queue | ∀ (goals : Array Aesop.GoalRef), sizeOf { goals := goals } = 1 + sizeOf goals |
IO.Promise.noConfusion | Init.System.Promise | {P : Sort u} →
{α : Type} →
{t : IO.Promise α} → {α' : Type} → {t' : IO.Promise α'} → α = α' → t ≍ t' → IO.Promise.noConfusionType P t t' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.