name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
TensorProduct.tmul_add | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m : M) (n₁ n₂ : N),
m ⊗ₜ[R] (n₁ + n₂) = m ⊗ₜ[R] n₁ + m ⊗ₜ[R] n₂ | true |
Metric.unitBall.instSemigroupWithZero._proof_2 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (x : ↑(Metric.ball 0 1)), x * 0 = 0 | false |
_private.Mathlib.Data.Int.CardIntervalMod.0.Int.Ico_filter_modEq_eq._simp_1_7 | Mathlib.Data.Int.CardIntervalMod | ∀ {n a b : ℤ}, (a ≡ b [ZMOD n]) = (n ∣ b - a) | false |
List.prefix_of_prefix_length_le | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ l₃ : List α}, l₁ <+: l₃ → l₂ <+: l₃ → l₁.length ≤ l₂.length → l₁ <+: l₂ | true |
HomotopicalAlgebra.ModelCategory.mk'._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty],
(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty | false |
Lean.instToJsonModuleArtifacts.toJson | Lean.Setup | Lean.ModuleArtifacts → Lean.Json | true |
MvPolynomial.IsHomogeneous.totalDegree | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] {φ : MvPolynomial σ R} {n : ℕ},
φ.IsHomogeneous n → φ ≠ 0 → φ.totalDegree = n | true |
CircleDeg1Lift.iterate_le_of_map_le_add_int | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) {x : ℝ} {m : ℤ}, f x ≤ x + ↑m → ∀ (n : ℕ), (⇑f)^[n] x ≤ x + ↑n * ↑m | true |
Padic.addValuation | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [hp : Fact (Nat.Prime p)] → AddValuation ℚ_[p] (WithTop ℤ) | true |
Ideal.span_union | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] (s t : Set α), Ideal.span (s ∪ t) = Ideal.span s ⊔ Ideal.span t | true |
Valuation.map_sub_eq_of_lt_left | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R}, v y < v x → v (x - y) = v x | true |
_private.Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology.0.IsValuativeTopology.instIsTopologicalAddGroup.match_1 | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : ValuativeRel R]
(γ : (MonoidWithZeroHom.ValueGroup₀ (ValuativeRel.valuation R))ˣ)
(motive :
(x : R × R) →
x ∈ {x | (ValuativeRel.valuation R).restrict x < ↑γ} ×ˢ {x | (ValuativeRel.valuation R).restrict x < ↑γ} → Prop)
(x : R × R)
(hx : x ∈ {x | (Valuativ... | false |
_private.Std.Time.Format.Basic.0.Std.Time.parseQuarterShort | Std.Time.Format.Basic | Std.Internal.Parsec.String.Parser Std.Time.Month.Quarter | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.VarInfo._sizeOf_1 | Lean.Compiler.LCNF.ExplicitRC | Lean.Compiler.LCNF.VarInfo✝ → ℕ | false |
FirstOrder.Language.LHom.sumInl_onFunction | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (_n : ℕ) (val : L.Functions _n),
FirstOrder.Language.LHom.sumInl.onFunction val = Sum.inl val | true |
_private.Init.Data.String.Decode.0.utf8DecodeChar?_eq_assemble₃._proof_2 | Init.Data.String.Decode | ∀ {b : ByteArray}, 3 ≤ b.size → ¬1 < b.size → False | false |
Subarray.start | Init.Data.Array.Subarray | {α : Type u_1} → Subarray α → ℕ | true |
Std.ExtTreeSet.max_erase_le_max | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{he : t.erase k ≠ ∅}, (cmp ((t.erase k).max he) (t.max ⋯)).isLE = true | true |
NormedRing.toNonUnitalNormedRing._proof_4 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedRing α] (n : ℕ) (a : α), Ring.zsmul (Int.negSucc n) a = -Ring.zsmul (↑n.succ) a | false |
Set.Ico_add_Ioc_subset | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Add α] [inst_1 : PartialOrder α] [AddLeftStrictMono α] [AddRightStrictMono α] (a b c d : α),
Set.Ico a b + Set.Ioc c d ⊆ Set.Ioo (a + c) (b + d) | true |
AddUnits.opEquiv._proof_4 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits Mᵃᵒᵖ), AddOpposite.unop ↑(-u) + AddOpposite.unop ↑u = 0 | false |
CompletelyDistribLattice.MinimalAxioms | Mathlib.Order.CompleteBooleanAlgebra | Type u → Type u | true |
Equiv.toHomeomorph._proof_3 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y),
(∀ (s : Set Y), IsOpen (⇑e ⁻¹' s) ↔ IsOpen s) → Continuous e.invFun | false |
UpperHemicontinuousWithinAt.eq_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α → Set β) (s : Set α)
(x : α), UpperHemicontinuousWithinAt f s x = SemicontinuousWithinAt (fun x t => t ∈ nhdsSet (f x)) s x | true |
Submodule.smul_comap_le_comap_smul | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type w}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') (S : Submodule R M') (I : Ideal R),
I • Submodule.comap f S ≤ Submodule.comap f (I • S) | true |
WeierstrassCurve.Affine.instDecidableEqPoint.decEq._proof_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type u_1} {inst : CommRing R} {W' : WeierstrassCurve.Affine R} (a a_1 : R) (a_2 : W'.Nonsingular a a_1),
a_2 = a_2 | false |
Finsupp.isCentralScalar | Mathlib.Data.Finsupp.SMulWithZero | ∀ (α : Type u_1) (M : Type u_5) {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M]
[inst_2 : SMulZeroClass Rᵐᵒᵖ M] [IsCentralScalar R M], IsCentralScalar R (α →₀ M) | true |
Lean.Elab.Term.Arg.stx.noConfusion | Lean.Elab.Arg | {P : Sort u} →
{val val' : Lean.Syntax} → Lean.Elab.Term.Arg.stx val = Lean.Elab.Term.Arg.stx val' → (val = val' → P) → P | false |
mersenne_le_mersenne._gcongr_1 | Mathlib.NumberTheory.LucasLehmer | ∀ {p q : ℕ}, p ≤ q → mersenne p ≤ mersenne q | false |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.IsReflection.conj._simp_1_1 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | false |
instIsContMDiffRiemannianBundleOfNatWithTopENat_2 | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | ∀ {EB : Type u_1} [inst : NormedAddCommGroup EB] [inst_1 : NormedSpace ℝ EB] {HB : Type u_2}
[inst_2 : TopologicalSpace HB] {IB : ModelWithCorners ℝ EB HB} {B : Type u_3} [inst_3 : TopologicalSpace B]
[inst_4 : ChartedSpace HB B] {F : Type u_4} [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace ℝ F]
{E : B → T... | true |
Polynomial.card_roots_sub_C | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R} {a : R},
0 < p.degree → ↑(p - Polynomial.C a).roots.card ≤ p.degree | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_of_containsKey_filterMap._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (p : α → Bool) (x : Option α), (Option.all p x = true) = ∀ (y : α), x = some y → p y = true | false |
CategoryTheory.BasedFunctor._sizeOf_inst | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
(𝒳 : CategoryTheory.BasedCategory 𝒮) →
(𝒴 : CategoryTheory.BasedCategory 𝒮) → [SizeOf 𝒮] → SizeOf (CategoryTheory.BasedFunctor 𝒳 𝒴) | false |
CategoryTheory.Square.rec | Mathlib.CategoryTheory.Square | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.Square C → Sort u_1} →
({X₁ X₂ X₃ X₄ : C} →
(f₁₂ : X₁ ⟶ X₂) →
(f₁₃ : X₁ ⟶ X₃) →
(f₂₄ : X₂ ⟶ X₄) →
(f₃₄ : X₃ ⟶ X₄) →
(fac : CategoryTheory.CategoryStruct.c... | false |
AList.insertRec._proof_1 | Mathlib.Data.List.AList | ∀ {α : Type u_1} {β : α → Type u_2}, WellFounded (invImage (fun x => x) sizeOfWFRel).1 | false |
Equiv.symm_image_subset._simp_1 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} (e : α ≃ β) (s : Set α) (t : Set β), (⇑e.symm '' t ⊆ s) = (t ⊆ ⇑e '' s) | false |
Padic.mulValuation._proof_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], (if 0 = 0 then 0 else WithZero.exp (-Padic.valuation 0)) = 0 | false |
Quiver.SingleObj.listToPath_pathToList | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Type u_1} {x : Quiver.SingleObj α} (p : Quiver.Path (Quiver.SingleObj.star α) x),
Quiver.SingleObj.listToPath (Quiver.SingleObj.pathToList p) = Quiver.Path.cast ⋯ ⋯ p | true |
Ordinal.add_log_le_log_mul | Mathlib.SetTheory.Ordinal.Exponential | ∀ {x y : Ordinal.{u_1}} (b : Ordinal.{u_1}), x ≠ 0 → y ≠ 0 → Ordinal.log b x + Ordinal.log b y ≤ Ordinal.log b (x * y) | true |
SimpleGraph.incidenceSetEquivNeighborSet._proof_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) (e : ↑(G.incidenceSet v)), ↑e ∈ G.incidenceSet v | false |
HahnSeries.cardSupp_congr | Mathlib.RingTheory.HahnSeries.Cardinal | ∀ {Γ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero S]
{x : HahnSeries Γ R} {y : HahnSeries Γ S}, x.support = y.support → x.cardSupp = y.cardSupp | true |
_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix._proof_2 | Lean.Util.Diff | ∀ {α : Type u_1} (left right : Subarray α) (i : ℕ),
i < Std.Slice.size left ∧ i < Std.Slice.size right → ¬Std.Slice.size right - i - 1 < Std.Slice.size right → False | false |
Std.HashSet.Equiv.diff_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₂.Equiv m₃ → (m₁ \ m₂).Equiv (m₁ \ m₃) | true |
Rep.hom_inv_rightUnitor | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : CommRing k] [inst_1 : Monoid G] {X : Rep.{u, u, v} k G},
Rep.Hom.hom (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv = ↑(Representation.TensorProduct.rid k X.ρ).symm | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.applyReplacementFun._proof_2 | Mathlib.Tactic.Translate.Core | ∀ (t : Mathlib.Tactic.Translate.TranslateData) (args : Array Lean.Expr) (n₀ : Lean.Name),
t.changeNumeral = true ∧
(match n₀ with
| `OfNat => true
| `OfNat.ofNat => true
| x => false) =
true ∧
2 ≤ args.size →
¬0 < args.size → False | false |
ApplicativeTransformation.mk.inj | Mathlib.Control.Traversable.Basic | ∀ {F : Type u → Type v} {inst : Applicative F} {G : Type u → Type w} {inst_1 : Applicative G}
{app : (α : Type u) → F α → G α} {preserves_pure' : ∀ {α : Type u} (x : α), app α (pure x) = pure x}
{preserves_seq' : ∀ {α β : Type u} (x : F (α → β)) (y : F α), app β (x <*> y) = app (α → β) x <*> app α y}
{app_1 : (α ... | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_36 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (tail : List α) {i : ℕ} (s : ℕ) (h : i + 1 ≤ (List.filter p tail).length),
(List.findIdxs p tail (s + 1))[i] - (s + 1) < tail.length | false |
_private.Mathlib.Geometry.Manifold.IntegralCurve.Basic.0.IsMIntegralCurveAt.hasMFDerivAt.match_1_1 | Mathlib.Geometry.Manifold.IntegralCurve.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {γ : ℝ → M}
{v : (x : M) → TangentSpace I x} {t₀ : ℝ} (motive : (∃ s ∈ nhds t₀, IsMIntegralCurv... | false |
Representation.apply_eq_of_coe_eq | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Group G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (S : Subgroup G)
[Representation.IsTrivial (MonoidHom.comp ρ S.subtype)] (g h : G), ↑g = ↑h → ρ g = ρ h | true |
Topology.RelCWComplex.iUnion_skeleton_eq_complex | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : T2Space X] [inst_1 : Topology.RelCWComplex C D],
⋃ n, ↑(Topology.RelCWComplex.skeleton C ↑n) = C | true |
Matrix.rank_mul_eq_left_of_isUnit_det | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {n : Type un} {R : Type uR} [inst : Fintype n] [inst_1 : CommRing R] [inst_2 : DecidableEq n]
(A : Matrix n n R) (B : Matrix m n R), IsUnit A.det → (B * A).rank = B.rank | true |
_private.Mathlib.Topology.Algebra.Valued.NormedValued.0.Valued.toNormedField._simp_21 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ (r₁ r₂ : NNReal), ↑r₁ * ↑r₂ = ↑(r₁ * r₂) | false |
RingHom.map_rat_algebraMap | Mathlib.Algebra.Algebra.Rat | ∀ {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Algebra ℚ R] [inst_3 : Algebra ℚ S]
(f : R →+* S) (r : ℚ), f ((algebraMap ℚ R) r) = (algebraMap ℚ S) r | true |
DirectLimit.instDivisionRing._proof_18 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.coeff_smul_right._simp_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
_private.Lean.Meta.MethodSpecs.0.Lean.getMethodSpecsInfo._sparseCasesOn_1 | Lean.Meta.MethodSpecs | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.disjoint_swap_swap._proof_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] {x y z t : α},
[x, y, z, t].Nodup → ∀ (x_1 : α), (Equiv.swap x y) x_1 = x_1 ∨ (Equiv.swap z t) x_1 = x_1 | false |
_private.Mathlib.Analysis.ODE.Gronwall.0.le_gronwallBound_of_liminf_deriv_right_le._simp_1_1 | Mathlib.Analysis.ODE.Gronwall | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (a ∈ Set.Ici a) = True | false |
Nat.getElem!_toList_roo_eq_zero | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, n ≤ i + (m + 1) → (m<...n).toList[i]! = 0 | true |
LieIdeal.mem_comap._simp_1 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {J : LieIdeal R L'} {x : L},
(x ∈ LieIdeal.comap f J) = (f x ∈ J) | false |
PadicInt.zmodRepr_eq_zero_iff_dvd | Mathlib.NumberTheory.Padics.RingHoms | ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)] {x : ℤ_[p]}, x.zmodRepr = 0 ↔ ↑p ∣ x | true |
Aesop.ScopeName.global | Aesop.Rule.Name | Aesop.ScopeName | true |
nnnormHom_apply | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] [inst_1 : NormOneClass α] [inst_2 : NormMulClass α] (x : α),
nnnormHom x = ‖x‖₊ | true |
Real.pow_div_factorial_le_exp | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℝ), 0 ≤ x → ∀ (n : ℕ), x ^ n / ↑n.factorial ≤ Real.exp x | true |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.Basic.0.Matrix.det_fromBlocks_zero₂₁._simp_1_8 | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
Lean.Elab.Tactic.ElimTargetView.ctorIdx | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimTargetView → ℕ | false |
Bialgebra.toCoalgebra | Mathlib.RingTheory.Bialgebra.Basic | {R : Type u} → {A : Type v} → {inst : CommSemiring R} → {inst_1 : Semiring A} → [self : Bialgebra R A] → Coalgebra R A | true |
Finset.prod_inv_index | Mathlib.Algebra.Group.Pointwise.Finset.BigOperators | ∀ {α : Type u_1} {ι : Type u_2} [inst : CommMonoid α] [inst_1 : DecidableEq ι] [inst_2 : InvolutiveInv ι] (s : Finset ι)
(f : ι → α), ∏ i ∈ s⁻¹, f i = ∏ i ∈ s, f i⁻¹ | true |
Neg.rec | Init.Prelude | {α : Type u} → {motive : Neg α → Sort u_1} → ((neg : α → α) → motive { neg := neg }) → (t : Neg α) → motive t | false |
MeasureTheory.SimpleFunc.instCommRing._proof_7 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : CommRing β],
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | false |
CategoryTheory.effectiveEpiFamilyStructOfComp._proof_3 | Mathlib.CategoryTheory.EffectiveEpi.Comp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {Z Y : I → C} {X : C}
(g : (i : I) → Z i ⟶ Y i) (f : (i : I) → Y i ⟶ X) {W : C} (φ : (a : I) → Y a ⟶ W) (m : X ⟶ W),
(∀ (a : I), CategoryTheory.CategoryStruct.comp (f a) m = φ a) →
∀ (i : I),
CategoryTheory.CategoryStruct.comp (... | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go_denote_eq._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight | ∀ {w : ℕ} (distance curr idx : ℕ), idx < w → w - 1 < w | false |
Lean.Meta.SynthInstance.Instance.ctorIdx | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.Instance → ℕ | false |
FreeMonoid.freeMonoidCongr_of | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_6} {β : Type u_7} (e : α ≃ β) (a : α),
(FreeMonoid.freeMonoidCongr e) (FreeMonoid.of a) = FreeMonoid.of (e a) | true |
Equiv.ofUnique._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ (α : Sort u_2) (β : Sort u_1) [inst : Unique α] [inst_1 : Unique β] (x : β), default (default x) = x | false |
String.toList_map | Init.Data.String.Lemmas.Modify | ∀ {f : Char → Char} {s : String}, (String.map f s).toList = List.map f s.toList | true |
Finset.compl_eq_univ_iff._simp_1 | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (s : Finset α), (sᶜ = Finset.univ) = (s = ∅) | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.addZ_smul._simp_1_4 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 2 = u * P 2 | false |
Lean.Attribute.Builtin.getPrio | Lean.Attributes | Lean.Syntax → Lean.AttrM ℕ | true |
Lean.Meta.CaseValuesSubgoal._sizeOf_inst | Lean.Meta.Match.CaseValues | SizeOf Lean.Meta.CaseValuesSubgoal | false |
AddMonoidHom.instDomMulActModule._proof_2 | Mathlib.Algebra.Module.Hom | ∀ {S : Type u_3} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring S] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module S M] (x : M →+ M₂), 0 • x = 0 | false |
CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_hom | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(G : CategoryTheory.Functor (J × K) C) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_4 : CategoryTheory.Limit... | true |
Squarefree.dvd_of_squarefree_of_mul_dvd_mul_left | Mathlib.Algebra.Squarefree.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [IsCancelMulZero R] {x y d : R} [DecompositionMonoid R],
Squarefree y → d * d ∣ x * y → d ∣ x | true |
Std.DTreeMap.Const.get?_eq_some_iff_exists_compare_eq_eq_and_mem_toList | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k : α}
{v : β}, Std.DTreeMap.Const.get? t k = some v ↔ ∃ k', cmp k k' = Ordering.eq ∧ (k', v) ∈ Std.DTreeMap.Const.toList t | true |
Relation.map_apply | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} {r : α → β → Prop} {f : α → γ} {g : β → δ} {c : γ}
{d : δ}, Relation.Map r f g c d ↔ ∃ a b, r a b ∧ f a = c ∧ g b = d | true |
List.Vector.traverse_def | Mathlib.Data.Vector.Basic | ∀ {n : ℕ} {F : Type u → Type u} [inst : Applicative F] {α β : Type u} (f : α → F β) (x : α) (xs : List.Vector α n),
List.Vector.traverse f (x ::ᵥ xs) = List.Vector.cons <$> f x <*> List.Vector.traverse f xs | true |
CovBy.lt_iff_le_right | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α}, y ⋖ x → ∀ {z : α}, y < z ↔ x ≤ z | true |
CategoryTheory.CategoryOfElements.map_map_coe | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor C (Type w)} (α : F₁ ⟶ F₂)
{t₁ t₂ : F₁.Elements} (k : t₁ ⟶ t₂), ↑((CategoryTheory.CategoryOfElements.map α).map k) = ↑k | true |
MonoidHom.snd._proof_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_2) (N : Type u_1) [inst : MulOneClass M] [inst_1 : MulOneClass N], 1.2 = 1.2 | false |
CategoryTheory.Subgroupoid.IsNormal.mk._flat_ctor | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {S : CategoryTheory.Subgroupoid C},
(∀ (c : C), CategoryTheory.CategoryStruct.id c ∈ S.arrows c c) →
(∀ {c d : C} (p : c ⟶ d) {γ : c ⟶ c},
γ ∈ S.arrows c c →
CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv p) (CategoryTheory.Categ... | false |
Std.HashMap.unitOfList_cons | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {hd : α} {tl : List α},
Std.HashMap.unitOfList (hd :: tl) = (∅.insertIfNew hd ()).insertManyIfNewUnit tl | true |
MeasureTheory.AEStronglyMeasurable.iUnion | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [Countable ι] [inst : TopologicalSpace β] {m₀ : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {f : α → β} [TopologicalSpace.PseudoMetrizableSpace β] {s : ι → Set α},
(∀ (i : ι), MeasureTheory.AEStronglyMeasurable f (μ.restrict (s i))) →
MeasureTheory.AEStronglyM... | true |
Lean.Widget.HighlightedMsgEmbed.rec_2 | Lean.Server.FileWorker.WidgetRequests | {motive_1 : Lean.Widget.HighlightedMsgEmbed → Sort u} →
{motive_2 : Lean.Widget.TaggedText Lean.Widget.HighlightedMsgEmbed → Sort u} →
{motive_3 :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.HighlightedMsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
... | false |
_private.Mathlib.Topology.UniformSpace.ProdApproximation.0.ContinuousMap.exists_finite_sum_smul_approximation_of_mem_uniformity._simp_1_4 | Mathlib.Topology.UniformSpace.ProdApproximation | ∀ {α : Type u} [inst : HasSubset α] [Std.Refl fun x1 x2 => x1 ⊆ x2] (a : α), (a ⊆ a) = True | false |
ENNReal.coe_ne_coe | Mathlib.Data.ENNReal.Basic | ∀ {p q : NNReal}, ↑p ≠ ↑q ↔ p ≠ q | true |
Module.Basis.finTwoProd | Mathlib.LinearAlgebra.Basis.Fin | (R : Type u_7) → [inst : Semiring R] → Module.Basis (Fin 2) R (R × R) | true |
MeasureTheory.eLpNormEssSup_indicator_const_le | Mathlib.MeasureTheory.Function.LpSeminorm.Indicator | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ε : Type u_7} [inst : TopologicalSpace ε]
[inst_1 : ESeminormedAddMonoid ε] (s : Set α) (c : ε), MeasureTheory.eLpNormEssSup (s.indicator fun x => c) μ ≤ ‖c‖ₑ | true |
_private.Mathlib.Algebra.Group.Basic.0.zsmul_zero.match_1_1 | Mathlib.Algebra.Group.Basic | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | false |
CategoryTheory.Lax.OplaxTrans.ctorIdx | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.LaxFunctor B C} → CategoryTheory.Lax.OplaxTrans F G → ℕ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.