name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UniqueFactorizationMonoid.recOn | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | {α : Type u_2} →
[inst : CommMonoidWithZero α] →
{motive : UniqueFactorizationMonoid α → Sort u} →
(t : UniqueFactorizationMonoid α) →
([toIsCancelMulZero : IsCancelMulZero α] →
[toWellFounded : WellFounded DvdNotUnit] →
(irreducible_iff_prime : ∀ {a : α}, Irreducible a ↔ P... | null | false |
Polynomial.Bivariate.equivMvPolynomial_symm_X_0 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R],
(Polynomial.Bivariate.equivMvPolynomial R).symm (MvPolynomial.X 0) = Polynomial.C Polynomial.X | null | true |
Lean.AssocList.brecOn.eq | Lean.Data.AssocList | ∀ {α : Type u} {β : Type v} {motive : Lean.AssocList α β → Sort u_1} (t : Lean.AssocList α β)
(F_1 : (t : Lean.AssocList α β) → Lean.AssocList.below t → motive t),
Lean.AssocList.brecOn t F_1 = F_1 t (Lean.AssocList.brecOn.go t F_1).2 | null | true |
CategoryTheory.Bicategory.associator_naturality_middle | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g') (h : c ⟶ d),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerLeft f η) h)
(CategoryTheory.Bicategory.associator f g' h).hom =
CategoryT... | null | true |
Std.DTreeMap.Internal.Impl.maxEntry.induct_unfolding | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v}
(motive : (t : Std.DTreeMap.Internal.Impl α β) → t.isEmpty = false → (a : α) × β a → Prop),
(∀ (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β)
(x : (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf).isEmpty = false),
(Std.DTree... | null | true |
ProbabilityTheory.Kernel.measurable_rnDeriv_right | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] (κ η : ProbabilityTheory.Kernel α γ) (a : α),
Measurable fun x => κ.rnDeriv η a x | null | true |
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.isCoboundedUnder_ge_toReal._simp_1_2 | Mathlib.Order.Filter.ENNReal | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {P : β → Prop},
(∀ᶠ (b : β) in Filter.map m f, P b) = ∀ᶠ (a : α) in f, P (m a) | null | false |
CategoryTheory.Limits.PullbackCone.pasteHoriz.congr_simp | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₃ Y₁ Y₂ Y₃ : C} {g₁ : Y₁ ⟶ Y₂} {g₂ : Y₂ ⟶ Y₃} {i₃ : X₃ ⟶ Y₃}
(t₂ : CategoryTheory.Limits.PullbackCone g₂ i₃) {i₂ : t₂.pt ⟶ Y₂}
(t₁ t₁_1 : CategoryTheory.Limits.PullbackCone g₁ i₂),
t₁ = t₁_1 → ∀ (hi₂ : i₂ = t₂.fst), t₂.pasteHoriz t₁ hi₂ = t₂.pasteHoriz t₁... | null | true |
_private.Mathlib.CategoryTheory.Sites.LocallyBijective.0.CategoryTheory.Sheaf.isLocallyBijective_iff_isIso'._simp_1_1 | Mathlib.CategoryTheory.Sites.LocallyBijective | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | null | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabRcc._regBuiltin.Lean.PrettyPrinter.Delaborator.delabRcc_1 | Lean.PrettyPrinter.Delaborator.Builtins | IO Unit | null | false |
IsOpen.continuousOn_iff | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α},
IsOpen s → (ContinuousOn f s ↔ ∀ ⦃a : α⦄, a ∈ s → ContinuousAt f a) | null | true |
List.sublistsLenAux._f | Mathlib.Data.List.Sublists | {α : Type u} →
{β : Type v} →
(x : List α) →
List.below (motive := fun x => ℕ → (List α → β) → List β → List β) x → ℕ → (List α → β) → List β → List β | null | false |
totallyBounded_insert._simp_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] (a : α) {s : Set α}, TotallyBounded (insert a s) = TotallyBounded s | null | false |
PartialHomeomorph.refl_source | Mathlib.Topology.PartialHomeomorph.Basic | ∀ (X : Type u_3) [inst : TopologicalSpace X], (PartialHomeomorph.refl X).source = Set.univ | null | true |
_private.Mathlib.Tactic.NormNum.RealSqrt.0.Mathlib.Meta.NormNum.evalNNRealSqrt._proof_1 | Mathlib.Tactic.NormNum.RealSqrt | ∀ (sℝ : Q(AddMonoidWithOne NNReal)),
«$sℝ» =Q NNReal.instSemiring.toNonAssocSemiring.toAddCommMonoidWithOne.toAddMonoidWithOne | null | false |
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.Function.FactorizedRational.meromorphicOrderAt_eq._simp_1_2 | Mathlib.Analysis.Meromorphic.FactorizedRational | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {d : 𝕜 → ℤ} {x : 𝕜},
0 ≤ d x → AnalyticAt 𝕜 (∏ᶠ (u : 𝕜), (fun x => x - u) ^ d u) x = True | null | false |
_private.Init.Data.Array.Erase.0.Array.exists_or_eq_self_of_eraseP.match_1_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} (p : α → Bool) (xs : Array α) (motive : (∃ a ∈ xs, p a = true) → Prop) (h : ∃ a ∈ xs, p a = true),
(∀ (w : α) (ha : w ∈ xs) (pa : p w = true), motive ⋯) → motive h | null | false |
_private.Mathlib.RingTheory.LocalProperties.Basic.0.RingHom.HoldsForLocalization.isLocalizationMap._simp_1_2 | Mathlib.RingTheory.LocalProperties.Basic | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | null | false |
unitInterval.symm | Mathlib.Topology.UnitInterval | ↑unitInterval → ↑unitInterval | Unit interval central symmetry. | true |
Lean.Meta.Grind.Context.reportMVarIssue._default | Lean.Meta.Tactic.Grind.Types | Bool | null | false |
inf_sq_eq_mul_div_mabs_div | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (a b : α), (a ⊓ b) ^ 2 = a * b / |b / a|ₘ | null | true |
MeasureTheory.JordanDecomposition.real_smul_def | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (r : ℝ) (j : MeasureTheory.JordanDecomposition α),
r • j = if 0 ≤ r then r.toNNReal • j else -((-r).toNNReal • j) | null | true |
HahnModule.instBaseSMul | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} →
[inst : PartialOrder Γ] →
{V : Type u_6} →
[inst_1 : Monoid R] → [inst_2 : AddMonoid V] → [inst_3 : DistribMulAction R V] → SMul R (HahnModule Γ R V) | null | true |
IsStronglyTranscendental.transcendental | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S},
IsStronglyTranscendental R x → ∀ [FaithfulSMul R S], Transcendental R x | null | true |
CategoryTheory.Triangulated.TStructure.eTruncLTι_naturality_assoc | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
primeFactors_primorial | Mathlib.NumberTheory.Primorial | ∀ (n : ℕ), (primorial n).primeFactors = n.primesLE | null | true |
List.any.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u} (x : α → Bool), [].any x = false | null | true |
CategoryTheory.Limits.ReflectsLimit.rec | Mathlib.CategoryTheory.Limits.Preserves.Basic | {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} →
... | null | false |
Homeomorph.prodComm_symm | Mathlib.Topology.Constructions.SumProd | ∀ (X : Type u) (Y : Type v) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
(Homeomorph.prodComm X Y).symm = Homeomorph.prodComm Y X | null | true |
AlternatingMap.domDomCongr_zero | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} {ι' : Type u_8} (σ : ι ≃ ι'),
AlternatingMap.domDomCongr σ 0 = 0 | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.Homology.0.CategoryTheory.Abelian.SpectralObject.dCokernelSequence_exact._proof_9 | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ (n₁ n₂ : ℤ),
autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.dCokernelSequence_exact._auto_3 → n₁ + 1 = n₂ | null | false |
PFun.mem_restrict | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {f : α →. β} {s : Set α} (h : s ⊆ f.Dom) (a : α) (b : β),
b ∈ f.restrict h a ↔ a ∈ s ∧ b ∈ f a | null | true |
measurableSet_closedBall | Mathlib.MeasureTheory.Constructions.BorelSpace.Metric | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] [inst_1 : MeasurableSpace α] [OpensMeasurableSpace α] {x : α} {ε : ℝ},
MeasurableSet (Metric.closedBall x ε) | null | true |
IsPreconnected.transGen_of_iUnion | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] {ι : Type u_3} {s : ι → Set α},
IsPreconnected (⋃ n, s n) →
(∀ (i : ι), IsOpen (s i)) →
∀ (i j : ι), (s i).Nonempty → (s j).Nonempty → Relation.TransGen (fun a b => (s a ∩ s b).Nonempty) i j | null | true |
Std.Time.OffsetX.hourMinute | Std.Time.Format.Modifier | Std.Time.OffsetX | Hour and minute without colon (e.g., "+0130")
| true |
_private.Init.Data.String.Basic.0.String.Slice.utf8ByteSize_copy_eq_sub._simp_1_2 | Init.Data.String.Basic | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
differentiable_const_cpow_of_neZero | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ (z : ℂ) [NeZero z], Differentiable ℂ fun s => z ^ s | null | true |
TopologicalSpace.isTopologicalBasis_of_subbasis_of_finiteInter | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {s : Set (Set α)},
t = TopologicalSpace.generateFrom s → FiniteInter s → TopologicalSpace.IsTopologicalBasis s | null | true |
CategoryTheory.Idempotents.Karoubi.HomologicalComplex.p_comm_f | Mathlib.CategoryTheory.Idempotents.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {P Q : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C c)} (f : P ⟶ Q) (n : ι),
CategoryTheory.CategoryStruct.comp (P.p.f n) (f.f.f n) = CategoryTheory.CategoryStruct.c... | null | true |
SeparationQuotient.instNorm.eq_1 | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E],
SeparationQuotient.instNorm = { norm := SeparationQuotient.lift norm ⋯ } | null | true |
TopModuleCat.isLimitKer._proof_5 | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {M N : TopModuleCat R} (φ : M ⟶ N)
(s : CategoryTheory.Limits.KernelFork φ),
CategoryTheory.CategoryStruct.comp
(TopModuleCat.ofHom
((TopModuleCat.Hom.hom (CategoryTheory.Limits.Fork.ι s)).codRestrict (↑(TopModuleCat.Hom.hom φ)).ker ⋯))
... | null | false |
CategoryTheory.Functor.OplaxMonoidal.η | 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) →
[self : F... | the counit morphism of a lax monoidal functor | true |
Stream'.iterate._unsafe_rec | Mathlib.Data.Stream.Defs | {α : Type u} → (α → α) → α → Stream' α | null | false |
Relation.SymmGen.of_lt | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {a b : α} [inst : Preorder α], a < b → Relation.SymmGen (fun x1 x2 => x1 ≤ x2) a b | null | true |
UniqueFactorizationMonoid.disjoint_primeFactors | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a b : M},
IsRelPrime a b → Disjoint (UniqueFactorizationMonoid.primeFactors a) (UniqueFactorizationMonoid.primeFactors b) | Relatively prime elements have disjoint prime factors (as finsets). | true |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.alphaEq._sparseCasesOn_7 | Lean.Meta.Sym.AlphaShareCommon | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | null | false |
IsCoprime.add_mul_right_right_iff._simp_1 | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y z : R}, IsCoprime x (y + z * x) = IsCoprime x y | null | false |
Asymptotics.IsEquivalent.isTheta_symm | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α},
Asymptotics.IsEquivalent l u v → v =Θ[l] u | null | true |
AdicCompletion.lift_smul._proof_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_3} [inst : CommRing R] (I : Ideal R) {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_2} [inst_3 : AddCommGroup N] [inst_4 : Module R N] (c : R) (f : (n : ℕ) → M →ₗ[R] N ⧸ I ^ n • ⊤),
(∀ {m n : ℕ} (hle : m ≤ n), AdicCompletion.transitionMap I N hle ∘ₗ f n = f m) →
∀ {m n ... | null | false |
Aesop.instHashableSlot | Aesop.Forward.RuleInfo | Hashable Aesop.Slot | null | true |
BoundedContinuousFunction.instSemiring._proof_3 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : Semiring R]
[inst_3 : BoundedMul R] [inst_4 : ContinuousMul R] [inst_5 : BoundedAdd R] [inst_6 : ContinuousAdd R]
(a b c : BoundedContinuousFunction α R), a * (b + c) = a * b + a * c | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_alter._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
AlgEquiv.equivCongr_apply | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} {A₁' : Type uA₁'} {A₂' : Type uA₂'} [inst : CommSemiring R]
[inst_1 : Semiring A₁] [inst_2 : Semiring A₂] [inst_3 : Semiring A₁'] [inst_4 : Semiring A₂'] [inst_5 : Algebra R A₁]
[inst_6 : Algebra R A₂] [inst_7 : Algebra R A₁'] [inst_8 : Algebra R A₂'] (e : A₁ ≃ₐ[R] A₂... | null | true |
SignType.instLinearOrder._proof_5 | Mathlib.Basic.Sign.Defs | ∀ (a b : SignType), a ≤ b ∨ b ≤ a | null | false |
CategoryTheory.Triangulated.Octahedron.ofIso._proof_1 | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] {X₁ X₂ X₃ Z₁₃ : C}
(u₁₂ : X₁ ⟶ X₂) (u₂₃ : X₂ ⟶ X₃) (u₁₃ : X₁ ⟶ X₃),
CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃ →
∀ {v₁₃ : X₃ ⟶ Z₁₃} {w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} {X₁' X₂' X₃' Z₁₃'... | null | false |
_private.Init.Data.SInt.IntToBitVec.0.ISize.lt_iff_toBitVec32_slt._simp_1_1 | Init.Data.SInt.IntToBitVec | ∀ {a b : ISize}, (a < b) = (a.toBitVec.slt b.toBitVec = true) | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkChainResult.go._unary._proof_1 | Lean.Elab.Tactic.Try | ∀ (tacss2 : Array (Array (Lean.TSyntax `tactic))) (i : ℕ) (acc : List (Lean.TSyntax `tactic)),
i < tacss2.size →
∀ (__do_lift : Lean.TSyntax `tactic),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i acc => tacss2.size - i) ⟨i + 1, __do_lift :: acc⟩
⟨i, acc⟩ | null | false |
_private.Batteries.Util.ProofWanted.0.classifyWantedRef.match_1 | Batteries.Util.ProofWanted | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) →
((refName : Lean.Name) → motive (some refName)) → ((x : Option Lean.Name) → motive x) → motive x | null | false |
EuclideanGeometry.dist_div_sin_angle_of_angle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Unoriented.RightAngle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {p₁ p₂ p₃ : P},
EuclideanGeometry.angle p₁ p₂ p₃ = Real.pi / 2 →
p₁ ≠ p₂ ∨ p₃ = p₂ → dist p₁ p₂ / Real.sin (EuclideanGeometry.angle p₂ p₃ p₁) = dist p₁ p₃ | A side of a right-angled triangle divided by the sine of the opposite angle equals the
hypotenuse. | true |
Finset.empty_pow | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] {n : ℕ}, n ≠ 0 → ∅ ^ n = ∅ | null | true |
AlgHom.toOpposite._proof_4 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (hf : ∀ (x y : A), Commute (f x) (f y)) (x y : A),
(↑↑(f.toOpposite hf)).toFun (x + y) = (↑↑(f.toOpposite hf)).toFun x + (↑↑(f.toOpposite h... | null | false |
AffineMap.prodMap._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_8} {V1 : Type u_3} {P1 : Type u_1} {V2 : Type u_7} {P2 : Type u_5} {V3 : Type u_4} {P3 : Type u_2}
{V4 : Type u_9} {P4 : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
[inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2] [inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2]
... | null | false |
Set.powersetCard.mem_range_ofFinEmbEquiv_symm_iff_mem | Mathlib.Order.Hom.PowersetCard | ∀ {n : ℕ} {I : Type u_1} [inst : LinearOrder I] (s : ↑(Set.powersetCard I n)) (i : I),
i ∈ Set.range ⇑(Set.powersetCard.ofFinEmbEquiv.symm s) ↔ i ∈ s | null | true |
Order.IsSuccLimit.nonempty_Iio | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α], Order.IsSuccLimit a → (Set.Iio a).Nonempty | null | true |
CochainComplex.HomComplex.Cochain.toSingleLinearEquiv_apply | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {R : Type u_1} [inst_3 : Ring R]
[inst_4 : CategoryTheory.Linear R C] {p q n : ℤ} (h : p + n = q)
(a : CochainComplex.HomComplex.Cochai... | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.leftUnshift._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {n' a : ℤ} (n : ℤ), n + a = n' → ∀ (p q : ℤ), p + n = q → p - a + n' = q | null | false |
Ideal.radical | Mathlib.RingTheory.Ideal.Operations | {R : Type u} → [inst : CommSemiring R] → Ideal R → Ideal R | The radical of an ideal `I` consists of the elements `r` such that `r ^ n ∈ I` for some `n`. | true |
Std.Format.prefixJoin | Init.Data.Format.Basic | {α : Type u} → [Std.ToFormat α] → Std.Format → List α → Std.Format | Concatenates the given list after prepending `pre` to each element.
The list items are formatting using `ToFormat.format`.
| true |
RootPairing.instIsBalancedOfIsRootSystem | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : AddCommGroup M] [inst_1 : AddCommGroup N]
[inst_2 : CommRing R] [inst_3 : Module R M] [inst_4 : Module R N] (P : RootPairing ι R M N) [P.IsRootSystem],
P.IsBalanced | null | true |
HomogeneousLocalization.deg | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} →
[inst : CommRing A] → [inst_1 : SetLike σ A] → {𝒜 : ι → σ} → {x : Submonoid A} → HomogeneousLocalization 𝒜 x → ι | For an element in `HomogeneousLocalization x`, degree is the natural number `i` such that
`𝒜 i` contains both numerator and denominator. | true |
Bool.ite_eq_false_right | Init.Data.Bool | ∀ {b : Bool} {q : Prop}, (if b = true then q else b = false) ↔ b = true → q | null | true |
irrational_sub_ratCast_iff._simp_1 | Mathlib.NumberTheory.Real.Irrational | ∀ {q : ℚ} {x : ℝ}, Irrational (x - ↑q) = Irrational x | null | false |
Bundle.ContMDiffRiemannianMetric.toContinuousRiemannianMetric._proof_10 | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | SMulCommClass ℝ ℝ ℝ | null | false |
List.iterate._sunfold | Mathlib.Data.List.Defs | {α : Type u_1} → (α → α) → α → ℕ → List α | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.lambdaTelescopeImp.process._unsafe_rec | Lean.Meta.Basic | {α : Type} →
Bool →
Bool →
Option ℕ →
(Array Lean.Expr → Lean.Expr → Lean.MetaM α) →
Bool → Bool → Bool → Lean.LocalContext → Array Lean.Expr → Lean.Expr → Lean.MetaM α | null | false |
CategoryTheory.SpectralSequence.noConfusionType | Mathlib.Algebra.Homology.SpectralSequence.Basic | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
CategoryTheory.SpectralSequence C c r₀ →
{C' : Type u_1} →
[ins... | null | false |
ClopenUpperSet.mk._flat_ctor | Mathlib.Topology.Sets.Order | {α : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : LE α] → (carrier : Set α) → IsClopen carrier → IsUpperSet carrier → ClopenUpperSet α | null | false |
Lean.Parser.Tactic.withReducible | Init.Tactics | Lean.ParserDescr | `with_reducible tacs` executes `tacs` using the reducible transparency setting.
In this setting only definitions tagged as `[reducible]` are unfolded.
| true |
Std.DTreeMap.Raw.Const.getKey?_modify | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp},
t.WF →
∀ {k k' : α} {f : β → β},
(Std.DTreeMap.Raw.Const.modify t k f).getKey? k' =
if cmp k k' = Ordering.eq then if k ∈ t then some k else none else t.getKey? k' | null | true |
Aesop.RuleTerm.ctorElimType | Aesop.RuleTac.RuleTerm | {motive : Aesop.RuleTerm → Sort u} → ℕ → Sort (max 1 u) | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go_denote_eq | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ),
curr + 1 ≤ w →
∀ (acc lhs rhs : aig.RefVec w) (lexpr rexpr : BitVec w) (assign : α → Bool),
(∀ (idx : ℕ) (hidx : idx < w), ⟦assign, { aig := aig, ref := lhs.get idx hidx }⟧ = lexpr.getLsbD idx) →
(∀ (... | null | true |
Matrix.charpolyRev.congr_simp | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] {n : Type v} {inst_1 : DecidableEq n} [inst_2 : DecidableEq n] [inst_3 : Fintype n]
(M M_1 : Matrix n n R), M = M_1 → M.charpolyRev = M_1.charpolyRev | null | true |
ContinuousSemilinearEquivClass.mk | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} [inst : Semiring R] [inst_1 : Semiring S]
{σ : outParam (R →+* S)} {σ' : outParam (S →+* R)} [inst_2 : RingHomInvPair σ σ'] [inst_3 : RingHomInvPair σ' σ]
{M : outParam (Type u_4)} [inst_4 : TopologicalSpace M] [inst_5 : AddCommMonoid M] {M₂ : out... | null | true |
MeasureTheory.LevyProkhorov.levyProkhorovDist_metricSpace_probabilityMeasure._proof_2 | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : PseudoEMetricSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
[BorelSpace Ω] {μ ν : MeasureTheory.LevyProkhorov (MeasureTheory.ProbabilityMeasure Ω)}, dist μ ν = 0 → μ = ν | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.State.noConfusionType | Init.Data.Format.Basic | Sort u → Std.Format.State✝ → Std.Format.State✝ → Sort u | null | false |
AddUnits.neg_add_eq_iff_eq_add | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α) {b c : α}, ↑(-a) + b = c ↔ b = ↑a + c | null | true |
TopologicalSpace.GenerateOpen.brecOn | Mathlib.Topology.Order | ∀ {α : Type u} {g : Set (Set α)} {motive : (a : Set α) → TopologicalSpace.GenerateOpen g a → Prop} {a : Set α}
(t : TopologicalSpace.GenerateOpen g a),
(∀ (a : Set α) (t : TopologicalSpace.GenerateOpen g a), TopologicalSpace.GenerateOpen.below t → motive a t) →
motive a t | null | true |
MeasureTheory.IsSetSemiring.empty_mem | Mathlib.MeasureTheory.SetSemiring | ∀ {α : Type u_1} {C : Set (Set α)}, MeasureTheory.IsSetSemiring C → ∅ ∈ C | null | true |
CategoryTheory.Abelian.Pseudoelement.mono_of_zero_of_map_zero | Mathlib.CategoryTheory.Abelian.Pseudoelements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q),
(∀ (a : CategoryTheory.Abelian.Pseudoelement P), CategoryTheory.Abelian.Pseudoelement.pseudoApply f a = 0 → a = 0) →
CategoryTheory.Mono f | A morphism that only maps the zero pseudoelement to zero is a monomorphism. | true |
OrdinalApprox.lfpApprox._proof_2 | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ (a b : Ordinal.{u_1}), b < a → (invImage (fun x => x) Ordinal.wellFoundedRelation).1 b a | null | false |
_private.Mathlib.Order.SupIndep.0.iSupIndep_ne_bot._simp_1_1 | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_3} [inst : CompleteLattice α] {t : ι → α},
iSupIndep t = ∀ (i : ι), Disjoint (t i) (⨆ j, ⨆ (_ : j ≠ i), t j) | null | false |
_private.Batteries.Data.List.Lemmas.0.List.pos_iff_exists_findIdxNth._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {p : α → Bool} {xs : List α} {h : i < xs.length} (w : ℕ),
List.findIdxNth p xs w = i → List.findIdxNth p xs w < xs.length | null | false |
Real.binEntropy_lt_log_two | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {p : ℝ}, Real.binEntropy p < Real.log 2 ↔ p ≠ 2⁻¹ | For probability `p ≠ 0.5`, `binEntropy p < log 2`. | true |
MulEquiv.map_inv | Mathlib.Algebra.Group.Equiv.Defs | ∀ {G : Type u_7} {H : Type u_8} [inst : Group G] [inst_1 : DivisionMonoid H] (h : G ≃* H) (x : G), h x⁻¹ = (h x)⁻¹ | A multiplicative equivalence of groups preserves inversion. | true |
CochainComplex.HomComplex.Cochain.shiftAddHom._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n a : ℤ) (a_1 b : CochainComplex.HomComplex.Cochain K L n),
(a_1 + b).shift a = a_1.shift a + b.shift a | null | false |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.eq_of_head_mem_of_getLast_mem_of_infix._proof_1_23 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l₁ l₂ : List α} {hne : l₂ ≠ []}, l₂.getLast hne ∈ l₁ → ∀ (w : List α), 0 < (w ++ l₁).length | null | false |
Submonoid.mem_map_of_mem | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) {S : Submonoid M} {x : M}, x ∈ S → f x ∈ Submonoid.map f S | null | true |
groupHomology.opcyclesIso₀._proof_4 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G),
(HomologicalComplex.sc (groupHomology.inhomogeneousChains A) 1).HasHomology | null | false |
Lean.Lsp.WorkspaceClientCapabilities.mk.noConfusion | Lean.Data.Lsp.Capabilities | {P : Sort u} →
{applyEdit? : Option Bool} →
{workspaceEdit? : Option Lean.Lsp.WorkspaceEditClientCapabilities} →
{applyEdit?' : Option Bool} →
{workspaceEdit?' : Option Lean.Lsp.WorkspaceEditClientCapabilities} →
{ applyEdit? := applyEdit?, workspaceEdit? := workspaceEdit? } =
... | null | false |
Bool.atLeastTwo_true_left | Init.Data.BitVec.Bitblast | ∀ {b c : Bool}, true.atLeastTwo b c = (b || c) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.