name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
instCircularOrderZMod._aux_13 | Mathlib.Order.Circular.ZMod | (n : ℕ) → ZMod (n + 1) → ZMod (n + 1) → ZMod (n + 1) → Prop | null | false |
ISize.toNat_toBitVec | Init.Data.SInt.Lemmas | ∀ (x : ISize), x.toBitVec.toNat = x.toUSize.toNat | null | true |
_private.Mathlib.Data.List.Forall2.0.List.sublistForall₂_map_left_iff._simp_1_1 | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β},
List.SublistForall₂ R l₁ l₂ = ∃ l, List.Forall₂ R l₁ l ∧ l.Sublist l₂ | null | false |
_private.Mathlib.Data.Int.Range.0.Int.decidableLELT._simp_2 | Mathlib.Data.Int.Range | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CategoryTheory.OplaxFunctor.mk | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
(toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C) →
(mapId :
(a : B) →
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.id a) ⟶
... | null | true |
Std.Async.System.UserId.noConfusionType | Std.Async.System | Sort u → Std.Async.System.UserId → Std.Async.System.UserId → Sort u | null | false |
String.utf8Len_reverseAux | Batteries.Data.String.Lemmas | ∀ (cs₁ cs₂ : List Char), String.utf8Len (cs₁.reverseAux cs₂) = String.utf8Len cs₁ + String.utf8Len cs₂ | null | true |
Std.TreeSet.get?_eq_some_get | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {a : α} (h' : a ∈ t),
t.get? a = some (t.get a h') | null | true |
HomologicalComplex.mapBifunctor.d₁ | Mathlib.Algebra.Homology.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] →
{I₁ : Type u_4} →
{I₂ : Type u_5} →
{J : Type... | The first differential on a summand of `mapBifunctor K₁ K₂ F c` | true |
NonUnitalSubring.copy._proof_1 | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (S : NonUnitalSubring R) (s : Set R) (hs : s = ↑S) {a b : R},
a ∈ (S.copy s hs).carrier → b ∈ (S.copy s hs).carrier → a + b ∈ (S.copy s hs).carrier | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.mul_dvd_mul._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (a ∣ b) = (a.natAbs ∣ b.natAbs) | null | false |
CategoryTheory.Adjunction.leftAdjointOplaxMonoidal._proof_3 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) [inst_4 : G.LaxMonoi... | null | false |
AddMonoidAlgebra.coeffLinearEquiv_symm_apply | Mathlib.Algebra.MonoidAlgebra.Module | ∀ (R : Type u_1) {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S]
(a : M →₀ S), (AddMonoidAlgebra.coeffLinearEquiv R).symm a = AddMonoidAlgebra.ofCoeff a | null | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_sq_not_dvd_a_add_eta_sq_mul_b.match_1_1 | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ)
(motive :
(hζ.toInteger - 1) ^ 2 ∣
FermatLastTheoremForThreeGen.Solution'.a✝ (FermatLastTheoremForThreeGen.Solution.toSolution'✝ S) +
↑⋯.unit ^ 2 *
FermatLastTheoremFo... | null | false |
OrderEmbedding.dual | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → α ↪o β → αᵒᵈ ↪o βᵒᵈ | An order embedding is also an order embedding between dual orders. | true |
BitVec.cpopLayer._unary.eq_def | Init.Data.BitVec.Bitblast | ∀ {len w : ℕ} (oldLayer : BitVec (len * w))
(_x : (iterNum : ℕ) ×' (_ : BitVec (iterNum * w)) ×' 2 * (iterNum - 1) < len),
BitVec.cpopLayer._unary oldLayer _x =
PSigma.casesOn _x fun iterNum newLayer =>
PSigma.casesOn newLayer fun newLayer hold =>
if hlen : len - iterNum * 2 = 0 then
hav... | null | false |
MeasureTheory.convolution | Mathlib.Analysis.Convolution | {𝕜 : Type u𝕜} →
{G : Type uG} →
{E : Type uE} →
{E' : Type uE'} →
{F : Type uF} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup E'] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NontriviallyNormedField 𝕜] →
[inst... | The convolution of two functions `f` and `g` with respect to a continuous bilinear map `L` and
measure `μ`. It is defined to be `(f ⋆[L, μ] g) x = ∫ t, L (f t) (g (x - t)) ∂μ`. | true |
Homotopy.mkInductiveAux₂.eq_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1)
(comm_zero : e.f 0 = CategoryTheory.CategoryStruct.comp zero (Q.d 1 0)) (one : P.X 1 ⟶ Q.X 2)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp (P.d... | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceFinHAddNatOfNatProdIntCoreE₂CohomologicalFin._proof_8 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (k t : ℕ), ↑k + 1 + ↑t + (1 - (2 + ↑k)) = ↑t | null | false |
_private.Lean.Meta.Tactic.Grind.AC.Util.0.Lean.Meta.Grind.AC.isArithOpInOtherModules.match_1 | Lean.Meta.Tactic.Grind.AC.Util | (motive : Lean.Expr → Sort u_1) →
(f : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((x : Lean.Expr) → motive x) → motive f | null | false |
IsSemisimpleRing.exists_algEquiv_pi_matrix_divisionRing_finite | Mathlib.RingTheory.SimpleModule.WedderburnArtin | ∀ (R₀ : Type u_1) (R : Type u) [inst : CommSemiring R₀] [inst_1 : Ring R] [inst_2 : Algebra R₀ R] [IsSemisimpleRing R]
[Module.Finite R₀ R],
∃ n D d x x_1,
∃ (_ : ∀ (i : Fin n), Module.Finite R₀ (D i)),
(∀ (i : Fin n), NeZero (d i)) ∧ Nonempty (R ≃ₐ[R₀] (i : Fin n) → Matrix (Fin (d i)) (Fin (d i)) (D i)) | The **Wedderburn–Artin Theorem**, algebra form, finite case: a finite semisimple algebra is
isomorphic to a product of matrix algebras over finite division algebras. | true |
Substring.Raw.dropPrefix? | Init.Data.String.Substring | Substring.Raw → Substring.Raw → Option Substring.Raw | If `pre` is a prefix of `s`, returns the remainder. Returns `none` otherwise.
The substring `pre` is a prefix of `s` if there exists a `t : Substring` such that
`s.toString = pre.toString ++ t.toString`. If so, the result is the substring of `s` without the
prefix.
| true |
CompleteLattice.mk.noConfusion | Mathlib.Order.CompleteLattice.Defs | {α : Type u_4} →
{P : Sort u} →
{toLattice : Lattice α} →
{toSupSet : SupSet α} →
{isLUB_sSup : ∀ (s : Set α), IsLUB s (sSup s)} →
{toInfSet : InfSet α} →
{isGLB_sInf : ∀ (s : Set α), IsGLB s (sInf s)} →
{toBoundedOrder : BoundedOrder α} →
{toLatti... | null | false |
_private.Mathlib.MeasureTheory.Group.GeometryOfNumbers.0.MeasureTheory.exists_ne_zero_mem_lattice_of_measure_mul_two_pow_le_measure._simp_1_4 | Mathlib.MeasureTheory.Group.GeometryOfNumbers | ∀ {S : Type u_3} {M : outParam (Type u_4)} {inst : Zero M} {inst_1 : SetLike S M} [self : ZeroMemClass S M] (s : S),
(0 ∈ s) = True | null | false |
_private.Init.Data.List.Nat.Modify.0.List.drop_modify_of_lt._simp_1_1 | Init.Data.List.Nat.Modify | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = y) = (p → x = y) | null | false |
ENNReal.bot_lt_log_iff | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLog | ∀ {x : ENNReal}, ⊥ < x.log ↔ 0 < x | null | true |
Function.update_add | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} [inst : (i : I) → Add (f i)] [inst_1 : DecidableEq I] (f₁ f₂ : (i : I) → f i) (i : I)
(x₁ x₂ : f i), Function.update (f₁ + f₂) i (x₁ + x₂) = Function.update f₁ i x₁ + Function.update f₂ i x₂ | null | true |
Real.rpowIntegrand₀₁.eq_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ (p t x : ℝ), p.rpowIntegrand₀₁ t x = t ^ p * (t⁻¹ - (t + x)⁻¹) | null | true |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.PadicInt.instBinomialRing._simp_2 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {x y : ℤ_[p]}, (x = y) = (↑x = ↑y) | null | false |
Lean.Meta.Grind.Arith.CommRing.Semiring.noConfusionType | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Sort u → Lean.Meta.Grind.Arith.CommRing.Semiring → Lean.Meta.Grind.Arith.CommRing.Semiring → Sort u | null | false |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.intro1.match_4 | Lean.Meta.Tactic.Grind.Intro | (motive : Lean.FVarId × Lean.MVarId → Sort u_1) →
(x : Lean.FVarId × Lean.MVarId) →
((fvarId : Lean.FVarId) → (mvarId : Lean.MVarId) → motive (fvarId, mvarId)) → motive x | null | false |
Lean.PrettyPrinter.Delaborator.Context.recOn | Lean.PrettyPrinter.Delaborator.Basic | {motive : Lean.PrettyPrinter.Delaborator.Context → Sort u} →
(t : Lean.PrettyPrinter.Delaborator.Context) →
((optionsPerPos : Lean.PrettyPrinter.Delaborator.OptionsPerPos) →
(currNamespace : Lean.Name) →
(openDecls : List Lean.OpenDecl) →
(inPattern : Bool) →
(subExpr :... | null | false |
iInf_plift_down | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : InfSet α] (f : ι → α), ⨅ i, f i.down = ⨅ i, f i | null | true |
CategoryTheory.Arrow.AugmentedCechNerve.extraDegeneracy | Mathlib.AlgebraicTopology.ExtraDegeneracy | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(f : CategoryTheory.Arrow C) →
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] →
CategoryTheory.SplitEpi f.hom → f.augmentedCechNerve.ExtraDegeneracy | The augmented Čech nerve associated to a split epimorphism has an extra degeneracy. | true |
_private.Mathlib.RingTheory.DedekindDomain.Ideal.Basic.0.Ideal.uniqueFactorizationMonoid._simp_2 | Mathlib.RingTheory.DedekindDomain.Ideal.Basic | ∀ {A : Type u_1} {B : outParam (Type u_2)} {inst : Membership B A} {inst_1 : LE A} [self : IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
List.lex_eq_true_iff_lt._simp_1 | Init.Data.List.Lex | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] [inst_2 : LT α] [inst_3 : DecidableLT α] {l₁ l₂ : List α},
((l₁.lex l₂ fun x1 x2 => decide (x1 < x2)) = true) = (l₁ < l₂) | null | false |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pos.skipWhile.match_1.eq_2 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {s : String.Slice} (motive : Option s.Pos → Sort u_1) (h_1 : (nextCurr : s.Pos) → motive (some nextCurr))
(h_2 : Unit → motive none),
(match none with
| some nextCurr => h_1 nextCurr
| none => h_2 ()) =
h_2 () | null | true |
HomologicalComplex.homologicalComplexToDGO_map_f | Mathlib.Algebra.Homology.DifferentialObject | ∀ {β : Type u_1} [inst : AddCommGroup β] (b : β) (V : Type u_2) [inst_1 : CategoryTheory.Category.{v_1, u_2} V]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V] {X Y : HomologicalComplex V (ComplexShape.up' b)} (f : X ⟶ Y)
(i : β), ((HomologicalComplex.homologicalComplexToDGO b V).map f).f i = f.f i | null | true |
Lean.Meta.Grind.EMatch.checkSize | Lean.Meta.Tactic.Grind.EMatch | Lean.Expr → ℕ → Lean.MetaM Bool | Helper function for checking grind pattern constraints of the form `size e < threshold`
Implicit arguments and type information in lambdas and let-expressions are ignored.
| true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.M | Lean.Server.Completion.CompletionCollectors | Type → Type | Monad used for completion computation that allows modifying a completion `State` and reading
`CompletionParams`.
| true |
TrivSqZeroExt.inl | Mathlib.Algebra.TrivSqZeroExt.Basic | {R : Type u} → {M : Type v} → [Zero M] → R → TrivSqZeroExt R M | The canonical inclusion `R → TrivSqZeroExt R M`. | true |
StieltjesFunction._sizeOf_inst | Mathlib.MeasureTheory.Measure.Stieltjes | (R : Type u_1) → {inst : LinearOrder R} → {inst_1 : TopologicalSpace R} → [SizeOf R] → SizeOf (StieltjesFunction R) | null | false |
AlgebraicTopology.DoldKan.PInfty | Mathlib.AlgebraicTopology.DoldKan.PInfty | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X : CategoryTheory.SimplicialObject C} →
AlgebraicTopology.AlternatingFaceMapComplex.obj X ⟶ AlgebraicTopology.AlternatingFaceMapComplex.obj X | The endomorphism `PInfty : K[X] ⟶ K[X]` obtained from the `P q` by passing to the limit. | true |
List.Perm.bagInter | Mathlib.Data.List.Perm.Lattice | ∀ {α : Type u_1} [inst : DecidableEq α] {l₁ l₂ t₁ t₂ : List α},
l₁.Perm l₂ → t₁.Perm t₂ → (l₁.bagInter t₁).Perm (l₂.bagInter t₂) | null | true |
Bundle.contMDiffAt_section_of_subsingleton | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_3} (E : B → Type u_5) [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_4 : (x : B) → TopologicalSpace (E x)] {EB : Type u_6} [inst_5 : NormedAddCommG... | null | true |
Int8.toInt_minValue | Init.Data.SInt.Lemmas | Int8.minValue.toInt = -2 ^ 7 | null | true |
NNReal.sqrt_eq_iff_eq_sq | Mathlib.Analysis.Real.Sqrt | ∀ {x y : NNReal}, NNReal.sqrt x = y ↔ x = y ^ 2 | null | true |
ENNReal.coe_inv | Mathlib.Basic.ENNReal.Inv | ∀ {r : NNReal}, r ≠ 0 → ↑r⁻¹ = (↑r)⁻¹ | null | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
[inst_3 : CategoryTheory.BraidedCategory D] (F : CategoryTheory.Functor C (CategoryTheory.CommMon D)),
CategoryTheory.CategoryStruct.comp
... | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_14 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ)
(h : i < (List.filter p (head :: tail)).length),
¬(List.findIdxs p (head :: tail) s)[i] - s = 0 → (List.findIdxs p (head :: tail) s)[i] - (s + 1) < tail.length | null | false |
_private.Mathlib.Data.Nat.Sqrt.0.Nat.sqrt_succ_le_succ_sqrt._proof_1_1 | Mathlib.Data.Nat.Sqrt | ∀ n ≤ n.sqrt * n.sqrt + n.sqrt + n.sqrt, n.succ < n.sqrt.succ.succ * n.sqrt.succ.succ | null | false |
Lean.Grind.AC.diseq_erase_dup | Init.Grind.AC | ∀ {α : Sort u_1} (ctx : Lean.Grind.AC.Context α) {x : Std.Associative ctx.op} {x : Std.IdempotentOp ctx.op}
(lhs rhs lhs' rhs' : Lean.Grind.AC.Seq),
Lean.Grind.AC.eq_erase_dup_cert lhs rhs lhs' rhs' = true →
Lean.Grind.AC.Seq.denote ctx lhs ≠ Lean.Grind.AC.Seq.denote ctx rhs →
Lean.Grind.AC.Seq.denote ctx... | null | true |
_private.Mathlib.ModelTheory.Satisfiability.0.FirstOrder.Language.Theory.ModelsBoundedFormula.realize_sentence._simp_1_1 | Mathlib.ModelTheory.Satisfiability | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] (T : L.Theory), M ⊨ T = ∀ φ ∈ T, M ⊨ φ | null | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.sndFunctor | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor A B) →
(G : CategoryTheory.Functor C B) →
... | The "second projection" of a CatCommSqOver as a functor. | true |
FractionalIdeal.mul | Mathlib.RingTheory.FractionalIdeal.Basic | {R : Type u_3} →
[inst : CommRing R] →
{S : Submonoid R} →
{P : Type u_4} →
[inst_1 : CommRing P] → [inst_2 : Algebra R P] → FractionalIdeal S P → FractionalIdeal S P → FractionalIdeal S P | `FractionalIdeal.mul` is the product of two fractional ideals,
used to define the `Mul` instance.
This is only an auxiliary definition: the preferred way of writing `I.mul J` is `I * J`.
Elaborated terms involving `FractionalIdeal` tend to grow quite large,
so by making definitions irreducible, we hope to avoid deep ... | true |
LucasLehmer.X.instRing._proof_7 | Mathlib.NumberTheory.LucasLehmer | ∀ {q : ℕ} (x : LucasLehmer.X q), x ^ 0 = 1 | null | false |
LieAlgebra.Orthogonal.invertiblePD._proof_2 | Mathlib.Algebra.Lie.Classical | ∀ (l : Type u_2) (R : Type u_1) [inst : DecidableEq l] [inst_1 : CommRing R] [inst_2 : Fintype l],
IsDedekindFiniteMonoid (Matrix (l ⊕ l) (l ⊕ l) R) | null | false |
AddOpposite.instVAdd.eq_1 | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} {β : Type u_2} [inst : VAdd α β],
AddOpposite.instVAdd = { vadd := fun c x => AddOpposite.op (c +ᵥ AddOpposite.unop x) } | null | true |
OrderMonoidIsoClass.toOrderMonoidIso.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulOneClass α]
[inst_3 : MulOneClass β] [inst_4 : EquivLike F α β] [inst_5 : OrderIsoClass F α β] [inst_6 : MulEquivClass F α β]
(f : F), ↑f = { toMulEquiv := ↑f, map_le_map_iff' := ⋯ } | null | true |
_private.Mathlib.Algebra.Group.Subgroup.Basic.0.Subgroup.inf_normalizer_le_normalizer_sup._simp_1_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {g : G},
(g ∈ Subgroup.normalizer ↑H) = (Subgroup.map (↑(MulAut.conj g)) H = H) | null | false |
AddMonoidHom.addSubmonoidMap._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) (M' : AddSubmonoid M),
∃ a ∈ ↑M', f a = f ↑0 | null | false |
HasSubset.Subset.trans_ssubset | Mathlib.Order.RelClasses | ∀ {α : Type u_1} [UsesSetNotationForOrder α] [inst : Preorder α] {a b c : α}, a ⊆ b → b ⊂ c → a ⊂ c | **Alias** of `LE.le.trans_ssubset`.
---
Set notation form of `LE.le.trans_lt` | true |
ImportGraph.Widget.GoToModuleProps._sizeOf_inst | ImportGraph.Widget.GoToModule | SizeOf ImportGraph.Widget.GoToModuleProps | null | false |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_aux.match_1.eq_1 | Mathlib.NumberTheory.Padics.Hensel | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match 0 with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_1 () | null | true |
Lean.Compiler.LCNF.LetValue.oproj.sizeOf_spec | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (i : ℕ) (var : Lean.FVarId)
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_7),
sizeOf (Lean.Compiler.LCNF.LetValue.oproj i var h) = 1 + sizeOf i + sizeOf var + sizeOf h | null | true |
PointedCone.dual_neg | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {N : Type u_4} [inst_5 : AddCommGroup N] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R} {s : Set M}, PointedCone.dual p (-s) = -PointedCone.dual p s | null | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.ringEquivOfRingEquiv._simp_7 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{I : FractionalIdeal S P} {x : P}, (x ∈ ↑I) = (x ∈ I) | null | false |
CategoryTheory.Limits.IsLimit.assoc_lift | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {sXY : CategoryTheory.Limits.BinaryFan X Y}
{sYZ : CategoryTheory.Limits.BinaryFan Y Z} (P : CategoryTheory.Limits.IsLimit sXY)
(Q : CategoryTheory.Limits.IsLimit sYZ) {s : CategoryTheory.Limits.BinaryFan sXY.pt Z}
(R : CategoryTheory.Limits.IsL... | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportErrorData.recOn | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {motive : Lean.Meta.RefinedDiscrTree.ImportErrorData✝ → Sort u} →
(t : Lean.Meta.RefinedDiscrTree.ImportErrorData✝) →
((errors : IO.Ref (Array Lean.Meta.RefinedDiscrTree.ImportFailure✝)) → motive { errors := errors }) → motive t | null | false |
LinearMap.IsSymmetric.toSelfAdjoint._proof_1 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {T : E →ₗ[𝕜] E} (hT : T.IsSymmetric), IsSelfAdjoint { toLinearMap := T, cont := ⋯ } | null | false |
MeasureTheory.etvDist_of_not_isFiniteMeasure_right | Mathlib.MeasureTheory.Measure.TotalVariation.Defs | ∀ {𝓧 : Type u_1} {m𝓧 : MeasurableSpace 𝓧} {μ ν : MeasureTheory.Measure 𝓧},
¬MeasureTheory.IsFiniteMeasure ν → MeasureTheory.etvDist μ ν = ⊤ | null | true |
Lean.instMonadRefOfMonadLiftOfMonadFunctor | Init.Prelude | (m n : Type → Type) → [MonadLift m n] → [MonadFunctor m n] → [Lean.MonadRef m] → Lean.MonadRef n | null | true |
Equiv.sumSigmaDistrib_apply | Mathlib.Logic.Equiv.Sum | ∀ {α : Type u_10} {β : Type u_11} (t : α ⊕ β → Type u_9) (x : (i : α ⊕ β) × t i),
(Equiv.sumSigmaDistrib t) x =
match x with
| ⟨Sum.inl x, y⟩ => Sum.inl ⟨x, y⟩
| ⟨Sum.inr x, y⟩ => Sum.inr ⟨x, y⟩ | null | true |
CategoryTheory.Functor.instFaithfulOppositeTypeRestrictedULiftYonedaOfIsDense | Mathlib.CategoryTheory.Functor.KanExtension.Dense | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [F.IsDense], (CategoryTheory.Presheaf.restrictedULiftYoneda F).Faithful | null | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.clear_ok._simp_1_14 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {α : Type u_1} {a : α} {b : Option α}, (a ∈ b) = (b = some a) | null | false |
Float.Model.UnpackedFloat.Sign.instNeg.match_1 | Init.Data.Float.Model.Unpacked.Sign | (motive : Float.Model.UnpackedFloat.Sign → Sort u_1) →
(x : Float.Model.UnpackedFloat.Sign) →
(Unit → motive Float.Model.UnpackedFloat.Sign.negative) →
(Unit → motive Float.Model.UnpackedFloat.Sign.positive) → motive x | null | false |
hasSum_empty._simp_1 | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β} [IsEmpty β], HasSum f 0 L = True | null | false |
Lean.EnvExtension.AsyncMode.ctorElimType | Lean.Environment | {motive : Lean.EnvExtension.AsyncMode → Sort u} → ℕ → Sort (max 1 u) | null | false |
Matroid.IsBase.dep_of_ssubset | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {B X : Set α},
M.IsBase B → B ⊂ X → autoParam (X ⊆ M.E) Matroid.IsBase.dep_of_ssubset._auto_1 → M.Dep X | null | true |
_private.Mathlib.RingTheory.Polynomial.Chebyshev.0.Polynomial.Chebyshev.U_eval_zero_of_odd._simp_1_1 | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ {n : ℤ}, Even n = ¬Odd n | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.equiv_of_Z_eq_zero._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R},
P 2 = 0 → W'.Equation P = (P 1 ^ 2 = P 0 ^ 3) | null | false |
LinearMap.IsProj.top | Mathlib.LinearAlgebra.Projection | ∀ (S : Type u_5) [inst : Semiring S] (M : Type u_6) [inst_1 : AddCommMonoid M] [inst_2 : Module S M],
LinearMap.IsProj ⊤ LinearMap.id | null | true |
Set.Infinite.exists_ne_map_eq_of_mapsTo | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {f : α → β},
s.Infinite → Set.MapsTo f s t → t.Finite → ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ f x = f y | null | true |
TopologicalGroup.IsSES.pullback.eq_1 | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {E : Type u_4} [inst : Group A] [inst_1 : Group B] [inst_2 : Group C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] {φ : A →* B} {ψ : B →* C}
(H : TopologicalGroup.IsSES φ ψ) [inst_6 : IsTopologicalGroup A] [inst_7 : IsTopolo... | null | true |
CategoryTheory.Limits.PreservesBinaryBiproduct.mk | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {X Y : C}
{F : CategoryTheory.Functor C D} [inst_4 : F.PreservesZeroMorphisms],
(∀ {b : Ca... | null | true |
IsDiscreteValuationRing.toIsLocalRing | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u} {inst : CommRing R} {inst_1 : IsDomain R} [self : IsDiscreteValuationRing R], IsLocalRing R | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal._proof_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (Z : TopologicalSpace.Closeds ↥X) (U : ↑X.affineOpens)
(f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op))
(PrimeSpectrum.vanishingIdeal (⇑(AlgebraicGeometry.IsAffineOpen.fromSpec ⋯) ⁻¹' ↑Z)) =
PrimeSpect... | null | false |
CompactlySupportedContinuousMap.compNonUnitalAlgHom._proof_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {β : Type u_3} {γ : Type u_1} {δ : Type u_2} [inst : TopologicalSpace β] [inst_1 : TopologicalSpace γ]
[inst_2 : TopologicalSpace δ] {R : Type u_4} [inst_3 : Semiring R] [inst_4 : NonUnitalNonAssocSemiring δ]
[inst_5 : IsTopologicalSemiring δ] [inst_6 : Module R δ] [inst_7 : ContinuousConstSMul R δ] (g : Cocompac... | null | false |
MeasureTheory.Measure.integral_comp_smul | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {F : Type u_2}
[inst_6 : NormedAddCommGroup F] [inst_7 : NormedSpace ℝ F] (f : E → F) (R : ℝ),
∫ (x : E), f (R • x) ∂μ = ... | The integral of `f (R • x)` with respect to an additive Haar measure is a multiple of the
integral of `f`. The formula we give works even when `f` is not integrable or `R = 0`
thanks to the convention that a non-integrable function has integral zero. | true |
AddOpposite.instPartialOrder | Mathlib.Algebra.Order.Group.Opposite | {α : Type u_1} → [PartialOrder α] → PartialOrder αᵃᵒᵖ | null | true |
Module.Basis.groupSMul_span_eq_top | Mathlib.LinearAlgebra.Basis.SMul | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{G : Type u_5} [inst_3 : Group G] [inst_4 : SMul G R] [inst_5 : MulAction G M] [IsScalarTower G R M] {v : ι → M},
Submodule.span R (Set.range v) = ⊤ → ∀ {w : ι → G}, Submodule.span R (Set.range (w • v... | null | true |
BooleanAlgebra.ofRegular._proof_6 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (a b c : α), a ≤ b → a ≤ c → a ≤ Lattice.inf b c | null | false |
Std.HashMap.getKey_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α Unit} [EquivBEq α] [LawfulHashable α] {l : List α}
{k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → ∀ {h : k' ∈ m.insertManyIfNewUnit l}, (m.insertManyIfNewUnit l).getKey k' h = k | null | true |
List.reverse_perm'._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.reverse.Perm l₂ = l₁.Perm l₂ | null | false |
CategoryTheory.shrinkCoyonedaIsoCoyoneda_inv_app | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : Cᵒᵖ),
CategoryTheory.shrinkCoyonedaIsoCoyoneda.inv.app X =
(CategoryTheory.NatIso.ofComponents (fun Y => CategoryTheory.shrinkCoyonedaObjObjEquiv.toIso) ⋯).inv | null | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.Context.check | Lean.Meta.LetToHave | Lean.Meta.LetToHave.Context✝ → Bool | Returns `true` if we need to do full typechecking due to `let` variables being in scope. | true |
nonemptyFinLinOrdDualCompForgetToFinPartOrd._proof_2 | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ ⦃X Y : NonemptyFinLinOrd⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.forget₂ NonemptyFinLinOrd FinPartOrd).comp FinPartOrd.dual).map f)
(FinPartOrd.ofHom OrderHom.id) =
CategoryTheory.CategoryStruct.comp (FinPartOrd.ofHom OrderHom.id)
((NonemptyFinLinOrd.dual.comp (Categ... | null | false |
instSeparatingDual | Mathlib.Analysis.LocallyConvex.SeparatingDual | ∀ {E : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E],
SeparatingDual 𝕜 E | null | true |
Monoid.CoprodI.NeWord.mulHead.eq_1 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {i j : ι} (w : Monoid.CoprodI.NeWord M i j)
(x : M i) (hnotone : x * w.head ≠ 1), w.mulHead x hnotone = Monoid.CoprodI.NeWord.replaceHead (x * w.head) hnotone w | null | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.State.getFType | Lean.Elab.App | Lean.Elab.Term.ElabAppArgs.State → Lean.Expr | Gets `s.fType` with all loose bvars instantiated. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.