name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.tendsto_nhds_top_iff_real._simp_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) |
Real.sinOrderIso._proof_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Real.sin '' Set.Icc (-(Real.pi / 2)) (Real.pi / 2) = Set.Icc (-1) 1 |
UInt8.not_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, ¬a ≤ b ↔ b < a |
Std.BundledIterM.Equiv._proof_1 | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ (m : Type u_1 → Type u_2) (β : Type u_1) [inst : Monad m] [inst_1 : LawfulMonad m]
(R S : Std.BundledIterM m β → Std.BundledIterM m β → Prop),
Lean.Order.PartialOrder.rel R S →
∀ (ita itb : Std.BundledIterM m β),
Std.Iterators.HetT.map (Std.IterStep.mapIterator (Quot.mk S)) ita.step =
Std.Iterators.HetT.map (Std.IterStep.mapIterator (Quot.mk S)) itb.step →
Std.Iterators.HetT.map (Std.IterStep.mapIterator (Quot.mk R)) ita.step =
Std.Iterators.HetT.map (Std.IterStep.mapIterator (Quot.mk R)) itb.step |
RestrictedProduct.mk.congr_simp | Mathlib.Topology.Algebra.RestrictedProduct.Units | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} (x x_1 : (i : ι) → R i) (e_x : x = x_1)
(hx : ∀ᶠ (i : ι) in 𝓕, x i ∈ A i), RestrictedProduct.mk x hx = RestrictedProduct.mk x_1 ⋯ |
Matrix.toMatrix₂Aux_toLinearMap₂'Aux | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ (R : Type u_1) {R₁ : Type u_2} {S₁ : Type u_3} {R₂ : Type u_4} {S₂ : Type u_5} {N₂ : Type u_10} {n : Type u_11}
{m : Type u_12} [inst : CommSemiring R] [inst_1 : Semiring R₁] [inst_2 : Semiring S₁] [inst_3 : Semiring R₂]
[inst_4 : Semiring S₂] [inst_5 : AddCommMonoid N₂] [inst_6 : Module R N₂] [inst_7 : Module S₁ N₂]
[inst_8 : Module S₂ N₂] [inst_9 : SMulCommClass S₁ R N₂] [inst_10 : SMulCommClass S₂ R N₂]
[inst_11 : SMulCommClass S₂ S₁ N₂] {σ₁ : R₁ →+* S₁} {σ₂ : R₂ →+* S₂} [inst_12 : Fintype n] [inst_13 : Fintype m]
[inst_14 : DecidableEq n] [inst_15 : DecidableEq m] (f : Matrix n m N₂),
(LinearMap.toMatrix₂Aux R (fun i => Pi.single i 1) fun j => Pi.single j 1) (Matrix.toLinearMap₂'Aux σ₁ σ₂ f) = f |
LowerSet.prod_self_lt_prod_self._simp_1 | Mathlib.Order.UpperLower.Prod | ∀ {α : Type u_1} [inst : Preorder α] {s₁ s₂ : LowerSet α}, (s₁ ×ˢ s₁ < s₂ ×ˢ s₂) = (s₁ < s₂) |
Lean.Meta.Grind.Methods.evalTactic | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Methods → Lean.Meta.Grind.EvalTactic |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_3 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ}, ∀ k ≤ n, ¬k + 1 ≤ n + 3 → False |
Algebra.exists_aeval_invOf_eq_zero_of_idealMap_adjoin_sup_span_eq_top | Mathlib.RingTheory.Polynomial.Ideal | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (x : S) (I : Ideal R),
I ≠ ⊤ →
∀ [inst_3 : Invertible x],
Ideal.map (algebraMap R ↥(Algebra.adjoin R {x})) I ⊔ Ideal.span {⟨x, ⋯⟩} = ⊤ →
∃ p, p.leadingCoeff - 1 ∈ I ∧ (Polynomial.aeval ⅟x) p = 0 |
OrderedFinpartition.extendLeft._proof_14 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition n) (i : Fin c.length), 0 < Fin.cons 1 c.partSize i.succ |
Lean.Meta.Match.Overlaps.noConfusionType | Lean.Meta.Match.MatcherInfo | Sort u → Lean.Meta.Match.Overlaps → Lean.Meta.Match.Overlaps → Sort u |
BoundedContinuousFunction.instModule'._proof_8 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {β : Type u_2} {𝕜 : Type u_3} [inst : NormedField 𝕜] [inst_1 : TopologicalSpace α]
[inst_2 : SeminormedAddCommGroup β] [inst_3 : NormedSpace 𝕜 β] (f : BoundedContinuousFunction α β), 1 • f = f |
CategoryTheory.Triangulated.Octahedron.map_m₁ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] [inst_4 : CategoryTheory.Limits.HasZeroObject C]
[inst_5 : CategoryTheory.Limits.HasZeroObject D] [inst_6 : CategoryTheory.Preadditive C]
[inst_7 : CategoryTheory.Preadditive D] [inst_8 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_9 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor D n).Additive] [inst_10 : CategoryTheory.Pretriangulated C]
[inst_11 : CategoryTheory.Pretriangulated D] {X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C} {u₁₂ : X₁ ⟶ X₂} {u₂₃ : X₂ ⟶ X₃}
{u₁₃ : X₁ ⟶ X₃} {comm : CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃} {v₁₂ : X₂ ⟶ Z₁₂}
{w₁₂ : Z₁₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁}
{h₁₂ : CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}
{v₂₃ : X₃ ⟶ Z₂₃} {w₂₃ : Z₂₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₂}
{h₂₃ : CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}
{v₁₃ : X₃ ⟶ Z₁₃} {w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁}
{h₁₃ : CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}
(h : CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃) (F : CategoryTheory.Functor C D)
[inst_12 : F.CommShift ℤ] [inst_13 : F.IsTriangulated], (h.map F).m₁ = F.map h.m₁ |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic.0.CategoryTheory.IsPullback.of_iso'._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
(CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) |
IsPurelyInseparable.surjective_algebraMap_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u_1) (E : Type u_2) [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E] [IsPurelyInseparable F E]
[Algebra.IsSeparable F E], Function.Surjective ⇑(algebraMap F E) |
Lean.Elab.CheckTactic.expandCheckSimp._regBuiltin.Lean.Elab.CheckTactic.expandCheckSimp.declRange_3 | Lean.Elab.CheckTactic | IO Unit |
Lean.Order.CompleteLattice.casesOn | Init.Internal.Order.Basic | {α : Sort u} →
{motive : Lean.Order.CompleteLattice α → Sort u_1} →
(t : Lean.Order.CompleteLattice α) →
([toPartialOrder : Lean.Order.PartialOrder α] →
(has_sup : ∀ (c : α → Prop), Exists (Lean.Order.is_sup c)) →
motive { toPartialOrder := toPartialOrder, has_sup := has_sup }) →
motive t |
Matrix.transpose_fromRows | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} (A₁ : Matrix m₁ n R) (A₂ : Matrix m₂ n R),
(A₁.fromRows A₂).transpose = A₁.transpose.fromCols A₂.transpose |
LinearMap.ofIsCompl_eq_add | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {p q : Submodule R E} (hpq : IsCompl p q) {φ : ↥p →ₗ[R] F}
{ψ : ↥q →ₗ[R] F}, LinearMap.ofIsCompl hpq φ ψ = φ ∘ₗ p.linearProjOfIsCompl q hpq + ψ ∘ₗ q.linearProjOfIsCompl p ⋯ |
RingEquiv.prodProdProdComm._proof_3 | Mathlib.Algebra.Ring.Prod | ∀ (R : Type u_2) (R' : Type u_1) (S : Type u_4) (S' : Type u_3) [inst : NonAssocSemiring R]
[inst_1 : NonAssocSemiring S] [inst_2 : NonAssocSemiring R'] [inst_3 : NonAssocSemiring S'] (x y : (R × R') × S × S'),
(MulEquiv.prodProdProdComm R R' S S').toFun (x * y) =
(MulEquiv.prodProdProdComm R R' S S').toFun x * (MulEquiv.prodProdProdComm R R' S S').toFun y |
_private.Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily.0.CategoryTheory.PreZeroHypercoverFamily.mem_precoverage_iff.match_1_1 | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P : CategoryTheory.PreZeroHypercoverFamily C} {X : C}
(motive : (R : CategoryTheory.Presieve X) → R ∈ P.precoverage.coverings X → Prop) (R : CategoryTheory.Presieve X)
(x : R ∈ P.precoverage.coverings X),
(∀ (E : CategoryTheory.PreZeroHypercover X) (hE : P.property E), motive E.presieve₀ ⋯) → motive R x |
IO.FS.Mode.recOn | Init.System.IO | {motive : IO.FS.Mode → Sort u} →
(t : IO.FS.Mode) →
motive IO.FS.Mode.read →
motive IO.FS.Mode.write →
motive IO.FS.Mode.writeNew → motive IO.FS.Mode.readWrite → motive IO.FS.Mode.append → motive t |
Vector.flatMap_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {m : ℕ} {xs : Vector α n} {x : α} {f : α → Vector β m},
(xs.push x).flatMap f = Vector.cast ⋯ (xs.flatMap f ++ f x) |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.Internal.foldRev.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} (f : δ → (a : α) → β a → δ) (init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.Internal.foldRev f init b =
(Std.DHashMap.Raw.Internal.foldRevM (fun x1 x2 x3 => pure (f x1 x2 x3)) init b).run |
UInt8.reduceAdd | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Meta.Simp.DSimproc |
LocallyConstant.desc | Mathlib.Topology.LocallyConstant.Basic | {X : Type u_5} →
{α : Type u_6} →
{β : Type u_7} →
[inst : TopologicalSpace X] →
{g : α → β} → (f : X → α) → (h : LocallyConstant X β) → g ∘ f = ⇑h → Function.Injective g → LocallyConstant X α |
DFinsupp.filter.congr_simp | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] (p p_1 : ι → Prop),
p = p_1 →
∀ {inst_1 : DecidablePred p} [inst_2 : DecidablePred p_1] (x x_1 : Π₀ (i : ι), β i),
x = x_1 → DFinsupp.filter p x = DFinsupp.filter p_1 x_1 |
ComplexShape.TensorSigns.casesOn | Mathlib.Algebra.Homology.ComplexShapeSigns | {I : Type u_7} →
[inst : AddMonoid I] →
{c : ComplexShape I} →
{motive : c.TensorSigns → Sort u} →
(t : c.TensorSigns) →
((ε' : Multiplicative I →* ℤˣ) →
(rel_add : ∀ (p q r : I), c.Rel p q → c.Rel (p + r) (q + r)) →
(add_rel : ∀ (p q r : I), c.Rel p q → c.Rel (r + p) (r + q)) →
(ε'_succ : ∀ (p q : I), c.Rel p q → ε' q = -ε' p) →
motive { ε' := ε', rel_add := rel_add, add_rel := add_rel, ε'_succ := ε'_succ }) →
motive t |
CategoryTheory.Subobject.ofLEMk_comp | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} {X : CategoryTheory.Subobject B} {f : A ⟶ B}
[inst_1 : CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f),
CategoryTheory.CategoryStruct.comp (X.ofLEMk f h) f = X.arrow |
_private.Mathlib.Analysis.Normed.Group.Basic.0.enorm'_eq_iff_norm_eq._simp_1_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] (x : E), ‖x‖ₑ = ENNReal.ofReal ‖x‖ |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.tendsto_double_sum_S_act._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y |
ENat.toENNReal_strictMono | Mathlib.Data.Real.ENatENNReal | StrictMono ENat.toENNReal |
Lean.Elab.Tactic.throwOrLogError | Lean.Elab.Tactic.Basic | Lean.MessageData → Lean.Elab.Tactic.TacticM Unit |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycle.commute_iff._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {G : Type u_1} [inst : Group G] {g h : G}, (h ∈ Subgroup.zpowers g) = ∃ k, g ^ k = h |
descPochhammer_one | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (R : Type u) [inst : Ring R], descPochhammer R 1 = Polynomial.X |
Lean.Meta.Simp.Arith.Int.ToLinear.State.mk.inj | Lean.Meta.Tactic.Simp.Arith.Int.Basic | ∀ {varMap : Lean.Meta.KExprMap ℕ} {vars : Array Lean.Expr} {varMap_1 : Lean.Meta.KExprMap ℕ} {vars_1 : Array Lean.Expr},
{ varMap := varMap, vars := vars } = { varMap := varMap_1, vars := vars_1 } → varMap = varMap_1 ∧ vars = vars_1 |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.lt_find_iff._simp_1_2 | Mathlib.Data.Fin.Tuple.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x |
Set.fintypeUnion._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Set α) [inst_1 : Fintype ↑s] [inst_2 : Fintype ↑t] (x : α),
x ∈ s.toFinset ∪ t.toFinset ↔ x ∈ s ∪ t |
ContinuousAlternatingMap.instNormedSpace | Mathlib.Analysis.Normed.Module.Alternating.Basic | {𝕜 : Type u} →
{E : Type wE} →
{F : Type wF} →
{ι : Type v} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : SeminormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
[inst_5 : Fintype ι] →
{𝕜' : Type u_1} →
[inst_6 : NormedField 𝕜'] →
[inst_7 : NormedSpace 𝕜' F] → [SMulCommClass 𝕜 𝕜' F] → NormedSpace 𝕜' (E [⋀^ι]→L[𝕜] F) |
WithBot.bot_lt_coe | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] (a : α), ⊥ < ↑a |
Lean.Lsp.DiagnosticRelatedInformation.mk.noConfusion | Lean.Data.Lsp.Diagnostics | {P : Sort u} →
{location : Lean.Lsp.Location} →
{message : String} →
{location' : Lean.Lsp.Location} →
{message' : String} →
{ location := location, message := message } = { location := location', message := message' } →
(location = location' → message = message' → P) → P |
instInhabitedBool.default | Init.Prelude | Bool |
_private.Mathlib.LinearAlgebra.Matrix.Notation.0.Matrix.delabMatrixNotation._sparseCasesOn_1 | Mathlib.LinearAlgebra.Matrix.Notation | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
WeierstrassCurve.integralModel | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | (R : Type u_1) →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : Field K] →
[inst_2 : Algebra R K] → (W : WeierstrassCurve K) → [hW : WeierstrassCurve.IsIntegral R W] → WeierstrassCurve R |
_private.Mathlib.MeasureTheory.SetSemiring.0.MeasureTheory.IsSetSemiring.empty_notMem_disjointOfDiffUnion._simp_1_4 | Mathlib.MeasureTheory.SetSemiring | (¬True) = False |
_private.Std.Time.Date.Unit.Weekday.0.Std.Time.Weekday.toOrdinal.eq_5 | Std.Time.Date.Unit.Weekday | Std.Time.Weekday.friday.toOrdinal = 5 |
Int.fib_dvd | Mathlib.Data.Int.Fib.Basic | ∀ (m n : ℤ), m ∣ n → Int.fib m ∣ Int.fib n |
ZMod.inv | Mathlib.Data.ZMod.Basic | (n : ℕ) → ZMod n → ZMod n |
Aesop.instBEqPhaseName.beq | Aesop.Rule.Name | Aesop.PhaseName → Aesop.PhaseName → Bool |
AbsConvexOpenSets.coe_isOpen | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : TopologicalSpace E] [inst_1 : AddCommMonoid E] [inst_2 : SeminormedRing 𝕜]
[inst_3 : SMul 𝕜 E] [inst_4 : PartialOrder 𝕜] (s : AbsConvexOpenSets 𝕜 E), IsOpen ↑s |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.Ioo_disjoint_Ioo._simp_1_2 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} [DenselyOrdered α], (Set.Ioo a b = ∅) = ¬a < b |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.snd_of_toSubgraph_adj._proof_1_7 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u v v' : V} {p : G.Walk u v} (i : ℕ),
(p.getVert i = u ∧ p.getVert (i + 1) = v' ∨ p.getVert i = v' ∧ p.getVert (i + 1) = u) ∧ i < p.length →
i + 1 ≤ p.length |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.card_nthRoots._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {α : Type u_1} {s : Multiset α}, (s.card = 0) = (s = 0) |
Lean.Meta.Grind.Arith.Cutsat.SymbolicBound.rec | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | {motive : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound → Sort u} →
((val : Lean.Expr) → (ival? : Option ℤ) → motive { val := val, ival? := ival? }) →
(t : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound) → motive t |
Std.TreeSet.isNone_max?_eq_isEmpty | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.max?.isNone = t.isEmpty |
Std.TreeMap.Raw.size_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).size = if t.contains k = true then t.size else t.size + 1 |
Lean.reservedMacroScope | Init.Prelude | ℕ |
cfcₙ_comp_smul._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
Std.TreeMap.getKey!_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {k : α}, (t₁ ∪ t₂).getKey! k = t₂.getKeyD k (t₁.getKey! k) |
LinearMap.ker_eq_top._simp_1 | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂}, (f.ker = ⊤) = (f = 0) |
RegularWreathProduct.mk.injEq | Mathlib.GroupTheory.RegularWreathProduct | ∀ {D : Type u_1} {Q : Type u_2} (left : Q → D) (right : Q) (left_1 : Q → D) (right_1 : Q),
({ left := left, right := right } = { left := left_1, right := right_1 }) = (left = left_1 ∧ right = right_1) |
Field.Emb.Cardinal.leastExt.eq_1 | Mathlib.FieldTheory.CardinalEmb | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E],
Field.Emb.Cardinal.leastExt F E =
⋯.fix fun i ih =>
let s := Set.range fun j => (Field.Emb.Cardinal.wellOrderedBasis F E) (ih ↑j ⋯);
⋯.min {k | (Field.Emb.Cardinal.wellOrderedBasis F E) k ∉ IntermediateField.adjoin F s} ⋯ |
ContinuousAlgHom.coe_mk' | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(f : A →ₐ[R] B) (h : Continuous (↑↑f.toRingHom).toFun), ⇑{ toAlgHom := f, cont := h } = ⇑f |
ProbabilityTheory.variance_id_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal}, ProbabilityTheory.variance id (ProbabilityTheory.gaussianReal μ v) = ↑v |
Turing.PartrecToTM2.trStmts₁_supports' | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {S : Finset Turing.PartrecToTM2.Λ'} {q : Turing.PartrecToTM2.Λ'} {K : Finset Turing.PartrecToTM2.Λ'},
Turing.PartrecToTM2.Λ'.Supports S q →
Turing.PartrecToTM2.trStmts₁ q ∪ K ⊆ S →
(K ⊆ S → Turing.PartrecToTM2.Supports K S) → Turing.PartrecToTM2.Supports (Turing.PartrecToTM2.trStmts₁ q ∪ K) S |
Std.Time.Year.instSubOffset | Std.Time.Date.Unit.Year | Sub Std.Time.Year.Offset |
Lean.Elab.MonadAutoImplicits.recOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadAutoImplicits m → Sort u} →
(t : Lean.Elab.MonadAutoImplicits m) →
((getAutoImplicits : m (Array Lean.Expr)) → motive { getAutoImplicits := getAutoImplicits }) → motive t |
Associated.mul_mul | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] {a₁ a₂ b₁ b₂ : M},
Associated a₁ b₁ → Associated a₂ b₂ → Associated (a₁ * a₂) (b₁ * b₂) |
Submodule.generators_card | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M),
Cardinal.mk ↑p.generators = p.spanRank |
Ordinal.cof_eq_zero._simp_1 | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {o : Ordinal.{u_1}}, (o.cof = 0) = (o = 0) |
Polynomial.Splits.of_degree_eq_two | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Field R] {f : Polynomial R} {x : R}, f.degree = 2 → Polynomial.eval x f = 0 → f.Splits |
Height.AdmissibleAbsValues.mk._flat_ctor | Mathlib.NumberTheory.Height.Basic | {K : Type u_1} →
[inst : Field K] →
(archAbsVal : Multiset (AbsoluteValue K ℝ)) →
(nonarchAbsVal : Set (AbsoluteValue K ℝ)) →
(∀ v ∈ nonarchAbsVal, IsNonarchimedean ⇑v) →
(∀ {x : K}, x ≠ 0 → Function.HasFiniteMulSupport fun v => ↑v x) →
(∀ {x : K}, x ≠ 0 → (Multiset.map (fun x_2 => x_2 x) archAbsVal).prod * ∏ᶠ (v : ↑nonarchAbsVal), ↑v x = 1) →
Height.AdmissibleAbsValues K |
Plausible.GenError.ctorIdx | Plausible.Gen | Plausible.GenError → ℕ |
Fact.mk | Mathlib.Logic.Basic | ∀ {p : Prop}, p → Fact p |
Set.chainHeight_coe_univ | Mathlib.Order.Height | ∀ {α : Type u_1} (s : Set α) (r : α → α → Prop), (Set.univ.chainHeight fun x1 x2 => r ↑x1 ↑x2) = s.chainHeight r |
Valuation.restrict_le_iff_le_embedding | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
{x : R} {g : MonoidWithZeroHom.ValueGroup₀ v}, v.restrict x ≤ g ↔ v x ≤ MonoidWithZeroHom.ValueGroup₀.embedding g |
Lean.Lsp.FileChangeType.recOn | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.FileChangeType → Sort u} →
(t : Lean.Lsp.FileChangeType) →
motive Lean.Lsp.FileChangeType.Created →
motive Lean.Lsp.FileChangeType.Changed → motive Lean.Lsp.FileChangeType.Deleted → motive t |
BitVec.getLsbD_succ_last | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec (w + 1)), x.getLsbD w = decide (2 ^ w ≤ x.toNat) |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listEncode.match_1.eq_2 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(t₁ t₂ : L.Term (α ⊕ Fin x)) (h_1 : (n : ℕ) → motive n FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(h_3 :
(n l : ℕ) →
(R : L.Relations l) → (ts : Fin l → L.Term (α ⊕ Fin n)) → motive n (FirstOrder.Language.BoundedFormula.rel R ts))
(h_4 : (x : ℕ) → (φ₁ φ₂ : L.BoundedFormula α x) → motive x (φ₁.imp φ₂))
(h_5 : (x : ℕ) → (φ : L.BoundedFormula α (x + 1)) → motive x φ.all),
(match x, FirstOrder.Language.BoundedFormula.equal t₁ t₂ with
| n, FirstOrder.Language.BoundedFormula.falsum => h_1 n
| x, FirstOrder.Language.BoundedFormula.equal t₁ t₂ => h_2 x t₁ t₂
| n, FirstOrder.Language.BoundedFormula.rel R ts => h_3 n l R ts
| x, φ₁.imp φ₂ => h_4 x φ₁ φ₂
| x, φ.all => h_5 x φ) =
h_2 x t₁ t₂ |
CategoryTheory.Pseudofunctor.DescentData'.ofDescentData._proof_13 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_5} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(D : F.DescentData f) (i : ι),
CategoryTheory.Pseudofunctor.DescentData'.pullHom' (fun i₁ i₂ => D.hom (sq i₁ i₂).p (sq i₁ i₂).p₁ (sq i₁ i₂).p₂ ⋯ ⋯)
(f i) (CategoryTheory.CategoryStruct.id (X i)) (CategoryTheory.CategoryStruct.id (X i)) ⋯ ⋯ =
CategoryTheory.CategoryStruct.id ((F.map (CategoryTheory.CategoryStruct.id (X i)).op.toLoc).toFunctor.obj (D.obj i)) |
Composition.reverse_eq_ones | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {c : Composition n}, c.reverse = Composition.ones n ↔ c = Composition.ones n |
Lean.Syntax.instForInTopDownOfMonad.match_1 | Lean.Syntax | (motive : Lean.Syntax → Sort u_1) →
(stx : Lean.Syntax) →
((info : Lean.SourceInfo) →
(k : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node info k args)) →
((x : Lean.Syntax) → motive x) → motive stx |
Array.forIn'_eq_forIn' | Init.Data.Array.Basic | ∀ {α : Type u} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m], Array.forIn' = forIn' |
HahnSeries.embDomainRingHom._proof_4 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} [inst : AddCommMonoid Γ] [inst_1 : PartialOrder Γ] {Γ' : Type u_3}
[inst_2 : AddCommMonoid Γ'] [inst_3 : PartialOrder Γ'] [inst_4 : NonAssocSemiring R] (f : Γ →+ Γ')
(hfi : Function.Injective ⇑f) (hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') (x y : HahnSeries Γ R),
HahnSeries.embDomain { toFun := ⇑f, inj' := hfi, map_rel_iff' := ⋯ } (x + y) =
HahnSeries.embDomain { toFun := ⇑f, inj' := hfi, map_rel_iff' := ⋯ } x +
HahnSeries.embDomain { toFun := ⇑f, inj' := hfi, map_rel_iff' := ⋯ } y |
CategoryTheory.rightAdjointMate_comp | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.HasRightDual X] [inst_3 : CategoryTheory.HasRightDual Y] {f : X ⟶ Y} {g : Xᘁ ⟶ Z},
CategoryTheory.CategoryStruct.comp (fᘁ) g =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor Yᘁ).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Yᘁ (η_ X Xᘁ))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Yᘁ (CategoryTheory.MonoidalCategoryStruct.tensorHom f g))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Yᘁ Y Z).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight (ε_ Y Yᘁ) Z)
(CategoryTheory.MonoidalCategoryStruct.leftUnitor Z).hom)))) |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_10 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α],
i < (List.idxsOf x xs s).length → 0 < (List.findIdxs (fun x_1 => x_1 == x) xs).length |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.opEquiv.match_15.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u_1) (motive : CategoryTheory.WithInitial Cᵒᵖ → Sort u_2)
(h_1 : (x : Cᵒᵖ) → motive (CategoryTheory.WithInitial.of x)) (h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of x => h_1 x
| CategoryTheory.WithInitial.star => h_2 ()) =
h_2 () |
Std.ExtDTreeMap.getKey?_filterMap | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} {γ : α → Type w}
[inst : Std.TransCmp cmp] [inst_1 : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Option (γ a)} {k : α},
(Std.ExtDTreeMap.filterMap f t).getKey? k = (t.getKey? k).pfilter fun x h' => (f x (t.get x ⋯)).isSome |
withTheReader.eq_1 | Std.Do.Triple.SpecLemmas | ∀ (ρ : Type u) {m : Type u → Type v} [inst : MonadWithReaderOf ρ m] {α : Type u} (f : ρ → ρ) (x : m α),
withTheReader ρ f x = MonadWithReaderOf.withReader f x |
_private.Mathlib.Algebra.Exact.0.Function.Exact.inr_fst._simp_1_1 | Mathlib.Algebra.Exact | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x |
CategoryTheory.Functor.RightExtension.isUniversalEquivOfIso₂._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} H] [inst_2 : CategoryTheory.Category.{u_6, u_5} D]
{L : CategoryTheory.Functor C D} {F₁ F₂ : CategoryTheory.Functor C H} (α₁ : L.RightExtension F₁)
(α₂ : L.RightExtension F₂) (e : F₁ ≅ F₂) (e' : α₁.left ≅ α₂.left),
CategoryTheory.CategoryStruct.comp (L.whiskerLeft e'.hom) α₂.hom = CategoryTheory.CategoryStruct.comp α₁.hom e.hom →
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.whiskeringLeft C D H).obj L).map e'.hom) α₂.hom =
((L.rightExtensionEquivalenceOfIso₂ e).functor.obj α₁).hom |
_private.Mathlib.Order.Directed.0.Directed.mono.match_1_1 | Mathlib.Order.Directed | ∀ {α : Type u_2} {r : α → α → Prop} {ι : Sort u_1} {f : ι → α} (a b : ι)
(motive : (∃ z, r (f a) (f z) ∧ r (f b) (f z)) → Prop) (x : ∃ z, r (f a) (f z) ∧ r (f b) (f z)),
(∀ (c : ι) (h₁ : r (f a) (f c)) (h₂ : r (f b) (f c)), motive ⋯) → motive x |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.resolveDelayedMVarAssignments | Lean.Meta.Tactic.Grind.Main | Lean.Expr → Lean.MetaM Lean.Expr |
ContinuousLinearMap.adjointAux._proof_10 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
SMulCommClass 𝕜 𝕜 (StrongDual 𝕜 E) |
Function.bUnion_ptsOfPeriod | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} (f : α → α), ⋃ n, ⋃ (_ : n > 0), Function.ptsOfPeriod f n = Function.periodicPts f |
Lean.Meta.ExtractLetsConfig._sizeOf_inst | Init.MetaTypes | SizeOf Lean.Meta.ExtractLetsConfig |
ProbabilityTheory.cgf_undef | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t : ℝ},
¬MeasureTheory.Integrable (fun ω => Real.exp (t * X ω)) μ → ProbabilityTheory.cgf X μ t = 0 |
SemidirectProduct.equivProd_symm_apply_left | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N} (x : N × G),
(SemidirectProduct.equivProd.symm x).left = x.1 |
Turing.TM2to1.trNormal.eq_3 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (k : K) (a : σ → Option (Γ k) → σ)
(q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2to1.trNormal (Turing.TM2.Stmt.pop k a q) =
Turing.TM1.Stmt.goto fun x x_1 => Turing.TM2to1.Λ'.go k (Turing.TM2to1.StAct.pop a) q |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.