name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.isType2Type._sparseCasesOn_2 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | false |
Rat.instNormedField | Mathlib.Analysis.Normed.Field.Lemmas | NormedField ℚ | true |
SimplexCategory.toTopHomeo_symm_naturality_apply | Mathlib.AlgebraicTopology.SimplicialSet.TopAdj | ∀ {n m : SimplexCategory} (f : n ⟶ m) (x : ↑(stdSimplex ℝ (Fin (n.len + 1)))),
m.toTopHomeo.symm (stdSimplex.map (⇑(CategoryTheory.ConcreteCategory.hom f)) x) =
(CategoryTheory.ConcreteCategory.hom (SSet.toTop.map (SSet.stdSimplex.map f))) (n.toTopHomeo.symm x) | true |
sqrt_one_add_norm_sq_le | Mathlib.Analysis.SpecialFunctions.JapaneseBracket | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (x : E), √(1 + ‖x‖ ^ 2) ≤ 1 + ‖x‖ | true |
instAddUInt32 | Init.Data.UInt.BasicAux | Add UInt32 | true |
CategoryTheory.GrothendieckTopology.Point.over | Mathlib.CategoryTheory.Sites.Point.Over | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
[CategoryTheory.LocallySmall.{w, v, u} C] → (Φ : J.Point) → {X : C} → Φ.fiber.obj X → (J.over X).Point | true |
CategoryTheory.GrothendieckTopology.Point.skyscraperSheafAdjunction_homEquiv_apply_val | Mathlib.CategoryTheory.Sites.Point.Skyscraper | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (Φ : J.Point)
{A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
[inst_3 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A] {F : CategoryTheory.Sheaf ... | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact.0.AlgebraicGeometry.instHasAffinePropertyQuasiCompactCompactSpaceCarrierCarrierCommRingCat._simp_2 | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s = CompactSpace ↑s | false |
div_right_injective | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {b : G}, Function.Injective fun a => b / a | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow._proof_1_3 | Init.Data.Nat.Bitwise.Lemmas | ∀ {n m : ℕ}, m < n → ¬m ≤ n → False | false |
Prod.mk_le_mk._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {a₁ a₂ : α} {b₁ b₂ : β},
((a₁, b₁) ≤ (a₂, b₂)) = (a₁ ≤ a₂ ∧ b₁ ≤ b₂) | false |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups.0.alternatingGroup.exists_mem_stabilizer_smul_eq._proof_1_3 | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} [inst : DecidableEq α] {t : Set α},
∀ a ∈ t, ∀ b ∈ t, ∀ c ∈ t, ∀ ⦃b_1 : α⦄, b_1 ∈ t → (⇑(Equiv.swap c a) ∘ ⇑(Equiv.swap a b)) b_1 ∈ t | false |
_private.Init.Data.UInt.Lemmas.0.UInt32.ofNat_mul._simp_1_1 | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt32), (UInt32.ofNat a = b) = (a % 2 ^ 32 = b.toNat) | false |
Lean.FileMap.lineStart | Lean.Data.Position | Lean.FileMap → ℕ → String.Pos.Raw | true |
SimpleGraph.isNIndepSet_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) (n : ℕ) (s : Finset α), G.IsNIndepSet n s ↔ G.IsIndepSet ↑s ∧ s.card = n | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_natAdd_Icc._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
CategoryTheory.Functor.LaxMonoidal.μ_whiskerRight_comp_μ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
F.obj (Category... | true |
Nat.gcd_sub_right_right_of_dvd | Init.Data.Nat.Gcd | ∀ {m k : ℕ} (n : ℕ), k ≤ m → n ∣ k → n.gcd (m - k) = n.gcd m | true |
FundamentalGroupoid.instIsEmpty | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (X : Type u_3) [IsEmpty X], IsEmpty (FundamentalGroupoid X) | true |
signedDist_vadd_right_swap | Mathlib.Geometry.Euclidean.SignedDist | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (v w : V) (p q : P), ((signedDist v) p) (w +ᵥ q) = ((signedDist v) (-w +ᵥ p)) q | true |
CategoryTheory.Lax.OplaxTrans.Hom._sizeOf_1 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.LaxFunctor B C} →
{η θ : F ⟶ G} → [SizeOf B] → [SizeOf C] → CategoryTheory.Lax.OplaxTrans.Hom η θ → ℕ | false |
hasFDerivAt_inv | Mathlib.Analysis.Calculus.Deriv.Inv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜},
x ≠ 0 → HasFDerivAt (fun x => x⁻¹) (ContinuousLinearMap.toSpanSingleton 𝕜 (-(x ^ 2)⁻¹)) x | true |
DenselyOrdered.rec | Mathlib.Order.Basic | {α : Type u_5} →
[inst : LT α] →
{motive : DenselyOrdered α → Sort u} →
((dense : ∀ (a₁ a₂ : α), a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂) → motive ⋯) → (t : DenselyOrdered α) → motive t | false |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Name.fromComponents.go._unsafe_rec | Mathlib.Lean.Expr.Basic | Lean.Name → List Lean.Name → Lean.Name | false |
Turing.ToPartrec.Cfg.ctorIdx | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Cfg → ℕ | false |
Nat.shiftLeft'._unsafe_rec | Mathlib.Data.Nat.Bits | Bool → ℕ → ℕ → ℕ | false |
_private.Init.Data.SInt.Lemmas.0.Int64.lt_iff_le_and_ne._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x ≤ y) = (x.toInt ≤ y.toInt) | false |
CategoryTheory.Bicategory.RightLift.mk | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f : b ⟶ a} →
{g : c ⟶ a} →
(h : c ⟶ b) → (CategoryTheory.CategoryStruct.comp h f ⟶ g) → CategoryTheory.Bicategory.RightLift f g | true |
Mathlib.Tactic.BicategoryLike.AtomIso.mk.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ (e : Lean.Expr) (src tgt : Mathlib.Tactic.BicategoryLike.Mor₁),
sizeOf { e := e, src := src, tgt := tgt } = 1 + sizeOf e + sizeOf src + sizeOf tgt | true |
Submodule.mem_adjoint_iff | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(g : Submodule 𝕜 (E × F)) (x : F × E),
x ∈ g.adjoint ↔ ∀ (a : E) (b : F), (a, b) ∈ g → inner 𝕜 b x.1 - inner 𝕜 a... | true |
CategoryTheory.Functor.pointwiseLeftKanExtensionCompIsoOfPreserves_fac_app | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B... | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.termProj | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.ParserDescr | true |
DeltaGenerated.instLargeCategory._aux_5 | Mathlib.Topology.Category.DeltaGenerated | {X Y Z : DeltaGenerated} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | false |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_12 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)) (k : Fin n),
↑j < ↑i → ¬↑k + 1 < ↑j → ↑k < ↑j → ¬↑k < ↑i → ↑k + 1 + 1 = ↑k + 1 | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic.0.tacticEval_simp | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | Lean.ParserDescr | true |
IsPrimitiveRoot.idealQuotient_mk | Mathlib.NumberTheory.NumberField.Ideal.Basic | ∀ {K : Type u_1} [inst : Field K] {I : Ideal (NumberField.RingOfIntegers K)} [inst_1 : NumberField K] {n : ℕ} [NeZero n]
{ζ : NumberField.RingOfIntegers K},
IsPrimitiveRoot ζ n → Ideal.absNorm I ≠ 1 → (Ideal.absNorm I).Coprime n → IsPrimitiveRoot ((Ideal.Quotient.mk I) ζ) n | true |
Stream'.WSeq.ofList_cons | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (a : α) (l : List α), ↑(a :: l) = Stream'.WSeq.cons a ↑l | true |
_private.Mathlib.NumberTheory.Divisors.0.Int.mul_mem_zero_one_two_three_four_iff._simp_1_1 | Mathlib.NumberTheory.Divisors | ∀ {x y z : ℤ}, z ≠ 0 → (x * y = z) = ((x, y) ∈ z.divisorsAntidiag) | false |
CompareReals.compareEquiv | Mathlib.Topology.UniformSpace.CompareReals | CompareReals.Bourbakiℝ ≃ᵤ ℝ | true |
Lean.Options.getInPattern | Lean.Data.Options | Lean.Options → Bool | true |
StandardEtalePair.instEtaleRing | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R), Algebra.Etale R P.Ring | true |
CategoryTheory.Equivalence.counitInv.eq_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D), e.counitInv = e.counitIso.inv | true |
MulSemiringActionHom.map_mul' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_10} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_12} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S]
(self : R →ₑ+*[φ] S) (x y : R), self.toFun (x * y) = self.toFun x * self.toFun y | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSliceFrom_ne_startPos._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} (p : s.Pos), (p ≠ s.startPos) = (s.startPos < p) | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.revMatchAt?_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt c pos pos' =
∃ (h : pos' ≠ s.startPos), pos = pos'.prev h ∧ (pos'.prev h).get ⋯ = c | false |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.ProtocolExtensionKind.ctorIdx | Lean.Server.ProtocolOverview | Lean.Server.Overview.ProtocolExtensionKind✝ → ℕ | false |
_private.Mathlib.Algebra.MvPolynomial.SchwartzZippel.0.MvPolynomial.schwartz_zippel_sup_sum._simp_1_5 | Mathlib.Algebra.MvPolynomial.SchwartzZippel | ∀ {a b c d : Prop}, ((a ∧ b) ∧ c ∧ d) = ((a ∧ c) ∧ b ∧ d) | false |
NonUnitalStarAlgHom.mk | Mathlib.Algebra.Star.StarAlgHom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : Monoid R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : DistribMulAction R A] →
[inst_3 : Star A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : DistribMulAction R B] →
... | true |
ContinuousOrderHom._sizeOf_inst | Mathlib.Topology.Order.Hom.Basic | (α : Type u_6) →
(β : Type u_7) →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : TopologicalSpace α} → {inst_3 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → SizeOf (α →Co β) | false |
Std.DTreeMap.isEmpty_toList | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.toList.isEmpty = t.isEmpty | true |
_private.Mathlib.Data.Int.Init.0.Int.le_induction_down._proof_1_3 | Mathlib.Data.Int.Init | ∀ {m : ℤ} {motive : (n : ℤ) → n ≤ m → Prop} (k : ℤ), m ≤ k → ∀ (hle' : k + 1 ≤ m), motive (k + 1) hle' | false |
HahnModule.instAddCommGroup._proof_9 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ] [inst_1 : SMul R V] [inst_2 : AddCommGroup V],
autoParam
(∀ (n : ℕ) (a : HahnModule Γ R V),
HahnModule.instAddCommGroup._aux_6 (↑n.succ) a = HahnModule.instAddCommGroup._aux_6 (↑n) a + a)
SubNegMonoid.zsmul_succ'._autoParam | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.toTriangle._simp_5 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | false |
Real.geom_mean_le_arith_mean3_weighted | Mathlib.Analysis.MeanInequalities | ∀ {w₁ w₂ w₃ p₁ p₂ p₃ : ℝ},
0 ≤ w₁ →
0 ≤ w₂ →
0 ≤ w₃ → 0 ≤ p₁ → 0 ≤ p₂ → 0 ≤ p₃ → w₁ + w₂ + w₃ = 1 → p₁ ^ w₁ * p₂ ^ w₂ * p₃ ^ w₃ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃ | true |
AddMonCat.HasLimits.limitConeIsLimit._proof_5 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddMonCat)
(s : CategoryTheory.Limits.Cone F) (x y : ↑s.1) {j j' : J} (f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.forget AddMonCat).mapCone s).π.app j)
((F.comp (CategoryTheory.forget AddMonCat)... | false |
AddMonoidHom.mulOp._proof_4 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) (x y : Mᵐᵒᵖ),
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) (x + y) =
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) x + (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) y | false |
CategoryTheory.comp_eqToHom_iff | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Y' : C} (p : Y = Y') (f : X ⟶ Y) (g : X ⟶ Y'),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom p) = g ↔
f = CategoryTheory.CategoryStruct.comp g (CategoryTheory.eqToHom ⋯) | true |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.foundLine | Init.Data.Format.Basic | Std.Format.SpaceResult✝ → Bool | true |
Ordinal.isNormal_veblen_zero | Mathlib.SetTheory.Ordinal.Veblen | Order.IsNormal fun x => Ordinal.veblen x 0 | true |
instContinuousSMulTangentSpace | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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] (_x : M), ContinuousSMul 𝕜 (TangentSpa... | true |
Cardinal.lift_sSup | Mathlib.SetTheory.Cardinal.Basic | ∀ {s : Set Cardinal.{u_1}}, BddAbove s → Cardinal.lift.{u, u_1} (sSup s) = sSup (Cardinal.lift.{u, u_1} '' s) | true |
_private.Mathlib.Order.ModularLattice.0.strictMono_inf_prod_sup.match_1_1 | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : Lattice α] {z : α} (_x _y : α)
(motive : (fun x => (x ⊓ z, x ⊔ z)) _y ≤ (fun x => (x ⊓ z, x ⊔ z)) _x → Prop)
(x : (fun x => (x ⊓ z, x ⊔ z)) _y ≤ (fun x => (x ⊓ z, x ⊔ z)) _x),
(∀ (inf_le : ((fun x => (x ⊓ z, x ⊔ z)) _y).1 ≤ ((fun x => (x ⊓ z, x ⊔ z)) _x).1)
(sup_le : ((fun x => (x ⊓... | false |
Lean.Parser.Term.letOpts.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | true |
LieAlgebra.SemiDirectSum.inl | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → (ψ : L →ₗ⁅R⁆ LieDerivation R K K) → K →ₗ⁅R⁆ K ⋊⁅ψ⁆ L | true |
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapPreimage | Mathlib.RingTheory.AdicCompletion.Exactness | {R : Type u} →
[inst : CommRing R] →
{I : Ideal R} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{N : Type w} →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{f : M →ₗ[R] N} →
Funct... | true |
CategoryTheory.Cat.equivOfIso._proof_3 | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : CategoryTheory.Cat} (γ : C ≅ D), γ.inv.toFunctor.comp γ.hom.toFunctor = CategoryTheory.Functor.id ↑D | false |
Finsupp.subtypeDomain_sub | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {G : Type u_8} [inst : AddGroup G] {p : α → Prop} {v v' : α →₀ G},
Finsupp.subtypeDomain p (v - v') = Finsupp.subtypeDomain p v - Finsupp.subtypeDomain p v' | true |
Std.HashMap.Raw.WF.filterMap | Std.Data.HashMap.AdditionalOperations | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β}
{f : α → β → Option γ}, m.WF → (Std.HashMap.Raw.filterMap f m).WF | true |
Std.TreeMap.getKey_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{hc : t.minKey! ∈ t}, t.getKey t.minKey! hc = t.minKey! | true |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.bindMutVarsFromTuple.go._sunfold | Lean.Elab.Do.Basic | Lean.Elab.Do.DoElabM Lean.Expr →
List Lean.Name → Lean.FVarId → Lean.Expr → Array Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr | false |
MonoidHom.toOneHom_coe | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N] (f : M →* N), ⇑↑f = ⇑f | true |
IsAddUnit.add_right_cancel | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : AddMonoid M] {a b c : M}, IsAddUnit b → a + b = c + b → a = c | true |
_private.Batteries.Data.MLList.Basic.0.MLList.ofArray.go._unsafe_rec | Batteries.Data.MLList.Basic | {m : Type → Type} → {α : Type} → Array α → ℕ → MLList m α | false |
OrderDual.ofDual_le_ofDual | Mathlib.Order.OrderDual | ∀ {α : Type u_1} [inst : LE α] {a b : αᵒᵈ}, OrderDual.ofDual a ≤ OrderDual.ofDual b ↔ b ≤ a | true |
List.append_eq | Init.Data.List.Basic | ∀ {α : Type u} {as bs : List α}, as.append bs = as ++ bs | true |
fderivWithin_of_mem_nhds | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s : Set E}, s ∈ nhds x → fderivWithin 𝕜 f s x = fder... | true |
_private.Mathlib.Analysis.Calculus.Taylor.0.taylor_integral_remainder_aux._proof_1_11 | Mathlib.Analysis.Calculus.Taylor | ∀ (n : ℕ), (↑n + 1) * ↑n.factorial = ↑(n.succ * n.factorial) | false |
RingHom.Finite.finiteType | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] {f : A →+* B}, f.Finite → f.FiniteType | true |
_private.Mathlib.Algebra.DirectSum.Internal.0.listProd_apply_eq_zero._simp_1_2 | Mathlib.Algebra.DirectSum.Internal | ∀ {α : Sort u_1} {a' : α} {P Q : α → Prop}, (∀ (a : α), a = a' ∨ Q a → P a) = (P a' ∧ ∀ (a : α), Q a → P a) | false |
_private.Mathlib.GroupTheory.Coset.Basic.0.Subgroup.quotientiInfSubgroupOfEmbedding._simp_3 | Mathlib.GroupTheory.Coset.Basic | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {h : ↥K}, (h ∈ H.subgroupOf K) = (↑h ∈ H) | false |
_private.Mathlib.AlgebraicGeometry.Cover.Sigma.0.AlgebraicGeometry.Scheme.Cover.presieve₀_sigma.match_1_1 | Mathlib.AlgebraicGeometry.Cover.Sigma | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : UnivLE.{u_2, u_1}]
{S : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S)
(motive :
(T : AlgebraicGeometry.Scheme) →
(g : T ⟶ S) → CategoryTheory.Presieve.singleton (CategoryTh... | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkSize.go.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(binderType b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.map_fst_toList_eq_keys._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Std.DHashMap.Raw.Const.get?_inter_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → Std.DHashMap.Raw.Const.get? (m₁ ∩ m₂) k = none | true |
Subalgebra.perfectClosure | Mathlib.FieldTheory.PurelyInseparable.Basic | (R : Type u_1) →
(A : Type u_2) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] → [inst_2 : Algebra R A] → (p : ℕ) → [ExpChar A p] → Subalgebra R A | true |
Int.modEq_sub_modulus_mul_iff | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, a ≡ b - n * c [ZMOD n] ↔ a ≡ b [ZMOD n] | true |
ProbabilityTheory.Kernel.iIndepFun.comp₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8} {γ : ι → Type u_9}
{mβ : (i : ι) → MeasurableSpace (β i)} {mγ : (i : ι) → MeasurableSpace (γ i)} {f : (i : ι) → Ω → β i},
Probability... | true |
Submodule.map._proof_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_2} {M₂ : Type u_1} [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₂}
[RingHomSurjective σ₁₂] (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R M) (c : R₂) {x : M₂}, x ∈ ⇑f '... | false |
Std.Do.Spec.forIn'_list._proof_5 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {xs : List α}, xs ++ [] = xs | false |
Std.TreeMap.Raw.minKeyD_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β} {fallback : α},
(t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' | true |
hasFDerivWithinAt_pi' | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {ι : Type u_6} {F' : ι → Type u_7}
[inst_3 : (i : ι) → NormedAddCommGroup (F' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i}
{Φ' : E →L[𝕜] ... | true |
Functor.map_unit | Init.Control.Lawful.Basic | ∀ {f : Type u_1 → Type u_2} [inst : Functor f] [LawfulFunctor f] {a : f PUnit.{u_1 + 1}},
(fun x => PUnit.unit) <$> a = a | true |
Sym.filterNe._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (m : Sym α n), (↑m).card < n + 1 | false |
Lean.IR.Expr.proj.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) → t.ctorIdx = 3 → ((i : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.proj i x)) → motive t | false |
SkewMonoidAlgebra.noConfusion | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {P : Sort u} →
{k : Type u_1} →
{G : Type u_2} →
{inst : Zero k} →
{t : SkewMonoidAlgebra k G} →
{k' : Type u_1} →
{G' : Type u_2} →
{inst' : Zero k'} →
{t' : SkewMonoidAlgebra k' G'} →
k = k' → G = G' → inst ≍ inst' → t ≍ t' → Sk... | false |
Vector.getElem?_append_right | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m i : ℕ} {xs : Vector α n} {ys : Vector α m}, n ≤ i → (xs ++ ys)[i]? = ys[i - n]? | true |
Lean.Level.collectMVars | Lean.Level | Lean.Level → optParam Lean.LMVarIdSet ∅ → Lean.LMVarIdSet | true |
NormedAddTorsor | Mathlib.Analysis.Normed.Group.AddTorsor | (V : outParam (Type u_1)) → (P : Type u_2) → [SeminormedAddCommGroup V] → [PseudoMetricSpace P] → Type (max u_1 u_2) | true |
SubMulAction.instSMulSubtypeMem._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_2} {M : Type u_1} [inst : SMul R M] (p : SubMulAction R M) (c : R) (x : ↥p), c • ↑x ∈ p | false |
ωCPO._sizeOf_1 | Mathlib.Order.Category.OmegaCompletePartialOrder | ωCPO → ℕ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.