name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
AddAction.block_stabilizerOrderIso.match_5 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ (G : Type u_2) [inst : AddGroup G] {X : Type u_1} [inst_1 : AddAction G X] (a : X)
(motive : { B // a ∈ B ∧ AddAction.IsBlock G B } → Prop) (x : { B // a ∈ B ∧ AddAction.IsBlock G B }),
(∀ (val : Set X) (ha : a ∈ val) (hB : AddAction.IsBlock G val), motive ⟨val, ⋯⟩) → motive x |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Operations.0.SimpleGraph.Walk.drop.match_1.eq_3 | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} (motive : (v : V) → G.Walk u v → ℕ → Sort u_2) (v v_1 : V)
(h : G.Adj u v_1) (q : G.Walk v_1 v) (n : ℕ) (h_1 : (x : ℕ) → motive u SimpleGraph.Walk.nil x)
(h_2 : (v : V) → (p : G.Walk u v) → motive v p 0)
(h_3 : (v v_2 : V) → (h : G.Adj u v_2) → (q : G.Walk v_2 v) → (n : ℕ) → motive v (SimpleGraph.Walk.cons h q) n.succ),
(match v, SimpleGraph.Walk.cons h q, n.succ with
| .(u), SimpleGraph.Walk.nil, x => h_1 x
| v, p, 0 => h_2 v p
| v, SimpleGraph.Walk.cons h q, n.succ => h_3 v v_2 h q n) =
h_3 v v_1 h q n |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.isSorryAlt._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Split | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Std.DTreeMap.Internal.Impl.minKey?.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : α → Type v} (x : Std.DTreeMap.Internal.Impl α β),
x.minKey? =
match x with
| Std.DTreeMap.Internal.Impl.leaf => none
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r => some k
| Std.DTreeMap.Internal.Impl.inner size k v (l@h:(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)) r_1 =>
l.minKey? |
_private.Mathlib.MeasureTheory.Group.Action.0.MeasureTheory.measure_isOpen_pos_of_vaddInvariant_of_compact_ne_zero.match_1_1 | Mathlib.MeasureTheory.Group.Action | ∀ (G : Type u_1) {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {K U : Set α}
(motive : (∃ I, K ⊆ ⋃ g ∈ I, g +ᵥ U) → Prop) (x : ∃ I, K ⊆ ⋃ g ∈ I, g +ᵥ U),
(∀ (t : Finset G) (ht : K ⊆ ⋃ g ∈ t, g +ᵥ U), motive ⋯) → motive x |
CategoryTheory.Limits.CofanTypes | Mathlib.CategoryTheory.Limits.Types.Coproducts | {C : Type u} → (C → Type v) → Type (max (max u v) (w + 1)) |
InfHom.top_apply | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : SemilatticeInf β] [inst_2 : Top β] (a : α), ⊤ a = ⊤ |
CategoryTheory.CostructuredArrow.costructuredArrowToOverEquivalence.functor._proof_3 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} T] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (F : CategoryTheory.Functor D T) {X : T} (Y : CategoryTheory.Over X)
{X_1 Y_1 Z : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.toOver F X) Y} (f : X_1 ⟶ Y_1)
(g : Y_1 ⟶ Z),
CategoryTheory.CostructuredArrow.homMk (CategoryTheory.CategoryStruct.comp f g).left.left ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CostructuredArrow.homMk f.left.left ⋯)
(CategoryTheory.CostructuredArrow.homMk g.left.left ⋯) |
Asymptotics.«term_~[_]_» | Mathlib.Analysis.Asymptotics.Defs | Lean.TrailingParserDescr |
Ordinal.small_Icc | Mathlib.SetTheory.Ordinal.Basic | ∀ (a b : Ordinal.{u}), Small.{u, u + 1} ↑(Set.Icc a b) |
Rack.toEnvelGroup.map._proof_2 | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] {G : Type u_2} [inst_1 : Group G] (f : ShelfHom R (Quandle.Conj G))
(x y : Rack.EnvelGroup R),
Quotient.liftOn (x * y) (Rack.toEnvelGroup.mapAux f) ⋯ =
Quotient.liftOn x (Rack.toEnvelGroup.mapAux f) ⋯ * Quotient.liftOn y (Rack.toEnvelGroup.mapAux f) ⋯ |
_private.Mathlib.Topology.UrysohnsLemma.0.Urysohns.CU.approx_le_one._simp_1_4 | Mathlib.Topology.UrysohnsLemma | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b |
continuousAt_iff_lower_upperSemicontinuousAt | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {γ : Type u_4} [inst_1 : LinearOrder γ]
[inst_2 : TopologicalSpace γ] [OrderTopology γ] {f : α → γ},
ContinuousAt f x ↔ LowerSemicontinuousAt f x ∧ UpperSemicontinuousAt f x |
BoxIntegral.Box.ne_of_disjoint_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, Disjoint ↑I ↑J → I ≠ J |
Std.ToFormat.format | Init.Data.Format.Basic | {α : Type u} → [self : Std.ToFormat α] → α → Std.Format |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_738 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
List.idxOfNth w [g (g a)] (List.idxOfNth w [g (g a)] 1) + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w [g (g a)] (List.idxOfNth w [g (g a)] 1) <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
«term⅟_» | Mathlib.Algebra.Group.Invertible.Defs | Lean.ParserDescr |
Sym.cast._proof_4 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n m : ℕ}, n = m → ∀ (s : Sym α m), (↑s).card = n |
Lean.Elab.InfoTree | Lean.Elab.InfoTree.Types | Type |
LinearEquiv.piCongrRight_trans | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {ι : Type x} [inst : Semiring R] {φ : ι → Type u_1} {ψ : ι → Type u_2} {χ : ι → Type u_3}
[inst_1 : (i : ι) → AddCommMonoid (φ i)] [inst_2 : (i : ι) → Module R (φ i)] [inst_3 : (i : ι) → AddCommMonoid (ψ i)]
[inst_4 : (i : ι) → Module R (ψ i)] [inst_5 : (i : ι) → AddCommMonoid (χ i)] [inst_6 : (i : ι) → Module R (χ i)]
(e : (i : ι) → φ i ≃ₗ[R] ψ i) (f : (i : ι) → ψ i ≃ₗ[R] χ i),
LinearEquiv.piCongrRight e ≪≫ₗ LinearEquiv.piCongrRight f = LinearEquiv.piCongrRight fun i => e i ≪≫ₗ f i |
CategoryTheory.MonoidalCategory.instMonoidalFunctorTensoringRight._proof_2 | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ⟶ Y) (X' : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((CategoryTheory.MonoidalCategory.tensoringRight C).map f)
((CategoryTheory.MonoidalCategory.tensoringRight C).obj X'))
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso C)
(((CategoryTheory.evaluation C (CategoryTheory.Functor C C)).obj Y).comp
((CategoryTheory.evaluation C C).obj X'))).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso C)
(((CategoryTheory.evaluation C (CategoryTheory.Functor C C)).obj X).comp
((CategoryTheory.evaluation C C).obj X'))).hom
((CategoryTheory.MonoidalCategory.tensoringRight C).map (CategoryTheory.MonoidalCategoryStruct.whiskerRight f X')) |
CategoryTheory.ObjectProperty.instSmallUnopOfOpposite | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ)
[CategoryTheory.ObjectProperty.Small.{w, v, u} P], CategoryTheory.ObjectProperty.Small.{w, v, u} P.unop |
_private.Mathlib.Probability.Moments.Variance.0.ProbabilityTheory.evariance_def'._simp_1_7 | Mathlib.Probability.Moments.Variance | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) |
Set.graphOn_univ_inj | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {f g : α → β}, Set.graphOn f Set.univ = Set.graphOn g Set.univ ↔ f = g |
ExpGrowth.expGrowthInf_of_eventually_ge | Mathlib.Analysis.Asymptotics.ExpGrowth | ∀ {u v : ℕ → ENNReal} {b : ENNReal},
b ≠ 0 → (∀ᶠ (n : ℕ) in Filter.atTop, b * u n ≤ v n) → ExpGrowth.expGrowthInf u ≤ ExpGrowth.expGrowthInf v |
_private.Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable.0.mdifferentiableWithinAt_totalSpace._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : 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 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {x : M} {s : Set M},
MDiffAt[s] f x = (ContinuousWithinAt f s x ∧ MDiffAt[s] (↑(extChartAt I' (f x)) ∘ f) x) |
AddAction.zmultiplesQuotientStabilizerEquiv._proof_6 | Mathlib.Data.ZMod.QuotientGroup | ∀ {α : Type u_1} {β : Type u_2} [inst : AddGroup α] (a : α) [inst_1 : AddAction α β] (b : β),
Function.Injective
⇑(QuotientAddGroup.map (AddSubgroup.zmultiples ↑(Function.minimalPeriod (fun x => a +ᵥ x) b))
(AddAction.stabilizer (↥(AddSubgroup.zmultiples a)) b) ((zmultiplesHom ↥(AddSubgroup.zmultiples a)) ⟨a, ⋯⟩)
⋯) ∧
Function.Surjective
⇑(QuotientAddGroup.map (AddSubgroup.zmultiples ↑(Function.minimalPeriod (fun x => a +ᵥ x) b))
(AddAction.stabilizer (↥(AddSubgroup.zmultiples a)) b) ((zmultiplesHom ↥(AddSubgroup.zmultiples a)) ⟨a, ⋯⟩) ⋯) |
SimpleGraph.Walk.length_dropLast | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.dropLast.length = p.length - 1 |
LLVM.addGlobal | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} → LLVM.Module ctx → String → LLVM.LLVMType ctx → BaseIO (LLVM.Value ctx) |
DFinsupp.addMonoid₂ | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{α : ι → Type u_2} →
{δ : (i : ι) → α i → Type v} →
[inst : (i : ι) → (j : α i) → AddMonoid (δ i j)] → AddMonoid (Π₀ (i : ι) (j : α i), δ i j) |
Std.DTreeMap.getKey?_eq_some_getKeyD_of_contains | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α},
t.contains a = true → t.getKey? a = some (t.getKeyD a fallback) |
Nat.instCommutativeHMul | Init.Data.Nat.Basic | Std.Commutative fun x1 x2 => x1 * x2 |
Std.DTreeMap.Internal.Impl.eraseManyEntries! | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{ρ : Type w} → [ForIn Id ρ ((a : α) × β a)] → (t : Std.DTreeMap.Internal.Impl α β) → ρ → t.IteratedSlowErasureFrom |
DiscreteTiling.Protoset.coe_injective | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X],
Function.Injective DiscreteTiling.Protoset.tiles |
Std.Do.SPred.Tactic.HasFrame.mk | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs} {P' : outParam (Std.Do.SPred σs)} {φ : outParam Prop},
(P ⊣⊢ₛ P' ∧ ⌜φ⌝) → Std.Do.SPred.Tactic.HasFrame P P' φ |
CategoryTheory.Functor.RightExtension.isPointwiseRightKanExtensionAtEquivOfIso' | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | {C : Type u_1} →
{D : Type u_2} →
{H : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} H] →
{L : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor C H} →
(E : L.RightExtension F) →
{Y Y' : D} → (Y ≅ Y') → E.IsPointwiseRightKanExtensionAt Y ≃ E.IsPointwiseRightKanExtensionAt Y' |
CategoryTheory.Idempotents.Karoubi.comp_proof | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q R : CategoryTheory.Idempotents.Karoubi C}
(g : Q.Hom R) (f : P.Hom Q),
CategoryTheory.CategoryStruct.comp P.p
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f.f g.f) R.p) =
CategoryTheory.CategoryStruct.comp f.f g.f |
RestrictedProduct.mulSingle_eq_one_iff._simp_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} {S : ι → Type u_3} {G : ι → Type u_4} [inst : (i : ι) → SetLike (S i) (G i)] (A : (i : ι) → S i)
[inst_1 : DecidableEq ι] [inst_2 : (i : ι) → One (G i)] [inst_3 : ∀ (i : ι), OneMemClass (S i) (G i)] (i : ι)
{x : G i}, (RestrictedProduct.mulSingle A i x = 1) = (x = 1) |
IsOpen.nhdsWithin_eq | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, IsOpen s → a ∈ s → nhdsWithin a s = nhds a |
_private.Init.Data.List.Impl.0.List.eraseP_eq_erasePTR.go.match_1 | Init.Data.List.Impl | ∀ (α : Type u_1) (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (x : α) (xs : List α), motive (x :: xs)) → motive x |
Asymptotics.isLittleO_const_id_atTop | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {E'' : Type u_9} [inst : NormedAddCommGroup E''] (c : E''), (fun _x => c) =o[Filter.atTop] id |
Lean.Lsp.ReferenceContext.ctorIdx | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceContext → ℕ |
CategoryTheory.effectiveEpiFamilyStructOfIsIsoDesc | Mathlib.CategoryTheory.EffectiveEpi.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{B : C} →
{α : Type u_2} →
(X : α → C) →
(π : (a : α) → X a ⟶ B) →
[inst_1 : CategoryTheory.Limits.HasCoproduct X] →
[CategoryTheory.IsIso (CategoryTheory.Limits.Sigma.desc π)] → CategoryTheory.EffectiveEpiFamilyStruct X π |
StarSubsemiring.ofClass._proof_3 | Mathlib.Algebra.Star.Subsemiring | ∀ {S : Type u_2} {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : SetLike S R] [SubsemiringClass S R] (s : S)
{a b : R}, a ∈ s → b ∈ s → a + b ∈ s |
Orientation.volumeForm_def | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {n : ℕ}
[_i : Fact (Module.finrank ℝ E = n)] (o : Orientation ℝ E (Fin n)),
o.volumeForm =
Nat.casesAuxOn (motive := fun a => n = a → E [⋀^Fin n]→ₗ[ℝ] ℝ) n
(fun h =>
Eq.ndrec (motive := fun {n} =>
[_i : Fact (Module.finrank ℝ E = n)] → Orientation ℝ E (Fin n) → E [⋀^Fin n]→ₗ[ℝ] ℝ)
(fun [Fact (Module.finrank ℝ E = 0)] o =>
have opos := AlternatingMap.constOfIsEmpty ℝ E (Fin 0) 1;
⋯.by_cases (fun x => opos) fun x => -opos)
⋯ o)
(fun n_1 h =>
Eq.ndrec (motive := fun {n} =>
[_i : Fact (Module.finrank ℝ E = n)] → Orientation ℝ E (Fin n) → E [⋀^Fin n]→ₗ[ℝ] ℝ)
(fun [Fact (Module.finrank ℝ E = n_1 + 1)] o => (Orientation.finOrthonormalBasis ⋯ ⋯ o).toBasis.det) ⋯ o)
⋯ |
Std.DTreeMap.Raw.maxKey?_mem | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {km : α}, t.maxKey? = some km → km ∈ t |
exists_stronglyMeasurable_limit_of_tendsto_ae | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[TopologicalSpace.PseudoMetrizableSpace β] {f : ℕ → α → β},
(∀ (n : ℕ), MeasureTheory.AEStronglyMeasurable (f n) μ) →
(∀ᵐ (x : α) ∂μ, ∃ l, Filter.Tendsto (fun n => f n x) Filter.atTop (nhds l)) →
∃ f_lim,
MeasureTheory.StronglyMeasurable f_lim ∧
∀ᵐ (x : α) ∂μ, Filter.Tendsto (fun n => f n x) Filter.atTop (nhds (f_lim x)) |
Lean.Elab.HoverableInfoPrio.mk.injEq | Lean.Server.InfoUtils | ∀ (isHoverPosOnStop : Bool) (size : ℕ) (isVariableInfo isPartialTermInfo isHoverPosOnStop_1 : Bool) (size_1 : ℕ)
(isVariableInfo_1 isPartialTermInfo_1 : Bool),
({ isHoverPosOnStop := isHoverPosOnStop, size := size, isVariableInfo := isVariableInfo,
isPartialTermInfo := isPartialTermInfo } =
{ isHoverPosOnStop := isHoverPosOnStop_1, size := size_1, isVariableInfo := isVariableInfo_1,
isPartialTermInfo := isPartialTermInfo_1 }) =
(isHoverPosOnStop = isHoverPosOnStop_1 ∧
size = size_1 ∧ isVariableInfo = isVariableInfo_1 ∧ isPartialTermInfo = isPartialTermInfo_1) |
PolynomialModule.eval_apply | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (r : R)
(p : PolynomialModule R M), (PolynomialModule.eval r) p = Finsupp.sum p fun i m => r ^ i • m |
Quiver.Path.weight | Mathlib.Combinatorics.Quiver.Path.Weight | {V : Type u_1} →
[inst : Quiver V] → {R : Type u_2} → [Monoid R] → ({i j : V} → (i ⟶ j) → R) → {i j : V} → Quiver.Path i j → R |
Lean.Elab.Tactic.evalWithAnnotateState | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic |
_private.Mathlib.GroupTheory.Coset.Basic.0.QuotientGroup.orbit_mk_eq_smul._simp_1_2 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {x y : α}, (x⁻¹ * y ∈ s) = (QuotientGroup.leftRel s) x y |
TrivialLieModule.instLieRingModule._proof_2 | Mathlib.Algebra.Lie.Abelian | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : AddCommGroup M] (x : L) (m n : TrivialLieModule R L M), 0 = 0 + 0 |
RelIso.sumLexComplLeft_symm_apply | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {x : α} [inst : IsTrans α r] [inst_1 : Std.Trichotomous r] [inst_2 : DecidableRel r]
(a : { x_1 // r x_1 x } ⊕ { x_1 // ¬r x_1 x }), (RelIso.sumLexComplLeft r x) a = (Equiv.sumCompl fun x_1 => r x_1 x) a |
Shrink.continuousLinearEquiv | Mathlib.Topology.Algebra.Module.TransferInstance | (R : Type u_1) →
(α : Type u_2) →
[inst : Small.{v, u_2} α] →
[inst_1 : AddCommMonoid α] →
[inst_2 : TopologicalSpace α] → [inst_3 : Semiring R] → [inst_4 : Module R α] → Shrink.{v, u_2} α ≃L[R] α |
_private.Init.Internal.Order.Basic.0.Lean.Order.implication_order_monotone_or.match_1_1 | Init.Internal.Order.Basic | ∀ {α : Sort u_1} (f₁ f₂ : α → Lean.Order.ImplicationOrder) (x : α) (motive : f₁ x ∨ f₂ x → Prop) (h : f₁ x ∨ f₂ x),
(∀ (hfx₁ : f₁ x), motive ⋯) → (∀ (hfx₂ : f₂ x), motive ⋯) → motive h |
AffineMap.comp | Mathlib.LinearAlgebra.AffineSpace.AffineMap | {k : Type u_1} →
{V1 : Type u_2} →
{P1 : Type u_3} →
{V2 : Type u_4} →
{P2 : Type u_5} →
{V3 : Type u_6} →
{P3 : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V1] →
[inst_2 : Module k V1] →
[inst_3 : AddTorsor V1 P1] →
[inst_4 : AddCommGroup V2] →
[inst_5 : Module k V2] →
[inst_6 : AddTorsor V2 P2] →
[inst_7 : AddCommGroup V3] →
[inst_8 : Module k V3] →
[inst_9 : AddTorsor V3 P3] → (P2 →ᵃ[k] P3) → (P1 →ᵃ[k] P2) → P1 →ᵃ[k] P3 |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comap_isBasis_iff._simp_1_10 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (s ⊆ f ⁻¹' t) = (f '' s ⊆ t) |
OrderMonoidIso.val_inv_unitsCongr_symm_apply | Mathlib.Algebra.Order.Hom.Units | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Monoid α] [inst_2 : Preorder β] [inst_3 : Monoid β]
(e : α ≃*o β) (a : βˣ), ↑(e.unitsCongr.symm a)⁻¹ = (↑e).symm ↑a⁻¹ |
Lean.Meta.instReprCoeFnType | Lean.Meta.CoeAttr | Repr Lean.Meta.CoeFnType |
Lean.IR.Sorry.State.mk.inj | Lean.Compiler.IR.Sorry | ∀ {localSorryMap : Lean.NameMap Lean.Name} {modified : Bool} {localSorryMap_1 : Lean.NameMap Lean.Name}
{modified_1 : Bool},
{ localSorryMap := localSorryMap, modified := modified } =
{ localSorryMap := localSorryMap_1, modified := modified_1 } →
localSorryMap = localSorryMap_1 ∧ modified = modified_1 |
Mathlib.Tactic.Monoidal.evalWhiskerLeft_comp | Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {f g h i : C}
{η : h ⟶ i}
{η₁ : CategoryTheory.MonoidalCategoryStruct.tensorObj g h ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj g i}
{η₂ :
CategoryTheory.MonoidalCategoryStruct.tensorObj f (CategoryTheory.MonoidalCategoryStruct.tensorObj g h) ⟶
CategoryTheory.MonoidalCategoryStruct.tensorObj f (CategoryTheory.MonoidalCategoryStruct.tensorObj g i)}
{η₃ :
CategoryTheory.MonoidalCategoryStruct.tensorObj f (CategoryTheory.MonoidalCategoryStruct.tensorObj g h) ⟶
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj f g) i}
{η₄ :
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj f g) h ⟶
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj f g) i},
CategoryTheory.MonoidalCategoryStruct.whiskerLeft g η = η₁ →
CategoryTheory.MonoidalCategoryStruct.whiskerLeft f η₁ = η₂ →
CategoryTheory.CategoryStruct.comp η₂ (CategoryTheory.MonoidalCategoryStruct.associator f g i).inv = η₃ →
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator f g h).hom η₃ = η₄ →
CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorObj f g) η = η₄ |
normalizationMonoidOfMonoidHomRightInverse._proof_5 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : DecidableEq α] (f : Associates α →* α)
(hinv : Function.RightInverse (⇑f) Associates.mk), (if 0 = 0 then 1 else Classical.choose ⋯) = 1 |
Lean.Elab.Term.tryPostponeIfHasMVars | Lean.Elab.Term.TermElabM | Option Lean.Expr → String → Lean.Elab.TermElabM Lean.Expr |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._proof_11 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (guess : ℕ) (hg : guess < table.size) (this : table[guess - 1] < guess),
¬table[guess - 1] < table.size → False |
Primrec.list_flatten | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec List.flatten |
Turing.ToPartrec.Code.succ | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code |
CategoryTheory.IsHomLift.eq_of_isHomLift | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) {a b : 𝒳} (f : p.obj a ⟶ p.obj b) (φ : a ⟶ b) [p.IsHomLift f φ], f = p.map φ |
RootPairing.InvariantForm.isOrthogonal_reflection | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N}
(self : P.InvariantForm) (i : ι), LinearMap.IsOrthogonal self.form ⇑(P.reflection i) |
PresheafOfModules.presheaf.eq_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Free | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R),
M.presheaf =
{ obj := fun X => (CategoryTheory.forget₂ (ModuleCat ↑(R.obj X)) Ab).obj (M.obj X),
map := fun {X Y} f => AddCommGrpCat.ofHom (AddMonoidHom.mk' ⇑(CategoryTheory.ConcreteCategory.hom (M.map f)) ⋯),
map_id := ⋯, map_comp := ⋯ } |
GenContFract.of_s_head | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] {v : K},
Int.fract v ≠ 0 → (GenContFract.of v).s.head = some { a := 1, b := ↑⌊(Int.fract v)⁻¹⌋ } |
Associates.is_pow_of_dvd_count | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α]
[inst_2 : DecidableEq (Associates α)] [inst_3 : (p : Associates α) → Decidable (Irreducible p)] {a : Associates α},
a ≠ 0 → ∀ {k : ℕ}, (∀ (p : Associates α), Irreducible p → k ∣ p.count a.factors) → ∃ b, a = b ^ k |
Quaternion.dualNumberEquiv._proof_2 | Mathlib.Algebra.DualQuaternion | ∀ {R : Type u_1} [inst : CommRing R],
Function.RightInverse
(fun d =>
{ re := ((TrivSqZeroExt.fst d).re, (TrivSqZeroExt.snd d).re),
imI := ((TrivSqZeroExt.fst d).imI, (TrivSqZeroExt.snd d).imI),
imJ := ((TrivSqZeroExt.fst d).imJ, (TrivSqZeroExt.snd d).imJ),
imK := ((TrivSqZeroExt.fst d).imK, (TrivSqZeroExt.snd d).imK) })
fun q =>
({ re := TrivSqZeroExt.fst q.re, imI := TrivSqZeroExt.fst q.imI, imJ := TrivSqZeroExt.fst q.imJ,
imK := TrivSqZeroExt.fst q.imK },
{ re := TrivSqZeroExt.snd q.re, imI := TrivSqZeroExt.snd q.imI, imJ := TrivSqZeroExt.snd q.imJ,
imK := TrivSqZeroExt.snd q.imK }) |
_private.Mathlib.Util.CompileInductive.0.Mathlib.Util.replaceConst.match_1 | Mathlib.Util.CompileInductive | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x |
CategoryTheory.Bicategory.associator_naturality_middle_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g') (h : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g' h) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerLeft f η) h)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator f g' h).hom h_1) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator f g h).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerRight η h)) h_1) |
differentiableOn_pi'' | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {ι : Type u_6} {F' : ι → Type u_7}
[inst_3 : (i : ι) → NormedAddCommGroup (F' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i},
(∀ (i : ι), DifferentiableOn 𝕜 (fun x => Φ x i) s) → DifferentiableOn 𝕜 Φ s |
Monoid.End.instInhabited | Mathlib.Algebra.Group.Hom.Defs | (M : Type u_4) → [inst : MulOne M] → Inhabited (Monoid.End M) |
DFinsupp.subtypeSupportEqEquiv._proof_5 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] (s : Finset ι) (f : (i : ↥s) → { x // x ≠ 0 }) (i : ι),
i ∈ (DFinsupp.mk s fun i => ↑(f i)).support ↔ i ∈ s |
CategoryTheory.Grp.instMonoidalMonForget₂Mon._proof_6 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y Z : CategoryTheory.Grp C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj ((CategoryTheory.Grp.forget₂Mon C).obj X)
((CategoryTheory.Grp.forget₂Mon C).obj Y)))
((CategoryTheory.Grp.forget₂Mon C).obj Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj
((CategoryTheory.Grp.forget₂Mon C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
((CategoryTheory.Grp.forget₂Mon C).obj Z)))
((CategoryTheory.Grp.forget₂Mon C).map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator ((CategoryTheory.Grp.forget₂Mon C).obj X)
((CategoryTheory.Grp.forget₂Mon C).obj Y) ((CategoryTheory.Grp.forget₂Mon C).obj Z)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.Grp.forget₂Mon C).obj X)
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj ((CategoryTheory.Grp.forget₂Mon C).obj Y)
((CategoryTheory.Grp.forget₂Mon C).obj Z))))
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj ((CategoryTheory.Grp.forget₂Mon C).obj X)
((CategoryTheory.Grp.forget₂Mon C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z))))) |
ne_zero_and_ne_zero_of_mul | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] {a b : M₀}, a * b ≠ 0 → a ≠ 0 ∧ b ≠ 0 |
_private.Mathlib.Analysis.MellinInversion.0.mellin_eq_fourier._simp_1_6 | Mathlib.Analysis.MellinInversion | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False |
DivisionSemiring.mk.noConfusion | Mathlib.Algebra.Field.Defs | {K : Type u_2} →
{P : Sort u} →
{toSemiring : Semiring K} →
{toInv : Inv K} →
{toDiv : Div K} →
{div_eq_mul_inv : autoParam (∀ (a b : K), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam} →
{zpow : ℤ → K → K} →
{zpow_zero' : autoParam (∀ (a : K), zpow 0 a = 1) DivInvMonoid.zpow_zero'._autoParam} →
{zpow_succ' :
autoParam (∀ (n : ℕ) (a : K), zpow (↑n.succ) a = zpow (↑n) a * a)
DivInvMonoid.zpow_succ'._autoParam} →
{zpow_neg' :
autoParam (∀ (n : ℕ) (a : K), zpow (Int.negSucc n) a = (zpow (↑n.succ) a)⁻¹)
DivInvMonoid.zpow_neg'._autoParam} →
{toNontrivial : Nontrivial K} →
{inv_zero : 0⁻¹ = 0} →
{mul_inv_cancel : ∀ (a : K), a ≠ 0 → a * a⁻¹ = 1} →
{toNNRatCast : NNRatCast K} →
{nnratCast_def :
autoParam (∀ (q : ℚ≥0), ↑q = ↑q.num / ↑q.den)
DivisionSemiring.nnratCast_def._autoParam} →
{nnqsmul : ℚ≥0 → K → K} →
{nnqsmul_def :
autoParam (∀ (q : ℚ≥0) (a : K), nnqsmul q a = ↑q * a)
DivisionSemiring.nnqsmul_def._autoParam} →
{toSemiring' : Semiring K} →
{toInv' : Inv K} →
{toDiv' : Div K} →
{div_eq_mul_inv' :
autoParam (∀ (a b : K), a / b = a * b⁻¹)
DivInvMonoid.div_eq_mul_inv._autoParam} →
{zpow' : ℤ → K → K} →
{zpow_zero'' :
autoParam (∀ (a : K), zpow' 0 a = 1)
DivInvMonoid.zpow_zero'._autoParam} →
{zpow_succ'' :
autoParam (∀ (n : ℕ) (a : K), zpow' (↑n.succ) a = zpow' (↑n) a * a)
DivInvMonoid.zpow_succ'._autoParam} →
{zpow_neg'' :
autoParam
(∀ (n : ℕ) (a : K),
zpow' (Int.negSucc n) a = (zpow' (↑n.succ) a)⁻¹)
DivInvMonoid.zpow_neg'._autoParam} →
{toNontrivial' : Nontrivial K} →
{inv_zero' : 0⁻¹ = 0} →
{mul_inv_cancel' : ∀ (a : K), a ≠ 0 → a * a⁻¹ = 1} →
{toNNRatCast' : NNRatCast K} →
{nnratCast_def' :
autoParam (∀ (q : ℚ≥0), ↑q = ↑q.num / ↑q.den)
DivisionSemiring.nnratCast_def._autoParam} →
{nnqsmul' : ℚ≥0 → K → K} →
{nnqsmul_def' :
autoParam (∀ (q : ℚ≥0) (a : K), nnqsmul' q a = ↑q * a)
DivisionSemiring.nnqsmul_def._autoParam} →
{ toSemiring := toSemiring, toInv := toInv,
toDiv := toDiv, div_eq_mul_inv := div_eq_mul_inv,
zpow := zpow, zpow_zero' := zpow_zero',
zpow_succ' := zpow_succ', zpow_neg' := zpow_neg',
toNontrivial := toNontrivial,
inv_zero := inv_zero,
mul_inv_cancel := mul_inv_cancel,
toNNRatCast := toNNRatCast,
nnratCast_def := nnratCast_def,
nnqsmul := nnqsmul, nnqsmul_def := nnqsmul_def } =
{ toSemiring := toSemiring', toInv := toInv',
toDiv := toDiv',
div_eq_mul_inv := div_eq_mul_inv', zpow := zpow',
zpow_zero' := zpow_zero'',
zpow_succ' := zpow_succ'',
zpow_neg' := zpow_neg'',
toNontrivial := toNontrivial',
inv_zero := inv_zero',
mul_inv_cancel := mul_inv_cancel',
toNNRatCast := toNNRatCast',
nnratCast_def := nnratCast_def',
nnqsmul := nnqsmul',
nnqsmul_def := nnqsmul_def' } →
(toSemiring ≍ toSemiring' →
toInv ≍ toInv' →
toDiv ≍ toDiv' →
zpow ≍ zpow' →
toNNRatCast ≍ toNNRatCast' →
nnqsmul ≍ nnqsmul' → P) →
P |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.gaussianPDFReal_inv_mul._simp_1_4 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False |
getElem?_eq_none_iff._simp_1 | Init.GetElem | ∀ {cont : Type u_1} {idx : Type u_2} {elem : Type u_3} {dom : cont → idx → Prop} [inst : GetElem? cont idx elem dom]
[LawfulGetElem cont idx elem dom] (c : cont) (i : idx) [Decidable (dom c i)], (c[i]? = none) = ¬dom c i |
lowerCentralSeries_pi_of_finite | Mathlib.GroupTheory.Nilpotent | ∀ {η : Type u_2} {Gs : η → Type u_3} [inst : (i : η) → Group (Gs i)] [Finite η] (n : ℕ),
lowerCentralSeries ((i : η) → Gs i) n = Subgroup.pi Set.univ fun i => lowerCentralSeries (Gs i) n |
_private.Init.Data.String.Decode.0.Char.utf8Size_eq_four_iff._proof_1_5 | Init.Data.String.Decode | ∀ {c : Char}, 127 < c.val.toNat → c.val.toNat ≤ 2047 → ¬c.val.toNat ≤ 65535 → False |
Std.PRange.UpwardEnumerable.succMany?_succ?_eq_succ?_bind_succMany? | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] (n : ℕ) (a : α),
Std.PRange.succMany? (n + 1) a = (Std.PRange.succ? a).bind fun x => Std.PRange.succMany? n x |
Nat.add_le_add_iff_left._simp_1 | Init.Data.Nat.Basic | ∀ {m k n : ℕ}, (n + m ≤ n + k) = (m ≤ k) |
Subfield.mk.congr_simp | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} [inst : DivisionRing K] (toSubring toSubring_1 : Subring K) (e_toSubring : toSubring = toSubring_1)
(inv_mem' : ∀ x ∈ toSubring.carrier, x⁻¹ ∈ toSubring.carrier),
{ toSubring := toSubring, inv_mem' := inv_mem' } = { toSubring := toSubring_1, inv_mem' := ⋯ } |
Polynomial.smeval_assoc_X_pow | Mathlib.Algebra.Polynomial.Smeval | ∀ (R : Type u_1) [inst : Semiring R] (p : Polynomial R) {S : Type u_2} [inst_1 : NonAssocSemiring S]
[inst_2 : Module R S] [inst_3 : Pow S ℕ] (x : S) [NatPowAssoc S] [IsScalarTower R S S] (m n : ℕ),
p.smeval x * x ^ m * x ^ n = p.smeval x * (x ^ m * x ^ n) |
smul_mem_asymptoticCone_iff._simp_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] [inst_6 : TopologicalSpace k]
[OrderTopology k] [IsStrictOrderedRing k] [IsTopologicalAddGroup V] [ContinuousSMul k V] {s : Set P} {c : k} {v : V},
0 < c → (c • v ∈ asymptoticCone k s) = (v ∈ asymptoticCone k s) |
CompleteOrthogonalIdempotents.lift_of_isNilpotent_ker | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) {I : Type u_3} [inst_2 : Fintype I],
(∀ x ∈ RingHom.ker f, IsNilpotent x) →
∀ {e : I → S},
CompleteOrthogonalIdempotents e →
(∀ (i : I), e i ∈ f.range) → ∃ e', CompleteOrthogonalIdempotents e' ∧ ⇑f ∘ e' = e |
_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.casesMatch.match_6 | Lean.Meta.Tactic.Grind.CasesMatch | (motive : Lean.Expr × Array Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Array Lean.Expr) →
((motive_1 : Lean.Expr) → (eqRefls : Array Lean.Expr) → motive (motive_1, eqRefls)) → motive __discr |
AddAction.instElemOrbit_1._proof_1 | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_2} {α : Type u_1} [inst : AddGroup G] [inst_1 : AddAction G α] (x : AddAction.orbitRel.Quotient G α)
(g g' : G) (a' : ↑x.orbit), (g + g') +ᵥ a' = g +ᵥ g' +ᵥ a' |
ContractingWith.fixedPoint_unique | Mathlib.Topology.MetricSpace.Contracting | ∀ {α : Type u_1} [inst : MetricSpace α] {K : NNReal} {f : α → α} (hf : ContractingWith K f) [inst_1 : Nonempty α]
[inst_2 : CompleteSpace α] {x : α}, Function.IsFixedPt f x → x = ContractingWith.fixedPoint f hf |
_private.Lean.Parser.Extension.0.Lean.Parser.compileParserDescr.visit.match_3 | Lean.Parser.Extension | (motive : Option Lean.Parser.ParserCategory → Sort u_1) →
(x : Option Lean.Parser.ParserCategory) →
((val : Lean.Parser.ParserCategory) → motive (some val)) → (Unit → motive none) → motive x |
Lean.PrettyPrinter.Delaborator.State.mk._flat_ctor | Lean.PrettyPrinter.Delaborator.Basic | ℕ →
Lean.SubExpr.PosMap Lean.Elab.Info →
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator → Lean.PrettyPrinter.Delaborator.State |
MeasureTheory.Measure.rnDeriv_add_right_of_absolutelyContinuous_of_mutuallySingular | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν ν' : MeasureTheory.Measure α} [μ.HaveLebesgueDecomposition ν]
[μ.HaveLebesgueDecomposition (ν + ν')] [MeasureTheory.SigmaFinite ν],
μ.AbsolutelyContinuous ν → ν.MutuallySingular ν' → μ.rnDeriv (ν + ν') =ᵐ[ν] μ.rnDeriv ν |
Multiset.foldl_zero | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (f : β → α → β) [inst : RightCommutative f] (b : β), Multiset.foldl f b 0 = b |
Finset.bipartiteBelow.eq_1 | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) (s : Finset α) (b : β) [inst : (a : α) → Decidable (r a b)],
Finset.bipartiteBelow r s b = {a ∈ s | r a b} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.