name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
instMinNat | Init.Prelude | Min ℕ | null | true |
Function.Injective.isLeftCancelAdd | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₁] [inst_1 : Add M₂] [IsLeftCancelAdd M₂] (f : M₁ → M₂),
Function.Injective f → (∀ (x y : M₁), f (x + y) = f x + f y) → IsLeftCancelAdd M₁ | A type has left-cancellative addition, if it admits an injective map that
preserves `+` to another type with left-cancellative addition. | true |
List.toFinset_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s : List α) (p : α → Bool),
(List.filter p s).toFinset = {x ∈ s.toFinset | p x = true} | null | true |
SSet.horn_ι_mem_innerHornInclusions | Mathlib.AlgebraicTopology.Quasicategory.InnerFibration | ∀ {n : ℕ} {i : Fin (n + 1)}, 0 < i → i < Fin.last n → SSet.innerHornInclusions (SSet.horn n i).ι | null | true |
Subgroup.isFiniteRelIndex_map_powMonoidHom_of_fg | Mathlib.GroupTheory.FiniteAbelian.Basic | ∀ {A : Type u_1} [inst : CommGroup A] {B : Subgroup A},
B.FG → ∀ {n : ℕ}, n ≠ 0 → (Subgroup.map (powMonoidHom n) B).IsFiniteRelIndex B | null | true |
UniformSpaceCat.completionFunctor._proof_2 | Mathlib.Topology.Category.UniformSpace | ∀ {X Y Z : UniformSpaceCat} (f : X ⟶ Y) (g : Y ⟶ Z),
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.ConcreteCategory.ofHom
⟨UniformSpace.Completion.map ⇑(CategoryTheory.CategoryStruct.comp f g).hom', ⋯⟩).hom) =
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct... | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.noConfusionType | Init.Data.Format.Basic | Sort u → Std.Format.WorkGroup✝ → Std.Format.WorkGroup✝ → Sort u | null | false |
integral_bilinear_hasLineDerivAt_right_eq_neg_left_of_integrable | Mathlib.Analysis.Calculus.LineDeriv.IntegrationByParts | ∀ {E : Type u_1} {F : Type u_2} {G : Type u_3} {W : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G]
[inst_6 : NormedAddCommGroup W] [inst_7 : NormedSpace ℝ W] [inst_8 : Measurable... | **Integration by parts for line derivatives**
Version with a general bilinear form `B`.
If `B f g` is integrable, as well as `B f' g` and `B f g'` where `f'` and `g'` are derivatives
of `f` and `g` in a given direction `v`, then `∫ B f g' = - ∫ B f' g`. | true |
BitVec.instHashable | Init.Data.BitVec.Basic | {n : ℕ} → Hashable (BitVec n) | null | true |
Aesop.Frontend.instInhabitedPriority.default | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority | null | true |
OrderRingHom.comp_id | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} {β : Type u_3} [inst : NonAssocSemiring α] [inst_1 : Preorder α] [inst_2 : NonAssocSemiring β]
[inst_3 : Preorder β] (f : α →+*o β), f.comp (OrderRingHom.id α) = f | null | true |
isLinearSet_iff_exists_fin_addMonoidHom | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M}, IsLinearSet s ↔ ∃ a n f, s = a +ᵥ Set.range ⇑f | null | true |
Real.sin_add_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℕ), Real.sin (x + ↑n * (2 * Real.pi)) = Real.sin x | null | true |
Std.DTreeMap.Internal.Impl.Const.minEntry._unary | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → (t : Std.DTreeMap.Internal.Impl α fun x => β) ×' t.isEmpty = false → α × β | Implementation detail of the tree map | false |
CochainComplex.HomComplex | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → CochainComplex C ℤ → CochainComplex C ℤ → CochainComplex AddCommGrpCat ℤ | The cochain complex of homomorphisms between two cochain complexes `F` and `G`.
In degree `n : ℤ`, it consists of the abelian group `HomComplex.Cochain F G n`. | true |
Char.reduceEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | Lean.Meta.Simp.Simproc | null | true |
UInt8.pow.match_1 | Init.Data.UInt.Basic | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | null | false |
_private.Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem.0.ValueDistribution.abs_characteristic_sub_characteristic_shift_le._simp_1_2 | Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | null | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem!_toArray_rio_eq_zero_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, ((m...n).toArray[i]! = 0) = (n ≤ i + m ∨ m = 0 ∧ i = 0) | null | false |
List.perm_reverse._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Perm l₂.reverse = l₁.Perm l₂ | null | false |
Vector.map_eq_flatMap | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {xs : Vector α n},
Vector.map f xs = Vector.cast ⋯ (xs.flatMap fun x => #v[f x]) | null | true |
ZFSet.diff | Mathlib.SetTheory.ZFC.Basic | ZFSet.{u} → ZFSet.{u} → ZFSet.{u} | The set difference operation | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.recOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.PreprocessKind✝ → Sort u} →
(t : Lean.Meta.PreprocessKind✝) →
motive Lean.Meta.PreprocessKind.noMVars✝ →
motive Lean.Meta.PreprocessKind.mvarsNoOutputParams✝ →
motive Lean.Meta.PreprocessKind.mvarsOutputParams✝ → motive t | null | false |
Ordnode.map.valid | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {β : Type u_2} [inst_1 : Preorder β] {f : α → β},
StrictMono f → ∀ {t : Ordnode α}, t.Valid → (Ordnode.map f t).Valid | null | true |
AdicCompletion.liftAlgHom._proof_2 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {S : Type u_1} [inst : CommRing S] (I : Ideal S) {m : ℕ}, (I ^ m).IsTwoSided | null | false |
CategoryTheory.createsColimitOfFullyFaithfulOfLift' | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | When `F` is fully faithful, to show that `F` creates the colimit for `K` it suffices to exhibit a
lift of a colimit cocone for `K ⋙ F`.
| true |
Con.commMagma | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_4} → [inst : CommMagma M] → (c : Con M) → CommMagma c.Quotient | The quotient of a commutative magma by a congruence relation is a commutative magma. | true |
finRotate_symm_apply | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {n : ℕ} (i : Fin n), (Equiv.symm (finRotate n)) i = i - 1 | null | true |
_private.Init.Data.List.MapIdx.0.List.mapFinIdx._proof_1 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (as as_1 : List α) (acc : Array β),
as_1.length + 1 + acc.size = as.length → ¬acc.size < as.length → False | null | false |
_private.Mathlib.Topology.EMetricSpace.Diam.0.Metric.ediam_pos_iff'._simp_1_1 | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} {s : Set X} [inst : EMetricSpace X], (0 < Metric.ediam s) = s.Nontrivial | null | false |
CategoryTheory.Factorisation.instCategory | Mathlib.CategoryTheory.Category.Factorisation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → {f : X ⟶ Y} → CategoryTheory.Category.{max u v, max u v} (CategoryTheory.Factorisation f) | null | true |
OneHom.instCommMonoid | Mathlib.Algebra.Group.Hom.Instances | {M : Type uM} → {N : Type uN} → [inst : One M] → [inst_1 : CommMonoid N] → CommMonoid (OneHom M N) | `OneHom M N` is a `CommMonoid` if `N` is commutative. | true |
Std.DHashMap.Raw.Const.all_eq_false_iff_exists_contains_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
{p : α → β → Bool},
m.WF → (m.all p = false ↔ ∃ a, ∃ (h : m.contains a = true), p a (Std.DHashMap.Raw.Const.get m a h) = false) | null | true |
iff_self_and._simp_1 | Init.SimpLemmas | ∀ {p q : Prop}, (p ↔ p ∧ q) = (p → q) | null | false |
add_eq_zero_iff_eq_neg | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a + b = 0 ↔ a = -b | null | true |
measurableSet_preimage_up._simp_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set (ULift.{u_6, u_1} α)},
MeasurableSet (ULift.up ⁻¹' s) = MeasurableSet s | null | false |
MvPolynomial.map_eval₂ | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {S₃ : Type x} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
(f : R →+* S₁) (g : S₂ → MvPolynomial S₃ R) (p : MvPolynomial S₂ R),
(MvPolynomial.map f) (MvPolynomial.eval₂ MvPolynomial.C g p) =
MvPolynomial.eval₂ MvPolynomial.C (⇑(MvPolynomial.map f) ∘ g) ((MvPolyno... | null | true |
MeasureTheory.integral_comp | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {E' : Type u_2} {F' : Type u_3} {A : Type u_4} [inst : NormedAddCommGroup E'] [inst_1 : InnerProductSpace ℝ E']
[inst_2 : FiniteDimensional ℝ E'] [inst_3 : MeasurableSpace E'] [inst_4 : BorelSpace E']
[inst_5 : NormedAddCommGroup F'] [inst_6 : InnerProductSpace ℝ F'] [inst_7 : FiniteDimensional ℝ F']
[inst_8 : ... | null | true |
Std.ExtHashMap.get_union_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (not_mem : k ∉ m₁) {h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).get k h' = m₂.get k ⋯ | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {v u : V} {p : G.Walk u v}, ∀ i' < p.length, i' ≤ p.length | null | false |
Fin.val_intCast | Mathlib.Data.ZMod.Defs | ∀ {n : ℕ} [inst : NeZero n] (x : ℤ), ↑↑x = (x % ↑n).toNat | null | true |
LinearPMap.comp | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
{T : Type u_3} →
[inst : Ring R] →
[inst_1 : Ring S] →
[inst_2 : Ring T] →
{σ : R →+* S} →
{τ : S →+* T} →
{E : Type u_4} →
[inst_3 : AddCommGroup E] →
[inst_4 : Module R E] →
... | Compose two `LinearPMap`s | true |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.isEmpty_slice._simp_1_2 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} (pos₁ pos₂ : (s.slice p₀ p₁ h).Pos),
(pos₁ = pos₂) = (String.Pos.ofSlice pos₁ = String.Pos.ofSlice pos₂) | null | false |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Ideal.isPrime_map_C_iff_isPrime._simp_1_4 | Mathlib.RingTheory.Polynomial.Basic | ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b₁ b₂ : β}, ((a₁, b₁) = (a₂, b₂)) = (a₁ = a₂ ∧ b₁ = b₂) | null | false |
NumberField.exists_ne_zero_mem_ideal_of_norm_le_mul_sqrt_discr | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
∃ a ∈ ↑I,
a ≠ 0 ∧
↑|(Algebra.norm ℚ) a| ≤
↑(FractionalIdeal.absNorm ↑I) * (4 / Real.pi) ^ NumberField.InfinitePlace.nrComplexPlaces K *
↑(Module.fin... | null | true |
AddMonoidHom.coe_snd | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddZeroClass N], ⇑(AddMonoidHom.snd M N) = Prod.snd | null | true |
Lean.Meta.Sym.Arith.State.mk.inj | Lean.Meta.Sym.Arith.Types | ∀ {exp : ℕ} {rings : Array Lean.Meta.Sym.Arith.CommRing} {semirings : Array Lean.Meta.Sym.Arith.CommSemiring}
{ncRings : Array Lean.Meta.Sym.Arith.Ring} {ncSemirings : Array Lean.Meta.Sym.Arith.Semiring}
{typeClassify : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Sym.Arith.ClassifyResult} {exp_1 : ℕ}
{rings_1 :... | null | true |
_private.Mathlib.Combinatorics.Enumerative.Catalan.Tree.0.BinaryTree.treesOfNumNodesEq_card_eq_catalan._simp_1_1 | Mathlib.Combinatorics.Enumerative.Catalan.Tree | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ s → a ∉ t | null | false |
KaehlerDifferential.mulActionBaseChange._proof_1 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A], SMulCommClass R R A | null | false |
CategoryTheory.Bicategory.«_aux_Mathlib_CategoryTheory_Bicategory_Basic___macroRules_CategoryTheory_Bicategory_term_◁ᵢ__1» | Mathlib.CategoryTheory.Bicategory.Basic | Lean.Macro | null | false |
MvQPF.wSetoid | Mathlib.Data.QPF.Multivariate.Constructions.Fix | {n : ℕ} → {F : TypeVec.{u} (n + 1) → Type u} → [q : MvQPF F] → (α : TypeVec.{u} n) → Setoid ((MvQPF.P F).W α) | Define the fixed point as the quotient of trees under the equivalence relation.
| true |
Lean.Elab.Term.LetIdDeclView._sizeOf_inst | Lean.Elab.Binders | SizeOf Lean.Elab.Term.LetIdDeclView | null | false |
ProbabilityTheory.condCDF_le_one | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α) (x : ℝ),
↑(ProbabilityTheory.condCDF ρ a) x ≤ 1 | The conditional cdf is lower or equal to 1 for all `a : α`. | true |
CategoryTheory.Monad.beckAlgebraCofork_pt | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra),
(CategoryTheory.Monad.beckAlgebraCofork X).pt = X | null | true |
AddCommMonCat.equivalence._proof_2 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddCommMonCat} (f : X ⟶ Y) (g : Y ⟶ Z),
CommMonCat.ofHom (AddMonoidHom.toMultiplicative (AddCommMonCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g))) =
CategoryTheory.CategoryStruct.comp (CommMonCat.ofHom (AddMonoidHom.toMultiplicative (AddCommMonCat.Hom.hom f)))
(CommMonCat.ofHom (AddMonoidH... | null | false |
LinearMap.piApply._proof_4 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R], SMulCommClass R R (M → R) | null | false |
AlgebraicGeometry.Scheme.Modules.restrictAdjunction._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f], IsOpenMap ⇑f | null | false |
Lean.Meta.Sym.Arith.State.mk | Lean.Meta.Sym.Arith.Types | ℕ →
Array Lean.Meta.Sym.Arith.CommRing →
Array Lean.Meta.Sym.Arith.CommSemiring →
Array Lean.Meta.Sym.Arith.Ring →
Array Lean.Meta.Sym.Arith.Semiring →
Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Sym.Arith.ClassifyResult → Lean.Meta.Sym.Arith.State | null | true |
_private.Mathlib.FieldTheory.Normal.Defs.0.AlgEquiv.restrictNormal_eq_one_iff._simp_1_2 | Mathlib.FieldTheory.Normal.Defs | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
Lean.Meta.Grind.Order.Cnstr.v | Lean.Meta.Tactic.Grind.Order.Types | {α : Type} → Lean.Meta.Grind.Order.Cnstr α → α | null | true |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.evalCast._sparseCasesOn_4 | Mathlib.Tactic.Ring.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) → (Nat.hasNotBit 512 t.ctorIdx → motive t) → motive t | null | false |
Lean.NameMapExtension | Batteries.Lean.NameMapAttribute | Type → Type | Environment extension that maps declaration names to `α`.
This uses a `Thunk` to avoid computing the name map when it isn't used. | true |
eqOn_of_cfcₙ_eq_cfcₙ._auto_7 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
_private.Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots.0.instFieldAdjoinPthRoots._aux_70 | Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots | (k : Type u_1) → [Field k] → ℚ → AdjoinPthRoots k → AdjoinPthRoots k | null | false |
pi_norm_le_iff_of_nonempty' | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedGroup (G i)] (f : (i : ι) → G i)
{r : ℝ} [Nonempty ι], ‖f‖ ≤ r ↔ ∀ (b : ι), ‖f b‖ ≤ r | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean.0.NNReal.bddAbove_range_agmSequences_fst._simp_1_2 | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
AlgebraicGeometry.spread_out_unique_of_isGermInjective | Mathlib.AlgebraicGeometry.SpreadingOut | ∀ {X Y : AlgebraicGeometry.Scheme} {x : ↥X} [X.IsGermInjectiveAt x] (f g : X ⟶ Y) (e : f x = g x),
AlgebraicGeometry.Scheme.Hom.stalkMap f x =
CategoryTheory.CategoryStruct.comp (Y.presheaf.stalkSpecializes ⋯) (AlgebraicGeometry.Scheme.Hom.stalkMap g x) →
∃ U, x ∈ U ∧ CategoryTheory.CategoryStruct.comp U.ι ... | Let `x : X` and `f g : X ⟶ Y` be two morphisms such that `f x = g x`.
If `f` and `g` agree on the stalk of `x`, then they agree on an open neighborhood of `x`,
provided `X` is "germ-injective" at `x` (e.g. when it's integral or locally Noetherian).
TODO: The condition on `X` is unnecessary when `Y` is locally of finit... | true |
_private.Mathlib.Algebra.Polynomial.Eval.Defs.0.Polynomial.eval_natCast._simp_1_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (n : ℕ), ↑n = Polynomial.C ↑n | null | false |
StarAlgEquiv.coe_pow | Mathlib.Algebra.Star.StarAlgHom | ∀ {S : Type u_1} {R : Type u_2} [inst : Mul R] [inst_1 : Add R] [inst_2 : Star R] [inst_3 : SMul S R] (f : R ≃⋆ₐ[S] R)
(n : ℕ), ⇑(f ^ n) = (⇑f)^[n] | null | true |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.tendsto_density_fst_atTop_ae_of_monotone._simp_1_1 | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
Std.TreeSet.Raw.foldr_eq_foldr_toArray | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} {δ : Type w} {f : α → δ → δ} {init : δ},
Std.TreeSet.Raw.foldr f init t = Array.foldr f init t.toArray | null | true |
RingEquiv.restrict._proof_5 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_3} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {σR : Type u_4}
{σS : Type u_2} [inst_2 : SetLike σR R] [inst_3 : SetLike σS S] [inst_4 : SubsemiringClass σR R]
[inst_5 : SubsemiringClass σS S] (e : R ≃+* S) (s' : σR) (s : σS) (h : ∀ (x : R), x ∈ s' ↔ e x ∈ s) (x : ↥s),
(... | null | false |
_private.Aesop.Rule.0.Aesop.instBEqRegularRule.beq._sparseCasesOn_2 | Aesop.Rule | {motive : Aesop.RegularRule → Sort u} →
(t : Aesop.RegularRule) →
((r : Aesop.UnsafeRule) → motive (Aesop.RegularRule.unsafe r)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.ShortComplex.RightHomologyMapData.ofIsLimitKernelFork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(c₂ : CategoryTheory.Limits.KernelFork S₂.g) (f : c₁.pt ⟶ c₂.pt),
CategoryTheory.CategoryStruct.comp... | null | false |
_private.Mathlib.Analysis.Asymptotics.Completion.0.«term_̂» | Mathlib.Analysis.Asymptotics.Completion | Lean.TrailingParserDescr | null | true |
ContMDiff.along_snd | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : 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 : NormedAddComm... | **Alias** of `ContMDiff.curry_right`.
---
Curried `C^n` functions are `C^n` in the second coordinate. | true |
_private.Mathlib.Topology.Sequences.0.FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto._simp_1_6 | Mathlib.Topology.Sequences | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.pairingCore.IsIndex.eq_of_isType₂_δ._proof_1_4 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {u : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N}
{l : Fin (u.dim + 1)} (i : Fin (u.dim + 2)), l.succ < i → ¬l = Fin.last u.dim | null | false |
RingHomInvPair.toRingEquiv_apply | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] (σ : R₁ →+* R₂) (σ' : R₂ →+* R₁)
[inst_2 : RingHomInvPair σ σ'] (a : R₁), (RingHomInvPair.toRingEquiv σ σ') a = σ a | null | true |
CategoryTheory.coyonedaLemma.eq_1 | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.coyonedaLemma C =
CategoryTheory.NatIso.ofComponents (fun x => (CategoryTheory.coyonedaEquiv.trans Equiv.ulift.symm).toIso) ⋯ | null | true |
Std.IterM.findM?_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β] [inst_2 : Std.IteratorLoop α m m]
[LawfulMonad m] [Std.Iterators.Finite α m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β}
{f : β → m (ULift.{w, 0} Bool)},
it.findM? f = do
let __do_lift ← it.step
match ↑__do_lift... | null | true |
Option.attachWith_some._proof_1 | Init.Data.Option.Attach | ∀ {α : Type u_1} {x : α} {P : α → Prop}, (∀ (b : α), some x = some b → P b) → P x | null | false |
PrincipalSeg.transInitial_top | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
(f : PrincipalSeg r s) (g : InitialSeg s t), (f.transInitial g).top = g f.top | null | true |
MonoidAlgebra.mapRangeAlgAut_apply | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_1) {A : Type u_4} (M : Type u_7) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Monoid M] (f : A ≃ₐ[R] A), (MonoidAlgebra.mapRangeAlgAut R M) f = MonoidAlgebra.mapAlgEquiv R M f | null | true |
AlgebraicGeometry.Scheme.precoverage_le_qcPrecoverage_of_isOpenMap | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme},
(P ≤ fun x x_1 f => IsOpenMap ⇑f) → AlgebraicGeometry.Scheme.precoverage P ≤ AlgebraicGeometry.Scheme.qcPrecoverage | If `P` implies being an open map, the by `P` induced precoverage is coarser
than the quasi-compact precoverage. | true |
ContinuousLinearMapWOT.seminorm._proof_3 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_4} {𝕜₂ : Type u_1} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_2} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [inst_8 : IsTopologi... | null | false |
Subspace.dualAnnihilator_dualAnnihilator_eq | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : FiniteDimensional K V] (W : Subspace K V),
(Submodule.dualAnnihilator W).dualAnnihilator = (Module.mapEvalEquiv K V) W | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.zero_lt_getElem!_toList_ric_iff._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
Std.Tactic.BVDecide.LRAT.Internal.Entails.noConfusionType | Std.Tactic.BVDecide.LRAT.Internal.Entails | Sort u_1 →
{α : Type u} →
{β : Type v} →
Std.Tactic.BVDecide.LRAT.Internal.Entails α β →
{α' : Type u} → {β' : Type v} → Std.Tactic.BVDecide.LRAT.Internal.Entails α' β' → Sort u_1 | null | false |
String.Slice.Pattern.Model.ForwardSliceSearcher.matchesAt_iff_getElem._proof_2 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos : s.Pos},
pos.offset.byteIdx + pat.copy.toByteArray.size ≤ s.copy.toByteArray.size →
∀ j < pat.copy.toByteArray.size, pos.offset.byteIdx + j < s.copy.toByteArray.size | null | false |
PadicInt.mahlerSeries_apply | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : Module ℤ_[p] E]
[inst_2 : IsBoundedSMul ℤ_[p] E] [IsUltrametricDist E] [CompleteSpace E] {a : ℕ → E},
Filter.Tendsto a Filter.atTop (nhds 0) → ∀ (x : ℤ_[p]), (PadicInt.mahlerSeries a) x = ∑' (n : ℕ), (mahler n) x • a n | Evaluation of a Mahler series is just the pointwise sum. | true |
Real.ofDigitsTerm_le | Mathlib.Analysis.Real.OfDigits | ∀ {b : ℕ} {digits : ℕ → Fin b} {n : ℕ}, Real.ofDigitsTerm digits n ≤ (↑b - 1) * (↑b ^ (n + 1))⁻¹ | null | true |
LieDerivation.SMulBracketCommClass.mk._flat_ctor | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {S : Type u_4} {L : Type u_5} {α : Type u_6} [inst : SMul S α] [inst_1 : LieRing L] [inst_2 : AddCommGroup α]
[inst_3 : LieRingModule L α],
(∀ (s : S) (l : L) (a : α), s • ⁅l, a⁆ = ⁅l, s • a⁆) → LieDerivation.SMulBracketCommClass S L α | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_slope_of_ne._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
MulOpposite.instCoalgebra._proof_8 | Mathlib.RingTheory.Coalgebra.MulOpposite | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A],
SMulCommClass R R (TensorProduct R Aᵐᵒᵖ R) | null | false |
_private.Lean.ParserCompiler.0.Lean.ParserCompiler.parserNodeKind?._sparseCasesOn_1 | Lean.ParserCompiler | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool)... | null | false |
CategoryTheory.FreeBicategory.Hom.brecOn.eq | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {motive : (a a_1 : B) → CategoryTheory.FreeBicategory.Hom a a_1 → Sort u_1} {a a_1 : B}
(t : CategoryTheory.FreeBicategory.Hom a a_1)
(F_1 :
(a a_2 : B) →
(t : CategoryTheory.FreeBicategory.Hom a a_2) → CategoryTheory.FreeBicategory.Hom.below t → motive a a_2 t),
Categor... | null | true |
Graph.isLink_self_iff | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G : Graph α β}, G.IsLink e x x ↔ G.IsLoopAt e x | null | true |
ContinuousMap.instCommCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : CommCStarAlgebra A],
CompleteSpace C(α, A) | null | false |
CategoryTheory.Pretriangulated.productTriangle_obj₁ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
(T : J → CategoryTheory.Pretriangulated.Triangle C) [inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁]
[inst_3 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₂]
[inst_4 : CategoryTheor... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.