name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_slope_of_ne._simp_1_4 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
CategoryTheory.Functor.flip_map_app | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) {d d' : D} (f : d ⟶ d') (c : C),
(F.flip.map f).app c = (F.obj c).map f | null | true |
_private.Lean.Environment.0.Lean.AsyncContext.noConfusion | Lean.Environment | {P : Sort u} → {t t' : Lean.AsyncContext✝} → t = t' → Lean.AsyncContext.noConfusionType✝ P t t' | null | false |
CategoryTheory.GrothendieckTopology.OneHypercover.mk'_toPreOneHypercover | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C}
(E : CategoryTheory.PreOneHypercover S) [inst_1 : E.HasPullbacks] (mem₀ : E.sieve₀ ∈ J S)
(mem₁' : ∀ (i₁ i₂ : E.I₀), E.sieve₁' i₁ i₂ ∈ J (CategoryTheory.Limits.pullback (E.f i₁) (E.f i₂))),
(CategoryTheory... | null | true |
SimpleGraph.Subgraph.instCompletelyDistribLattice._proof_5 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (a : G.Subgraph), a ⇨ ⊥ = aᶜ | null | false |
CategoryTheory.ObjectProperty.Is.mk | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {P : CategoryTheory.ObjectProperty C} {X : C},
P X → P.Is X | null | true |
Mathlib.Explode.Entries.noConfusion | Mathlib.Tactic.Explode.Datatypes | {P : Sort u} → {t t' : Mathlib.Explode.Entries} → t = t' → Mathlib.Explode.Entries.noConfusionType P t t' | null | false |
CochainComplex.ConnectData.mk.noConfusion | Mathlib.Algebra.Homology.Embedding.Connect | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{K : ChainComplex C ℕ} →
{L : CochainComplex C ℕ} →
{P : Sort u_1} →
{d₀ : K.X 0 ⟶ L.X 0} →
{comp_d₀ : CategoryTheory.CategoryStruct.comp (K.d 1 0) d₀ ... | null | false |
HahnSeries.orderTopSubOnePos | Mathlib.RingTheory.HahnSeries.Multiplication | (Γ : Type u_6) →
(R : Type u_7) →
[inst : LinearOrder Γ] →
[inst_1 : AddCommMonoid Γ] →
[inst_2 : IsOrderedCancelAddMonoid Γ] → [inst_3 : CommRing R] → Subgroup (HahnSeries Γ R)ˣ | The group of invertible Hahn series close to 1, i.e., those series such that subtracting 1
yields a series with strictly positive `orderTop`. | true |
Lean.MessageData.isTrace._sunfold | Lean.Message | Lean.MessageData → Bool | null | false |
_private.Init.Data.String.Lemmas.Basic.0.String.Slice.Pos.slice_eq_endPos._simp_1_1 | Init.Data.String.Lemmas.Basic | ∀ {s : String.Slice} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} (pos₁ pos₂ : (s.slice p₀ p₁ h).Pos),
(pos₁ = pos₂) = (String.Slice.Pos.ofSlice pos₁ = String.Slice.Pos.ofSlice pos₂) | null | false |
Set.sigma_sdiff_sigma | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_3} {s₁ s₂ : Set ι} {t₁ t₂ : (i : ι) → Set (α i)},
s₁.sigma t₁ \ s₂.sigma t₂ = s₁.sigma (t₁ \ t₂) ∪ (s₁ \ s₂).sigma t₁ | null | true |
Pi.locallyPathConnectedSpace_of_finite_not_pathConnectedSpace | Mathlib.Topology.Connected.LocallyPathConnected | ∀ {ι : Type u_3} {Z : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (Z i)]
[∀ (i : ι), LocallyPathConnectedSpace (Z i)],
{i | ¬PathConnectedSpace (Z i)}.Finite → LocallyPathConnectedSpace ((i : ι) → Z i) | If each `Z i` is locally path-connected and all but finitely many are path-connected, then
`∀ i, Z i` is locally path-connected. | true |
PositiveLinearMap.instAddCommGroupPreGNS._proof_20 | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : PartialOrder A] [inst_2 : Module ℂ A] (f : A →ₚ[ℂ] ℂ),
autoParam (∀ (n : ℕ) (a : f.PreGNS), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
isOpen_iInter₂ | Mathlib.Topology.AlexandrovDiscrete | ∀ {ι : Sort u_1} {κ : ι → Sort u_2} {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α]
{f : (i : ι) → κ i → Set α}, (∀ (i : ι) (j : κ i), IsOpen (f i j)) → IsOpen (⋂ i, ⋂ j, f i j) | null | true |
CoalgEquiv.rec | Mathlib.RingTheory.Coalgebra.Equiv | {R : Type u_5} →
[inst : CommSemiring R] →
{A : Type u_6} →
{B : Type u_7} →
[inst_1 : AddCommMonoid A] →
[inst_2 : AddCommMonoid B] →
[inst_3 : Module R A] →
[inst_4 : Module R B] →
[inst_5 : CoalgebraStruct R A] →
[inst_6 : Coal... | null | false |
SkewMonoidAlgebra.update_eq_erase_add_single | Mathlib.Algebra.SkewMonoidAlgebra.Single | ∀ {M : Type u_4} {α : Type u_5} [inst : AddCommMonoid M] (f : SkewMonoidAlgebra M α) (a : α) (b : M),
f.update a b = (SkewMonoidAlgebra.erase a) f + SkewMonoidAlgebra.single a b | null | true |
AddMonoidHom.instDistribSMul._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Hom | ∀ {M : Type u_3} {A : Type u_1} {B : Type u_2} [inst : AddZeroClass A] [inst_1 : AddCommMonoid B]
[inst_2 : DistribSMul M B] (x : M) (x_1 x_2 : A →+ B), x • (x_1 + x_2) = x • x_1 + x • x_2 | null | false |
_private.ImportGraph.Shake.Algebra.0.ImportGraph.Shake.Needs.addAndThen._proof_2 | ImportGraph.Shake.Algebra | ∀ (kImp : ImportGraph.Shake.NeedsKind),
¬kImp.isAll = true →
∀ k ∈ ImportGraph.Shake.NeedsKind.toPublic,
(if k.isExported = true then Lean.Environment.Visibility.public else Lean.Environment.Visibility.private) =
if kImp.isAll = true then Lean.Environment.Visibility.private else Lean.Environment.Vis... | null | false |
CategoryTheory.createsLimitOfFullyFaithfulOfIso | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | When `F` is fully faithful, and `HasLimit (K ⋙ F)`, to show that `F` creates the limit for `K`
it suffices to show that the chosen limit point is in the essential image of `F`.
| true |
Polynomial.reflect_C_mul | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (f : Polynomial R) (r : R) (N : ℕ),
Polynomial.reflect N (Polynomial.C r * f) = Polynomial.C r * Polynomial.reflect N f | null | true |
cfcₙHomSuperset._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : MetricSpace R] [inst_2 : NonUnitalRing A]
[inst_3 : Module R A] {a : A} {s : Set R} (hs : quasispectrum R a ⊆ s), Continuous (Subtype.map id hs) | null | false |
LinearEquiv.symm_symm | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂),
... | null | true |
_private.Mathlib.Combinatorics.SetFamily.Compression.Down.0.Finset.image_insert_memberSubfamily.match_1_3 | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} (𝒜 : Finset (Finset α)) (a : α) (s : Finset α) (motive : s ∈ 𝒜 ∧ a ∈ s → Prop) (x : s ∈ 𝒜 ∧ a ∈ s),
(∀ (hs : s ∈ 𝒜) (ha : a ∈ s), motive ⋯) → motive x | null | false |
Sum3.in₀ | Mathlib.Data.Sum.Basic | {α : Type u} → {β : Type v} → {γ : Type u_1} → α → α ⊕ β ⊕ γ | The map from the first summand into a ternary sum. | true |
GrpCat.forget_isCorepresentable | Mathlib.Algebra.Category.Grp.ForgetCorepresentable | (CategoryTheory.forget GrpCat).IsCorepresentable | null | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.reduceProp._sparseCasesOn_7 | Mathlib.Tactic.FieldSimp | {motive : Mathlib.Ineq → Sort u} →
(t : Mathlib.Ineq) →
motive Mathlib.Ineq.eq → motive Mathlib.Ineq.le → (Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.RingTheory.DiscreteValuationRing.Basic.0.IsDiscreteValuationRing.exists_irreducible._simp_1_1 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] (ϖ : R),
Irreducible ϖ = (IsLocalRing.maximalIdeal R = Ideal.span {ϖ}) | null | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.RCasesPatt.parse._unsafe_rec | Lean.Elab.Tactic.RCases | Lean.Syntax → Lean.MetaM Lean.Elab.Tactic.RCases.RCasesPatt | null | false |
_private.Mathlib.Data.Set.Lattice.Image.0.Set.sInter_prod._simp_1_1 | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
CategoryTheory.Bicategory.triangle_assoc_comp_left_inv_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c) {Z : a ⟶ c}
(h :
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id b)) g ⟶
Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f ... | null | true |
BitVec.reduceGT | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.Simproc | Simplification procedure for `>` on `BitVec`s. | true |
_private.Mathlib.GroupTheory.FreeGroup.Reduce.0.FreeGroup.toWord_mul_mk_eq._proof_1_29 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] (x : FreeGroup α) (i : ℕ),
i + 1 ≤ (List.map ((fun g => (g.1, !g.2)) ∘ fun g => (g.1, !g.2)) x.toWord).length → i < x.toWord.length | null | false |
Lean.Grind.AC.Seq.unionFuel_k | Init.Grind.AC | ℕ → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | null | true |
RingHom.PropertyIsLocal.respectsIso | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
RingHom.PropertyIsLocal P → RingHom.RespectsIso P | null | true |
heq_of_eq_cast | Mathlib.Basic.Logic.Basic | ∀ {α β : Sort u} {a : α} {b : β} (e : β = α), a = cast e b → a ≍ b | null | true |
WeierstrassCurve.instSMulVariableChange._proof_2 | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | (2 + 1).AtLeastTwo | null | false |
Vector.mem_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {x y : α}, x ∈ xs.push y ↔ x ∈ xs ∨ x = y | null | true |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Eval.0.Polynomial.eval_one_cyclotomic_not_prime_pow._simp_1_7 | Mathlib.RingTheory.Polynomial.Cyclotomic.Eval | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.faulhaber_sum_div_prime_eq._simp_1_2 | Mathlib.NumberTheory.Bernoulli | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
ContinuousMap.liftCover'._proof_2 | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} (A : Set (Set α)) (i : { x // x ∈ A }), ↑i ∈ A | null | false |
QuadraticMap.Isometry.mk.sizeOf_spec | Mathlib.LinearAlgebra.QuadraticForm.Isometry | ∀ {R : Type u_1} {M₁ : Type u_3} {M₂ : Type u_4} {N : Type u_7} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid N] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
[inst_6 : Module R N] {Q₁ : QuadraticMap R M₁ N} {Q₂ : QuadraticMap R M₂ N} [inst_7 : SizeOf R] [in... | null | true |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Continuous.exists_forall_le_of_isBounded._simp_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
MeasureTheory.Measure.FiniteAtFilter.integrableAtFilter | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {E : Type u_5} {mα : MeasurableSpace α} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure α}
{f : α → E} {l : Filter α} [l.IsMeasurablyGenerated],
StronglyMeasurableAtFilter f l μ →
μ.FiniteAtFilter l →
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l (norm ∘ f) → MeasureTheory.Integ... | If `μ` is a measure finite at filter `l` and `f` is a function such that its norm is bounded
above at `l`, then `f` is integrable at `l`. | true |
Matrix.piAlgEquiv._proof_3 | Mathlib.Data.Matrix.Basic | ∀ {n : Type u_1} {ι : Type u_2} {β : ι → Type u_3} (R : Type u_4) [inst : CommSemiring R]
[inst_1 : (i : ι) → Semiring (β i)] [inst_2 : (i : ι) → Algebra R (β i)] [inst_3 : Fintype n] [inst_4 : DecidableEq n]
(x : R) (x_1 : Matrix n n ((i : ι) → β i)),
Matrix.piRingEquiv.toRingHom (x • x_1) = Matrix.piRingEquiv.t... | null | false |
CategoryTheory.Discrete.addMonoidal_tensorObj_as | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ (M : Type u) [inst : AddMonoid M] (X Y : CategoryTheory.Discrete M),
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).as = X.as + Y.as | null | true |
MulOpposite.instMulZeroClass._proof_1 | Mathlib.Algebra.GroupWithZero.Opposite | ∀ {α : Type u_1} [inst : MulZeroClass α] (x : αᵐᵒᵖ), 0 * x = 0 | null | false |
Rat.instEncodable.match_1 | Mathlib.Data.Rat.Encodable | (motive : ℚ → Sort u_1) →
(x : ℚ) →
((a : ℤ) →
(b : ℕ) → (c : b ≠ 0) → (d : a.natAbs.Coprime b) → motive { num := a, den := b, den_nz := c, reduced := d }) →
motive x | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.unreachable._regBuiltin.Lean.Parser.Term.unreachable.declRange_5 | Lean.Parser.Term | IO Unit | null | false |
Std.ExtDHashMap.get?_insertMany_list_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{l : List ((a : α) × β a)} {k : α}, (List.map Sigma.fst l).contains k = false → (m.insertMany l).get? k = m.get? k | null | true |
LocallyConstant.instMulAction | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
{R : Type u_5} → [inst_1 : Monoid R] → [MulAction R Y] → MulAction R (LocallyConstant X Y) | null | true |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.coeff_X_mul_largeSchroderSeriesSeries_sq._simp_1_6 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ {α : Type u_2} [inst : Preorder α] (x : α), (x < x) = False | null | false |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkCongrSimpCore?.mkProof | Lean.Meta.CongrTheorems | Lean.Expr → Array Lean.Meta.CongrArgKind → Lean.MetaM Lean.Expr | null | true |
_private.Lean.Util.CollectAxioms.0.Lean.instInhabitedExportedAxiomsState | Lean.Util.CollectAxioms | Inhabited Lean.ExportedAxiomsState✝ | null | true |
ZMod.commRing._proof_16 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ), Nat.casesOn (motive := fun x => ℕ → ZMod x) n Nat.cast (fun n => Nat.cast) 0 = 0 | null | false |
CategoryTheory.Monoidal.instMonoidalTransportedInverseSymmEquivalenceTransported._proof_3 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] (e : C ≌ D),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.Monoidal.equivalenceTransported e).sy... | null | false |
Real.contDiffOn_arcosh | Mathlib.Analysis.SpecialFunctions.Arcosh | ∀ {n : WithTop ℕ∞}, ContDiffOn ℝ n Real.arcosh (Set.Ioi 1) | null | true |
CategoryTheory.SimplicialObject.Splitting.toNondegComplex_f_assoc | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C] (n : ℕ) {Z : C} (h : s.nondegComplex.X n ⟶ Z),
CategoryTheory.CategoryStruct.comp (s.toNondegComplex.f n) h =
CategoryTheory.CategoryStruct.comp (Algeb... | null | true |
HomotopicalAlgebra.CofibrantObject.exists_bifibrant_map | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
{X₁ X₂ : HomotopicalAlgebra.CofibrantObject C} (f : X₁ ⟶ X₂),
∃ g,
CategoryTheory.CategoryStruct.comp X₁.iBifibrantResolutionObj
(HomotopicalAlgebra.BifibrantObject.ιCofibrantObject.map g) =
Cate... | null | true |
CategoryTheory.Sieve.forallYonedaIsSheaf_iff_colimit | Mathlib.CategoryTheory.Sites.SheafOfTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (S : CategoryTheory.Sieve X),
(∀ (W : C), CategoryTheory.Presieve.IsSheafFor (CategoryTheory.yoneda.obj W) S.arrows) ↔
Nonempty (CategoryTheory.Limits.IsColimit S.arrows.cocone) | The base of a sieve `S` is a colimit of `S` iff all Yoneda-presheaves satisfy
the sheaf condition for `S`.
| true |
_private.Mathlib.Geometry.Euclidean.Triangle.0.EuclideanGeometry.dist_sq_add_dist_sq_eq_two_mul_dist_midpoint_sq_add_half_dist_sq._simp_1_1 | Mathlib.Geometry.Euclidean.Triangle | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Std.DTreeMap.Internal.Impl.toListModel_eq_append | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] (k : α → Ordering) [Std.Internal.IsStrictCut compare k]
{l : Std.DTreeMap.Internal.Impl α β},
l.Ordered →
l.toListModel =
List.filter (fun x => k x.fst == Ordering.gt) l.toListModel ++
(List.find? (fun x => k x.fst == Ordering.eq) l... | null | true |
Lean.Meta.ExtractLetsConfig.underBinder._default | Init.MetaTypes | Bool | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_3.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTre... | null | true |
UniformEquiv.prodAssoc._proof_1 | Mathlib.Topology.UniformSpace.Equiv | ∀ (α : Type u_2) (β : Type u_1) (γ : Type u_3) [inst : UniformSpace α] [inst_1 : UniformSpace β]
[inst_2 : UniformSpace γ], UniformContinuous fun a => (((fun p => p.1) ∘ fun p => p.1) a, a.1.2, a.2) | null | false |
gcd_isUnit_iff_isRelPrime | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] {a b : α}, IsUnit (gcd a b) ↔ IsRelPrime a b | null | true |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.mem_jacobson_bot.match_1_3 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {x : R} (y : R) (motive : (∃ b, (x * y + 1) * b = 1) → Prop)
(x_1 : ∃ b, (x * y + 1) * b = 1), (∀ (b : R) (hb : (x * y + 1) * b = 1), motive ⋯) → motive x_1 | null | false |
Array.all_append | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {f : α → Bool} {xs ys : Array α}, (xs ++ ys).all f = (xs.all f && ys.all f) | null | true |
Partition.disjoint | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {s x y : α} [inst : CompleteLattice α] {P : Partition s}, x ∈ P → y ∈ P → x ≠ y → Disjoint x y | null | true |
IsCyclotomicExtension.Rat.associated_sub_one_of_isPrimitiveRoot | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p : ℕ) {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ p) [inst_1 : NeZero p] {η : K}
(hη : IsPrimitiveRoot η p), Associated (hζ.toInteger - 1) (hη.toInteger - 1) | null | true |
normFromConst._proof_1 | Mathlib.Analysis.Normed.Unbundled.SeminormFromConst | ∀ {K : Type u_1} [inst : Field K] {k : K} {g : RingSeminorm K} (hg_k : g k ≠ 0) (hg_pm : IsPowMul ⇑g),
(seminormFromConst hg_k hg_pm) k ≠ 0 | null | false |
CategoryTheory.Functor.leftOp_faithful | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C Dᵒᵖ} [F.Faithful], F.leftOp.Faithful | If F is faithful then the `leftOp` of F is also faithful. | true |
Std.Sat.AIG.empty._proof_2 | Std.Sat.AIG.Basic | ∀ {α : Type}, #[Std.Sat.AIG.Decl.false][0] = Std.Sat.AIG.Decl.false | null | false |
SupIrred.supPrime | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : DistribLattice α] {a : α}, SupIrred a → SupPrime a | **Alias** of the reverse direction of `supPrime_iff_supIrred`. | true |
Set.not_nonempty_empty | Mathlib.Data.Set.Basic | ∀ {α : Type u}, ¬∅.Nonempty | null | true |
Std.Http.URI.Scheme.ofString? | Std.Http.Data.URI.Basic | String → Option Std.Http.URI.Scheme | Attempts to create a `Scheme` from a string, normalizing to lowercase.
Returns `none` if the scheme is invalid per RFC 3986 Section 3.1.
| true |
_private.Mathlib.Analysis.SpecificLimits.Fibonacci.0.tendsto_fib_succ_div_fib_atTop._simp_1_2 | Mathlib.Analysis.SpecificLimits.Fibonacci | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Units.mulRight_symm | Mathlib.Algebra.Group.Units.Equiv | ∀ {M : Type u_3} [inst : Monoid M] (u : Mˣ), Equiv.symm u.mulRight = u⁻¹.mulRight | null | true |
AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap_fst_assoc | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(s : CategoryTheory.Limits.PullbackCone f g) (i j : 𝒰.I₀) {Z_1 : AlgebraicGeometry.Scheme}
(h : CategoryTheory.Limits.pullbac... | null | true |
_private.Mathlib.GroupTheory.Finiteness.0.isMulFG_multiplicative_iff.match_1_1 | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} [inst : Add M] (motive : IsMulFG (Multiplicative M) → Prop) (x : IsMulFG (Multiplicative M)),
(∀ (S : Finset (Multiplicative M)) (hS : Subsemigroup.closure ↑S = ⊤), motive ⋯) → motive x | null | false |
Std.PRange.UpwardEnumerable.Map.mk | Init.Data.Range.Polymorphic.Map | {α : Type u} →
{β : Type v} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.UpwardEnumerable β] →
(toFun : α → β) →
Function.Injective toFun →
(∀ (a : α), Std.PRange.succ? (toFun a) = Option.map toFun (Std.PRange.succ? a)) →
(∀ (n : ℕ) (a : α), Std... | null | true |
_aux_Mathlib_Order_Defs_LinearOrder___macroRules_tacticCompareOfLessAndEq_rfl_1 | Mathlib.Order.Defs.LinearOrder | Lean.Macro | This attempts to prove that a given instance of `compare` is equal to `compareOfLessAndEq` by
introducing the arguments and trying the following approaches in order:
1. seeing if `rfl` works
2. seeing if the `compare` at hand is nonetheless essentially `compareOfLessAndEq`, but, because of
implicit arguments, requi... | false |
Lean.Elab.Do.instInhabitedContInfo | Lean.Elab.Do.Basic | Inhabited Lean.Elab.Do.ContInfo | null | true |
Std.DTreeMap.Internal.RocSliceData.recOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.RocSliceData α β → Sort u_1} →
(t : Std.DTreeMap.Internal.RocSliceData α β) →
((treeMap : Std.DTreeMap.Internal.Impl α β) →
(range : Std.Roc α) → motive { treeMap := treeMap, range := range }) ... | null | false |
_private.Mathlib.Analysis.BoxIntegral.Basic.0.BoxIntegral.integrable_of_bounded_and_ae_continuousWithinAt._simp_1_1 | Mathlib.Analysis.BoxIntegral.Basic | ∀ {E : Type u} {F : Type v} [inst : PseudoEMetricSpace F] [inst_1 : TopologicalSpace E] (f : E → F) {D : Set E} {x : E},
x ∈ D → (oscillationWithin f D x = 0) = ContinuousWithinAt f D x | null | false |
HomogeneousLocalization.homogeneousLocalizationCommRing._proof_1 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] {𝒜 : ι → σ} {x : Submonoid A} (y : HomogeneousLocalization 𝒜 x), (-y).val = -y.val | null | false |
_private.Std.Data.DTreeMap.Internal.Balanced.0.Std.DTreeMap.Internal.Impl.balancedAtRoot_zero_iff._proof_1_1 | Std.Data.DTreeMap.Internal.Balanced | ∀ {n : ℕ}, ¬(0 + n ≤ 1 ∨ 0 ≤ Std.DTreeMap.Internal.delta * n ∧ n ≤ Std.DTreeMap.Internal.delta * 0 ↔ n ≤ 1) → False | null | false |
EReal.bot_ne_zero | Mathlib.Data.EReal.Basic | ⊥ ≠ 0 | null | true |
LinearIndependent.notMem_span | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [Nontrivial R], LinearIndependent R v → ∀ (i : ι), v i ∉ Submodule.span R (v '' {i}ᶜ) | null | true |
_private.Lean.Parser.Syntax.0.Lean.Parser.Command.macro_rules._regBuiltin.Lean.Parser.Command.macro_rules.formatter_9 | Lean.Parser.Syntax | IO Unit | null | false |
_private.Mathlib.RingTheory.Nilpotent.Basic.0.not_isNilpotent_neg_one._simp_1_1 | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_3} [inst : MonoidWithZero R] [Nontrivial R], IsNilpotent 1 = False | null | false |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.IsReduced.nodup_rightInvSeq._simp_1_5 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | null | false |
Equiv.algebra._proof_4 | Mathlib.Algebra.Algebra.TransferInstance | ∀ (R : Type u_2) {α : Type u_1} {β : Type u_3} [inst : CommSemiring R] (e : α ≃ β) [inst_1 : Semiring β]
[inst_2 : Algebra R β] (r : R) (x : α),
r • x =
{ toFun := fun r => e.invFun ((algebraMap R β) r), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ } r *
x | null | false |
AlgebraicGeometry.Scheme.evaluation | Mathlib.AlgebraicGeometry.ResidueField | (X : AlgebraicGeometry.Scheme) → (U : X.Opens) → (x : ↥X) → x ∈ U → (X.presheaf.obj (Opposite.op U) ⟶ X.residueField x) | If `U` is an open of `X` containing `x`, we have a canonical ring map from the sections
over `U` to the residue field of `x`.
If we interpret sections over `U` as functions of `X` defined on `U`, then this ring map
corresponds to evaluation at `x`.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Basic.0.SimpleGraph.exists_isExtremal_iff_exists.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Extremal.Basic | ∀ {V : Type u_1} [inst : Fintype V] (p : SimpleGraph V → Prop) (motive : (∃ G x, G.IsExtremal p) → Prop)
(x : ∃ G x, G.IsExtremal p),
(∀ (w : SimpleGraph V) (w_1 : DecidableRel w.Adj) (h : w.IsExtremal p), motive ⋯) → motive x | null | false |
«termC(_,_)» | Mathlib.Topology.ContinuousMap.Defs | Lean.ParserDescr | `C(X, Y)` is the type of continuous maps from `X` to `Y`. | true |
Lean.PrettyPrinter.Delaborator.OmissionReason.rec | Lean.PrettyPrinter.Delaborator.Basic | {motive : Lean.PrettyPrinter.Delaborator.OmissionReason → Sort u} →
motive Lean.PrettyPrinter.Delaborator.OmissionReason.deep →
motive Lean.PrettyPrinter.Delaborator.OmissionReason.proof →
motive Lean.PrettyPrinter.Delaborator.OmissionReason.maxSteps →
((s : String) → motive (Lean.PrettyPrinter.Dela... | null | false |
MeasureTheory.LocallyIntegrable.mono_measure | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ ν : MeasureTheory.Measure X},
MeasureTheory.LocallyIntegrable f μ → ν ≤ μ → MeasureTheory.LocallyIntegrable f ν | null | true |
Lean.Lsp.SemanticTokenModifier.documentation.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenModifier → Sort u} →
(t : Lean.Lsp.SemanticTokenModifier) → t.ctorIdx = 8 → motive Lean.Lsp.SemanticTokenModifier.documentation → motive t | null | false |
_private.Mathlib.Algebra.BigOperators.Finprod.0.mul_finprod_cond_ne._proof_1_1 | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] {f : α → M} (a x : α), f x ≠ 1 → (¬x = a ↔ ¬f x = 1 ∧ ¬x = a) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.