name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Mathlib.Tactic.ModCases.NatMod.onModCases_succ | Mathlib.Tactic.ModCases | {p : Sort u_1} →
{n a : ℕ} →
(b : ℕ) →
(a ≡ b [MOD n] → p) →
Mathlib.Tactic.ModCases.NatMod.OnModCases n a (b.add 1) p → Mathlib.Tactic.ModCases.NatMod.OnModCases n a b p |
MeasureTheory.Measure.snd_mono | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{ρ μ : MeasureTheory.Measure (α × β)}, ρ ≤ μ → ρ.snd ≤ μ.snd |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkCasesResultSeq._proof_1 | Lean.Meta.Tactic.Grind.Split | ∀ (alts : Array (List (Lean.TSyntax `grind))), alts.size = 1 → ¬0 < alts.size → False |
_private.Mathlib.Algebra.Order.Field.Power.0.Mathlib.Meta.Positivity.evalZPow._proof_5 | Mathlib.Algebra.Order.Field.Power | ∀ {u : Lean.Level} {α : Q(Type u)} (zα : Q(Zero «$α»)) (_a : Q(GroupWithZero «$α»)),
«$zα» =Q «$_a».toMulZeroOneClass.toMulZeroClass.toZero |
CategoryTheory.HasProjectiveDimensionLT.subsingleton' | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Abelian C} {X : C} {n : ℕ}
[self : CategoryTheory.HasProjectiveDimensionLT X n] (i : ℕ),
n ≤ i → ∀ ⦃Y : C⦄, Subsingleton (CategoryTheory.Abelian.Ext X Y i) |
addRightReflectLT_of_addLeftReflectLT | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ (N : Type u_2) [inst : AddCommSemigroup N] [inst_1 : LT N] [AddLeftReflectLT N], AddRightReflectLT N |
Int8.reduceDiv._regBuiltin.Int8.reduceDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3529513953._hygCtx._hyg.120 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit |
Batteries.RBSet.mem_toList | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x : α} {t : Batteries.RBSet α cmp}, x ∈ t.toList ↔ x ∈ ↑t |
Nat.Partition.powerSeriesMk_card_restricted_eq_powerSeriesMk_card_countRestricted | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | ∀ (R : Type u_1) [inst : CommRing R] [NoZeroDivisors R] {m : ℕ},
0 < m →
(PowerSeries.mk fun n => ↑(Nat.Partition.restricted n fun x => ¬m ∣ x).card) =
PowerSeries.mk fun n => ↑(Nat.Partition.countRestricted n m).card |
groupCohomology.shortComplexH0_g | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G),
(groupCohomology.shortComplexH0 A).g = groupCohomology.d₀₁ A |
HomologicalComplex.homology_π_ι | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {K : HomologicalComplex C c} (i : ι) [inst_2 : K.HasHomology i],
CategoryTheory.CategoryStruct.comp (K.homologyπ i) (K.homologyι i) =
CategoryTheory.CategoryStruct.comp (K.iCycles i) (K.pOpcycles i) |
ProbabilityTheory.HasSubgaussianMGF.const_mul | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ} {c : NNReal},
ProbabilityTheory.HasSubgaussianMGF X c μ →
∀ (r : ℝ), ProbabilityTheory.HasSubgaussianMGF (fun ω => r * X ω) (⟨r ^ 2, ⋯⟩ * c) μ |
Mathlib.Tactic.Bicategory.tgtExpr | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Lean.Expr → Lean.MetaM Lean.Expr |
ModuleCat.isLimitKernelFork._proof_6 | Mathlib.Algebra.Category.ModuleCat.Kernels | ∀ {R : Type u_2} [inst : Ring R] {M N P : ModuleCat R} (f : M ⟶ N) (g : N ⟶ P)
(H : Function.Exact ⇑(ModuleCat.Hom.hom f) ⇑(ModuleCat.Hom.hom g)) (H₂ : Function.Injective ⇑(ModuleCat.Hom.hom f))
(j : CategoryTheory.Limits.WalkingParallelPair),
(ModuleCat.kernelCone g).π.app j =
CategoryTheory.CategoryStruct.comp
((LinearEquiv.ofInjective (ModuleCat.Hom.hom f) H₂).trans
(LinearEquiv.ofEq (ModuleCat.Hom.hom f).range (ModuleCat.Hom.hom g).ker ⋯)).toModuleIso.symm.hom
((CategoryTheory.Limits.KernelFork.ofι f ⋯).π.app j) |
TopologicalSpace.Fiber.sigmaIsoHom.match_1 | Mathlib.Topology.FiberPartition | {S : Type u_1} →
{Y : Type u_2} →
(f : S → Y) →
(motive : (x : Function.Fiber f) × ↑↑x → Sort u_3) →
(x : (x : Function.Fiber f) × ↑↑x) → ((a : Function.Fiber f) → (x : ↑↑a) → motive ⟨a, x⟩) → motive x |
SheafOfModules.IsFiniteType.rec | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | {C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat] →
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] →
[inst_3 : ∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] →
{M : SheafOfModules R} →
{motive : M.IsFiniteType → Sort u_1} →
((exists_localGeneratorsData : ∃ σ, σ.IsFiniteType) → motive ⋯) → (t : M.IsFiniteType) → motive t |
Lean.Lsp.DocumentColorParams.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{toWorkDoneProgressParams : Lean.Lsp.WorkDoneProgressParams} →
{toPartialResultParams : Lean.Lsp.PartialResultParams} →
{textDocument : Lean.Lsp.TextDocumentIdentifier} →
{toWorkDoneProgressParams' : Lean.Lsp.WorkDoneProgressParams} →
{toPartialResultParams' : Lean.Lsp.PartialResultParams} →
{textDocument' : Lean.Lsp.TextDocumentIdentifier} →
{ toWorkDoneProgressParams := toWorkDoneProgressParams, toPartialResultParams := toPartialResultParams,
textDocument := textDocument } =
{ toWorkDoneProgressParams := toWorkDoneProgressParams',
toPartialResultParams := toPartialResultParams', textDocument := textDocument' } →
(toWorkDoneProgressParams = toWorkDoneProgressParams' →
toPartialResultParams = toPartialResultParams' → textDocument = textDocument' → P) →
P |
_private.Lean.Server.Test.Runner.0.Lean.Server.Test.Runner.Client.instFromJsonHighlightedMsgEmbed.fromJson.match_1 | Lean.Server.Test.Runner | (motive : String → Sort u_1) →
(tag : String) →
(Unit → motive "highlighted") →
(Unit → motive "expr") →
(Unit → motive "goal") →
(Unit → motive "widget") → (Unit → motive "trace") → ((x : String) → motive x) → motive tag |
Lean.Meta.mkId | Lean.Meta.AppBuilder | Lean.Expr → Lean.MetaM Lean.Expr |
Tropical.instLinearOrderTropical._proof_5 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] (a b : Tropical R), a + b = if a ≤ b then a else b |
AlternatingMap.domCoprod.summand._proof_1 | Mathlib.LinearAlgebra.Alternating.DomCoprod | ∀ {ιa : Type u_1} {ιb : Type u_2} [inst : Fintype ιa] [inst_1 : Fintype ιb] {R' : Type u_6} {Mᵢ : Type u_3}
{N₁ : Type u_4} {N₂ : Type u_5} [inst_2 : CommSemiring R'] [inst_3 : AddCommGroup N₁] [inst_4 : Module R' N₁]
[inst_5 : AddCommGroup N₂] [inst_6 : Module R' N₂] [inst_7 : AddCommMonoid Mᵢ] [inst_8 : Module R' Mᵢ]
[inst_9 : DecidableEq ιa] [inst_10 : DecidableEq ιb] (a : Mᵢ [⋀^ιa]→ₗ[R'] N₁) (b : Mᵢ [⋀^ιb]→ₗ[R'] N₂)
(σ₁ σ₂ : Equiv.Perm (ιa ⊕ ιb)),
(QuotientGroup.leftRel (Equiv.Perm.sumCongrHom ιa ιb).range) σ₁ σ₂ →
(fun σ => Equiv.Perm.sign σ • MultilinearMap.domDomCongr σ ((↑a).domCoprod ↑b)) σ₁ =
(fun σ => Equiv.Perm.sign σ • MultilinearMap.domDomCongr σ ((↑a).domCoprod ↑b)) σ₂ |
Subalgebra.mem_saturation_iff._simp_1 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
{s : Subalgebra R S} {M : Submonoid S} {H : M ≤ s.toSubmonoid} {x : S}, (x ∈ s.saturation M H) = ∃ m ∈ M, m • x ∈ s |
Fin.sum_univ_five | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddCommMonoid M] (f : Fin 5 → M), ∑ i, f i = f 0 + f 1 + f 2 + f 3 + f 4 |
Mathlib.Tactic.Widget.StringDiagram.stringEqM? | Mathlib.Tactic.Widget.StringDiagram | Lean.Expr → Lean.MetaM (Option ProofWidgets.Html) |
MonadCont.Label.rec | Mathlib.Control.Monad.Cont | {α : Type w} →
{m : Type u → Type v} →
{β : Type u} →
{motive : MonadCont.Label α m β → Sort u_1} →
((apply : α → m β) → motive { apply := apply }) → (t : MonadCont.Label α m β) → motive t |
List.take_concat_get | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {l : List α} {i : ℕ} (h : i < l.length), (List.take i l).concat l[i] = List.take (i + 1) l |
range_pow_padicValNat_subset_divisors' | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p n : ℕ} [hp : Fact (Nat.Prime p)],
Finset.image (fun t => p ^ (t + 1)) (Finset.range (padicValNat p n)) ⊆ n.divisors.erase 1 |
DihedralGroup.oddCommuteEquiv | Mathlib.GroupTheory.SpecificGroups.Dihedral | {n : ℕ} → Odd n → { p // Commute p.1 p.2 } ≃ ZMod n ⊕ ZMod n ⊕ ZMod n ⊕ ZMod n × ZMod n |
Filter.EventuallyEq.fun_comp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} {f g : α → β} {l : Filter α}, f =ᶠ[l] g → ∀ (h : β → γ), h ∘ f =ᶠ[l] h ∘ g |
ShareCommonT | Init.ShareCommon | ShareCommon.StateFactory → (Type u → Type v) → Type u → Type (max u v) |
StarRingEquiv.mk.inj | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_1} {B : Type u_2} {inst : Add A} {inst_1 : Add B} {inst_2 : Mul A} {inst_3 : Mul B} {inst_4 : Star A}
{inst_5 : Star B} {toRingEquiv : A ≃+* B}
{map_star' : ∀ (a : A), toRingEquiv.toFun (star a) = star (toRingEquiv.toFun a)} {toRingEquiv_1 : A ≃+* B}
{map_star'_1 : ∀ (a : A), toRingEquiv_1.toFun (star a) = star (toRingEquiv_1.toFun a)},
{ toRingEquiv := toRingEquiv, map_star' := map_star' } = { toRingEquiv := toRingEquiv_1, map_star' := map_star'_1 } →
toRingEquiv = toRingEquiv_1 |
MeasureTheory.FiniteMeasure.ennreal_coeFn_eq_coeFn_toMeasure | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (ν : MeasureTheory.FiniteMeasure Ω) (s : Set Ω), ↑(ν s) = ↑ν s |
MonoidAlgebra.coe_add._simp_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {G : Type u_3} [inst : Semiring R] (f g : MonoidAlgebra R G), ⇑f + ⇑g = ⇑(f + g) |
_private.Lean.Meta.Tactic.Grind.PP.0.Lean.Meta.Grind.isArithOfCastLike | Lean.Meta.Tactic.Grind.PP | Lean.Expr → Bool |
Lean.Parser.InputContext.substring | Lean.Parser.Types | Lean.Parser.InputContext → String.Pos.Raw → String.Pos.Raw → Substring.Raw |
Std.Time.Duration.addMilliseconds | Std.Time.Duration | Std.Time.Duration → Std.Time.Millisecond.Offset → Std.Time.Duration |
_private.Mathlib.Data.Matrix.Invertible.0.Matrix.add_mul_mul_mul_invOf_eq_one._simp_1_2 | Mathlib.Data.Matrix.Invertible | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype m]
(L M : Matrix l m α) (N : Matrix m n α), L * N + M * N = (L + M) * N |
Std.DHashMap.Raw.mem_toList_iff_get?_eq_some._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α],
m.WF → ∀ {k : α} {v : β k}, (⟨k, v⟩ ∈ m.toList) = (m.get? k = some v) |
_private.Mathlib.RingTheory.Valuation.Discrete.Basic.0.Valuation.valuationSubring_not_isField._simp_1_1 | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {R : Type u} [inst : Ring R] (s : Subring R) {x : ↥s}, (↑x = 0) = (x = 0) |
CategoryTheory.Bicategory.id_whiskerLeft._autoParam | Mathlib.CategoryTheory.Bicategory.Basic | Lean.Syntax |
CategoryTheory.Cat.HasLimits.limitCone_pt | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat),
(CategoryTheory.Cat.HasLimits.limitCone F).pt = CategoryTheory.Cat.HasLimits.limitConeX F |
_private.Mathlib.Algebra.Order.BigOperators.Ring.Finset.0.Finset.prod_add_prod_le._simp_1_7 | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
mem_emetric_ball_one_iff | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] {a : E} {r : ENNReal}, a ∈ Metric.eball 1 r ↔ ‖a‖ₑ < r |
TensorProduct.ext_iff_inner_right_threefold | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G] {x y : TensorProduct 𝕜 (TensorProduct 𝕜 E F) G},
x = y ↔ ∀ (a : E) (b : F) (c : G), inner 𝕜 x (a ⊗ₜ[𝕜] b ⊗ₜ[𝕜] c) = inner 𝕜 y (a ⊗ₜ[𝕜] b ⊗ₜ[𝕜] c) |
Complex.re_nonneg_iff_nonneg | Mathlib.Analysis.Complex.Basic | ∀ {x : ℂ}, IsSelfAdjoint x → (0 ≤ x.re ↔ 0 ≤ x) |
CategoryTheory.Limits.KernelFork.IsLimit.ofι'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y K : C} {f : X ⟶ Y} (i : K ⟶ X)
(h :
{A : C} →
(k : A ⟶ X) → CategoryTheory.CategoryStruct.comp k f = 0 → { l // CategoryTheory.CategoryStruct.comp l i = k })
[hi : CategoryTheory.Mono i] {A : C} (k : A ⟶ X) (hk : CategoryTheory.CategoryStruct.comp k f = 0) (m : A ⟶ K),
CategoryTheory.CategoryStruct.comp m i = k → m = (fun {x} k hk => ↑(h k hk)) k hk |
_private.Lean.Declaration.0.Lean.ConstantInfo.value?._sparseCasesOn_1 | Lean.Declaration | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
((val : Lean.OpaqueVal) → motive (Lean.ConstantInfo.opaqueInfo val)) →
(Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t |
Lean.Meta.PostponedEntry.ctorIdx | Lean.Meta.Basic | Lean.Meta.PostponedEntry → ℕ |
Std.TreeSet.getD_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k a fallback : α},
(t.insert k).getD a fallback = if cmp k a = Ordering.eq ∧ k ∉ t then k else t.getD a fallback |
IsTopologicalAddGroup.continuous_conj' | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Neg G] [inst_2 : Add G] [ContinuousAdd G] [ContinuousNeg G]
(h : G), Continuous fun g => g + h + -g |
LieDerivation.instLieAlgebra._proof_1 | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (r : R)
(d e : LieDerivation R L L), ⁅d, r • e⁆ = r • ⁅d, e⁆ |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.insertAux.match_3 | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
(motive : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β) → Sort u_3) →
(entry : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) →
(Unit → motive Lean.PersistentHashMap.Entry.null) →
((node : Lean.PersistentHashMap.Node α β) → motive (Lean.PersistentHashMap.Entry.ref node)) →
((k' : α) → (v' : β) → motive (Lean.PersistentHashMap.Entry.entry k' v')) → motive entry |
OrderHomClass | Mathlib.Order.Hom.Basic | (F : Type u_6) → (α : outParam (Type u_7)) → (β : outParam (Type u_8)) → [LE α] → [LE β] → [FunLike F α β] → Prop |
lineDerivWithin.eq_1 | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] (f : E → F) (s : Set E)
(x v : E), lineDerivWithin 𝕜 f s x v = derivWithin (fun t => f (x + t • v)) ((fun t => x + t • v) ⁻¹' s) 0 |
Std.Sat.AIG.IsPrefix.of._flat_ctor | Std.Sat.AIG.LawfulOperator | ∀ {α : Type} {decls1 decls2 : Array (Std.Sat.AIG.Decl α)} (size_le : decls1.size ≤ decls2.size),
(∀ (idx : ℕ) (h : idx < decls1.size), decls2[idx] = decls1[idx]) → Std.Sat.AIG.IsPrefix decls1 decls2 |
GenContFract.zeroth_den_eq_one | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K], g.dens 0 = 1 |
Lean.MonadCacheT.instAlternative | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] → [inst_2 : Hashable α] → [Monad m] → [Alternative m] → Alternative (Lean.MonadCacheT α β m) |
_private.Lean.Meta.Tactic.Grind.Arith.Simproc.0._regBuiltin.Lean.Meta.Grind.Arith.normFieldInv.declare_24._@.Lean.Meta.Tactic.Grind.Arith.Simproc.1655774764._hygCtx._hyg.12 | Lean.Meta.Tactic.Grind.Arith.Simproc | IO Unit |
ZMod.erdos_ginzburg_ziv | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {ι : Type u_1} {n : ℕ} {s : Finset ι} (a : ι → ZMod n), 2 * n - 1 ≤ s.card → ∃ t ⊆ s, t.card = n ∧ ∑ i ∈ t, a i = 0 |
HomologicalComplex.dgoToHomologicalComplex | Mathlib.Algebra.Homology.DifferentialObject | {β : Type u_1} →
[inst : AddCommGroup β] →
(b : β) →
(V : Type u_2) →
[inst_1 : CategoryTheory.Category.{v_1, u_2} V] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V] →
CategoryTheory.Functor (CategoryTheory.DifferentialObject ℤ (CategoryTheory.GradedObjectWithShift b V))
(HomologicalComplex V (ComplexShape.up' b)) |
Lean.Meta.Grind.Arith.Linear.Struct.recOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive : Lean.Meta.Grind.Arith.Linear.Struct → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.Struct) →
((id : ℕ) →
(ringId? : Option ℕ) →
(type : Lean.Expr) →
(u : Lean.Level) →
(intModuleInst : Lean.Expr) →
(leInst? ltInst? lawfulOrderLTInst? isPreorderInst? orderedAddInst? isLinearInst? noNatDivInst?
ringInst? commRingInst? orderedRingInst? fieldInst? : Option Lean.Expr) →
(charInst? : Option (Lean.Expr × ℕ)) →
(zero ofNatZero : Lean.Expr) →
(one? leFn? ltFn? : Option Lean.Expr) →
(addFn zsmulFn nsmulFn : Lean.Expr) →
(zsmulFn? nsmulFn? homomulFn? : Option Lean.Expr) →
(subFn negFn : Lean.Expr) →
(vars : Lean.PArray Lean.Expr) →
(varMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Grind.Linarith.Var) →
(lowers uppers : Lean.PArray (Lean.PArray Lean.Meta.Grind.Arith.Linear.IneqCnstr)) →
(diseqs : Lean.PArray (Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCnstr)) →
(assignment : Lean.PArray ℚ) →
(caseSplits : Bool) →
(conflict? : Option Lean.Meta.Grind.Arith.Linear.UnsatProof) →
(diseqSplits : Lean.PHashMap Lean.Grind.Linarith.Poly Lean.FVarId) →
(elimEqs : Lean.PArray (Option Lean.Meta.Grind.Arith.Linear.EqCnstr)) →
(elimStack : List Lean.Grind.Linarith.Var) →
(occurs : Lean.PArray Lean.Meta.Grind.Arith.Linear.VarSet) →
(ignored : Lean.PArray Lean.Expr) →
motive
{ id := id, ringId? := ringId?, type := type, u := u,
intModuleInst := intModuleInst, leInst? := leInst?,
ltInst? := ltInst?, lawfulOrderLTInst? := lawfulOrderLTInst?,
isPreorderInst? := isPreorderInst?,
orderedAddInst? := orderedAddInst?,
isLinearInst? := isLinearInst?,
noNatDivInst? := noNatDivInst?, ringInst? := ringInst?,
commRingInst? := commRingInst?,
orderedRingInst? := orderedRingInst?,
fieldInst? := fieldInst?, charInst? := charInst?,
zero := zero, ofNatZero := ofNatZero, one? := one?,
leFn? := leFn?, ltFn? := ltFn?, addFn := addFn,
zsmulFn := zsmulFn, nsmulFn := nsmulFn, zsmulFn? := zsmulFn?,
nsmulFn? := nsmulFn?, homomulFn? := homomulFn?,
subFn := subFn, negFn := negFn, vars := vars,
varMap := varMap, lowers := lowers, uppers := uppers,
diseqs := diseqs, assignment := assignment,
caseSplits := caseSplits, conflict? := conflict?,
diseqSplits := diseqSplits, elimEqs := elimEqs,
elimStack := elimStack, occurs := occurs,
ignored := ignored }) →
motive t |
CategoryTheory.MorphismProperty.of_pullback_fst_of_descendsAlong | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C} {X Y Z : C}
{f : X ⟶ Z} {g : Y ⟶ Z} [P.DescendsAlong Q] [inst_2 : CategoryTheory.Limits.HasPullback f g],
Q f → P (CategoryTheory.Limits.pullback.fst f g) → P g |
_private.Lean.Meta.Hint.0.Lean.Meta.Hint.mkSuggestionsMessage._sparseCasesOn_5 | Lean.Meta.Hint | {motive : Lean.Meta.Hint.DiffGranularity → Sort u} →
(t : Lean.Meta.Hint.DiffGranularity) →
motive Lean.Meta.Hint.DiffGranularity.none → (Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t |
Lean.PrettyPrinter.Formatter.State.mk.injEq | Lean.PrettyPrinter.Formatter | ∀ (stxTrav : Lean.Syntax.Traverser) (leadWord : String) (leadWordIdent isUngrouped mustBeGrouped : Bool)
(stack : Array Std.Format) (stxTrav_1 : Lean.Syntax.Traverser) (leadWord_1 : String)
(leadWordIdent_1 isUngrouped_1 mustBeGrouped_1 : Bool) (stack_1 : Array Std.Format),
({ stxTrav := stxTrav, leadWord := leadWord, leadWordIdent := leadWordIdent, isUngrouped := isUngrouped,
mustBeGrouped := mustBeGrouped, stack := stack } =
{ stxTrav := stxTrav_1, leadWord := leadWord_1, leadWordIdent := leadWordIdent_1, isUngrouped := isUngrouped_1,
mustBeGrouped := mustBeGrouped_1, stack := stack_1 }) =
(stxTrav = stxTrav_1 ∧
leadWord = leadWord_1 ∧
leadWordIdent = leadWordIdent_1 ∧
isUngrouped = isUngrouped_1 ∧ mustBeGrouped = mustBeGrouped_1 ∧ stack = stack_1) |
UInt16.size_dvd_usizeSize | Init.Data.UInt.Lemmas | UInt16.size ∣ USize.size |
instIsLocalizedModuleToLinearMapToAlgHomOfIsLocalizationAlgebraMapSubmonoid | Mathlib.Algebra.Module.LocalizedModule.IsLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {A : Type u_2} {Aₛ : Type u_3} [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : CommSemiring Aₛ] [inst_4 : Algebra A Aₛ] [inst_5 : Algebra R Aₛ]
[inst_6 : IsScalarTower R A Aₛ] [IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ],
IsLocalizedModule S (IsScalarTower.toAlgHom R A Aₛ).toLinearMap |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_15 | Init.Data.BitVec.Bitblast | ∀ {p : Prop} [Decidable p], (¬¬p) = p |
Std.HashSet.Raw.containsThenInsert_fst | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α],
m.WF → ∀ {k : α}, (m.containsThenInsert k).1 = m.contains k |
spectrum.zero_notMem | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsUnit a → 0 ∉ spectrum R a |
Std.ExtTreeMap.getKey?_minKey! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α], t ≠ ∅ → t.getKey? t.minKey! = some t.minKey! |
AffineEquiv.mk | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_4} →
{V₂ : Type u_5} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
[inst_5 : AddTorsor V₁ P₁] →
[inst_6 : AddTorsor V₂ P₂] →
(toEquiv : P₁ ≃ P₂) →
(linear : V₁ ≃ₗ[k] V₂) →
(∀ (p : P₁) (v : V₁), toEquiv (v +ᵥ p) = linear v +ᵥ toEquiv p) → P₁ ≃ᵃ[k] P₂ |
_private.Mathlib.Data.List.Cycle.0.List.next_getLast_eq_head_of_notMem_dropLast._proof_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α}, l ≠ [] → 0 < l.length |
Btw.btw.antisymm | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularPartialOrder α] {a b c : α}, btw a b c → btw c b a → a = b ∨ b = c ∨ c = a |
isEllDivSequence_id | Mathlib.NumberTheory.EllipticDivisibilitySequence | IsEllDivSequence id |
Concept.intent_swap | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} (c : Concept α β r), c.swap.intent = c.extent |
MeasureTheory.Ioo_ae_eq_Ioc' | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : PartialOrder α] {a b : α},
μ {b} = 0 → Set.Ioo a b =ᵐ[μ] Set.Ioc a b |
SkewMonoidAlgebra.toFinsupp_eq_zero._simp_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {a : SkewMonoidAlgebra k G}, (a.toFinsupp = 0) = (a = 0) |
ArithmeticFunction.vonMangoldt.residueClass_apply | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {q : ℕ} {a : ZMod q} [NeZero q],
IsUnit a →
∀ (n : ℕ),
↑(ArithmeticFunction.vonMangoldt.residueClass a n) =
(↑q.totient)⁻¹ * ∑ χ, χ a⁻¹ * χ ↑n * ↑(ArithmeticFunction.vonMangoldt n) |
TopologicalSpace.CompactOpens.coe_inf | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : QuasiSeparatedSpace α] (s t : TopologicalSpace.CompactOpens α),
↑(s ⊓ t) = ↑s ∩ ↑t |
AlgEquiv.aut_inv | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁]
(ϕ : A₁ ≃ₐ[R] A₁), ϕ⁻¹ = ϕ.symm |
MeasureTheory.L2.instInnerSubtypeAEEqFunMemAddSubgroupLpOfNatENNReal._proof_1 | Mathlib.MeasureTheory.Function.L2Space | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E |
FinBddDistLat.forget_map | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y : FinBddDistLat} (f : X ⟶ Y),
(CategoryTheory.forget FinBddDistLat).map f = ⇑(CategoryTheory.ConcreteCategory.hom f) |
Pi.zero_apply | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {M : ι → Type u_5} [inst : (i : ι) → Zero (M i)] (i : ι), 0 i = 0 |
List.toList_iter | Init.Data.Iterators.Lemmas.Producers.List | ∀ {β : Type w} {l : List β}, l.iter.toList = l |
_private.Mathlib.RingTheory.MvPowerSeries.Evaluation.0.MvPolynomial.toMvPowerSeries_uniformContinuous._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.Evaluation | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) |
Std.Tactic.BVDecide.BVLogicalExpr.eval | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVExpr.Assignment → Std.Tactic.BVDecide.BVLogicalExpr → Bool |
Lean.Meta.RefinedDiscrTree.instToFormatLazyEntry | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Std.ToFormat Lean.Meta.RefinedDiscrTree.LazyEntry |
CategoryTheory.regularOfIsPullbackSndOfRegular._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S}
{k : R ⟶ S} (hr : CategoryTheory.RegularMono h)
(comm : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k)
(s :
CategoryTheory.Limits.Fork (CategoryTheory.CategoryStruct.comp k hr.left)
(CategoryTheory.CategoryStruct.comp k hr.right))
(p :
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero ⟶
(CategoryTheory.Limits.PullbackCone.mk f g comm).pt)
{m :
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero ⟶
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj
(CategoryTheory.Limits.Fork.ofι g ⋯).pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero},
CategoryTheory.CategoryStruct.comp m (CategoryTheory.Limits.Fork.ofι g ⋯).ι = s.ι →
CategoryTheory.CategoryStruct.comp m g = CategoryTheory.CategoryStruct.comp p g →
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp m f) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp p f) h |
Set.mem_Icc | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, x ∈ Set.Icc a b ↔ a ≤ x ∧ x ≤ b |
HahnSeries.single_eq_zero | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] {a : Γ}, (HahnSeries.single a) 0 = 0 |
Sym2.mk_prod_swap_eq | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {a b : α}, s(a, b) = s(b, a) |
LieRinehartAlgebra.mk | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_1} {A : Type u_2} {L : Type u_3} [inst : CommRing A] [inst_1 : LieRing L] [inst_2 : Module A L]
[inst_3 : LieRingModule L A] [inst_4 : LieRinehartRing A L] [inst_5 : CommRing R] [inst_6 : Algebra R A]
[inst_7 : LieAlgebra R L] [toIsScalarTower : IsScalarTower R A L] [toLieModule : LieModule R L A],
LieRinehartAlgebra R A L |
Std.Do.PostCond.entails.trans | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} {α : Type u} {P Q R : Std.Do.PostCond α ps}, P.entails Q → Q.entails R → P.entails R |
uniformity_eq_comap_mul_inv_nhds_one | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (Gᵣ : Type u_3) [inst : UniformSpace Gᵣ] [inst_1 : Group Gᵣ] [IsRightUniformGroup Gᵣ],
uniformity Gᵣ = Filter.comap (fun x => x.2 * x.1⁻¹) (nhds 1) |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.expandMatchAltsIntoMatchAux._unsafe_rec | Lean.Elab.Binders | Lean.Syntax → Bool → Bool → ℕ → Array Lean.Syntax → Array Lean.Ident → Lean.MacroM Lean.Syntax |
MeasureTheory.closedCompactCylinders.eq_1 | Mathlib.MeasureTheory.Constructions.ClosedCompactCylinders | ∀ {ι : Type u_1} (X : ι → Type u_2) [inst : (i : ι) → TopologicalSpace (X i)],
MeasureTheory.closedCompactCylinders X =
⋃ s, ⋃ S, ⋃ (_ : IsClosed S), ⋃ (_ : IsCompact S), {MeasureTheory.cylinder s S} |
Aesop.RulePatternIndex.getSingle | Aesop.Index.RulePattern | Lean.Expr → Aesop.RulePatternIndex → Aesop.BaseM (Array (Aesop.RuleName × Aesop.Substitution)) |
UniformConvergenceCLM.coe_zero | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologicalAddGroup F]
(𝔖 : Set (Set E)), ⇑0 = 0 |
Ideal.mul_add_mem_pow_succ_unique | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] {P : Ideal S} [P_prime : P.IsPrime] [IsDedekindDomain S],
P ≠ ⊥ →
∀ {i : ℕ} (a d d' e e' : S),
a ∉ P ^ (i + 1) → e ∈ P ^ (i + 1) → e' ∈ P ^ (i + 1) → a * d + e - (a * d' + e') ∈ P ^ (i + 1) → d - d' ∈ P |
Std.ExtHashMap.size_alter_eq_add_one | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
k ∉ m → (f m[k]?).isSome = true → (m.alter k f).size = m.size + 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.