name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Inv.0.Lean.Grind.Linarith.Poly.checkCoeffs._sunfold | Lean.Meta.Tactic.Grind.Arith.Linear.Inv | Lean.Grind.Linarith.Poly → Bool | false |
SimpleGraph.completeAtomicBooleanAlgebra._proof_11 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u_1} (G : SimpleGraph V) (v w : V), { Adj := Ne, symm := ⋯, loopless := ⋯ }.Adj v w → (G ⊔ Gᶜ).Adj v w | false |
MeasurableSpace.CountableOrCountablyGenerated.rec | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | {α : Type u_5} →
{β : Type u_6} →
[inst : MeasurableSpace β] →
{motive : MeasurableSpace.CountableOrCountablyGenerated α β → Sort u} →
((countableOrCountablyGenerated : Countable α ∨ MeasurableSpace.CountablyGenerated β) → motive ⋯) →
(t : MeasurableSpace.CountableOrCountablyGenerated α β) → motive t | false |
Summable.tsum_eq_add_tsum_ite' | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {L : SummationFilter β}
[T2Space α] [ContinuousAdd α] [inst_4 : DecidableEq β] [L.LeAtTop] [L.NeBot] {f : β → α} (b : β),
Summable (Function.update f b 0) L → ∑'[L] (x : β), f x = f b + ∑'[L] (x : β), if x = b then 0 else f x | true |
Lean.Elab.Term.PostponeBehavior | Lean.Elab.SyntheticMVars | Type | true |
_private.Lean.MonadEnv.0.Lean.isCtor?.match_1 | Lean.MonadEnv | (motive : Option Lean.AsyncConstantInfo → Sort u_1) →
(x : Option Lean.AsyncConstantInfo) →
((info : Lean.AsyncConstantInfo) →
(name : Lean.Name) →
(sig : Task Lean.ConstantVal) →
(constInfo : Task Lean.ConstantInfo) →
(h : info = { name := name, kind := Lean.ConstantKind.ctor, sig := sig, constInfo := constInfo }) →
motive
(some
(namedPattern info
{ name := name, kind := Lean.ConstantKind.ctor, sig := sig, constInfo := constInfo } h))) →
((x : Option Lean.AsyncConstantInfo) → motive x) → motive x | false |
MeasureTheory.AEEqFun.compMeasurePreserving_id | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace β] {ν : MeasureTheory.Measure β}
(g : β →ₘ[ν] γ), g.compMeasurePreserving id ⋯ = g | true |
CategoryTheory.coherentTopology.equivalence | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[inst_2 : F.PreservesFiniteEffectiveEpiFamilies] →
[inst_3 : F.ReflectsFiniteEffectiveEpiFamilies] →
[inst_4 : F.Full] →
[inst_5 : F.Faithful] →
[inst_6 : CategoryTheory.Precoherent D] →
[inst_7 : F.EffectivelyEnough] →
(A : Type u₃) →
[inst_8 : CategoryTheory.Category.{v₃, u₃} A] →
[∀ (X : Dᵒᵖ),
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.StructuredArrow X F.op) A] →
CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) A ≌
CategoryTheory.Sheaf (CategoryTheory.coherentTopology D) A | true |
instDecidableRelAdjFromRelOfDecidableEq._aux_1 | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u_1} → [DecidableEq V] → (r : V → V → Prop) → [DecidableRel r] → DecidableRel (SimpleGraph.fromRel r).Adj | false |
Batteries.Tactic.Lint.traceLintCore | Batteries.Tactic.Lint.Frontend | String → Bool → Lean.CoreM Unit | true |
Unitization.instNonAssocSemiring._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_2} {A : Type u_1} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
(x x_1 x_2 : Unitization R A), (x * (x_1 + x_2)).toProd.2 = (x * x_1 + x * x_2).toProd.2 | false |
Turing.ToPartrec.Code.zero.eq_1 | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code.zero = Turing.ToPartrec.Code.zero'.cons Turing.ToPartrec.Code.nil | true |
_private.Mathlib.Topology.UniformSpace.UniformEmbedding.0.completeSpace_extension.match_1_19 | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] {m : β → α} (g : Filter α)
(motive : (∃ x, Filter.map m (Filter.comap m g) ≤ nhds x) → Prop) (x : ∃ x, Filter.map m (Filter.comap m g) ≤ nhds x),
(∀ (x : α) (hx : Filter.map m (Filter.comap m g) ≤ nhds x), motive ⋯) → motive x | false |
RootPairing.EmbeddedG2.allRoots_eq_map_allCoeffs | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N)
[inst_5 : P.EmbeddedG2] [Finite ι] [CharZero R] [IsDomain R],
RootPairing.EmbeddedG2.allRoots P =
List.map (⇑(Fintype.linearCombination ℤ ![RootPairing.EmbeddedG2.shortRoot P, RootPairing.EmbeddedG2.longRoot P]))
RootPairing.EmbeddedG2.allCoeffs | true |
Equiv.Perm.cycle_is_cycleOf | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Fintype α] {f c : Equiv.Perm α} {a : α},
a ∈ c.support → c ∈ f.cycleFactorsFinset → c = f.cycleOf a | true |
MonoidWithZero.mk.noConfusion | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
{P : Sort u_1} →
{toMonoid : Monoid M₀} →
{toZero : Zero M₀} →
{zero_mul : ∀ (a : M₀), 0 * a = 0} →
{mul_zero : ∀ (a : M₀), a * 0 = 0} →
{toMonoid' : Monoid M₀} →
{toZero' : Zero M₀} →
{zero_mul' : ∀ (a : M₀), 0 * a = 0} →
{mul_zero' : ∀ (a : M₀), a * 0 = 0} →
{ toMonoid := toMonoid, toZero := toZero, zero_mul := zero_mul, mul_zero := mul_zero } =
{ toMonoid := toMonoid', toZero := toZero', zero_mul := zero_mul', mul_zero := mul_zero' } →
(toMonoid ≍ toMonoid' → toZero ≍ toZero' → P) → P | false |
CategoryTheory.Mat.instAddCommGroupHom._aux_1 | Mathlib.CategoryTheory.Preadditive.Mat | (R : Type) → [inst : Ring R] → (X Y : CategoryTheory.Mat R) → (X ⟶ Y) → (X ⟶ Y) → (X ⟶ Y) | false |
Homeomorph.piCongrRight_apply | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι : Type u_7} {Y₁ : ι → Type u_8} {Y₂ : ι → Type u_9} [inst : (i : ι) → TopologicalSpace (Y₁ i)]
[inst_1 : (i : ι) → TopologicalSpace (Y₂ i)] (F : (i : ι) → Y₁ i ≃ₜ Y₂ i) (a : (i : ι) → Y₁ i) (i : ι),
(Homeomorph.piCongrRight F) a i = (F i) (a i) | true |
_private.Mathlib.NumberTheory.ModularForms.BoundedAtCusp.0.OnePoint.isBoundedAt_iff._simp_1_2 | Mathlib.NumberTheory.ModularForms.BoundedAtCusp | ∀ {f : UpperHalfPlane → ℂ} {k : ℤ}, OnePoint.infty.IsBoundedAt f k = UpperHalfPlane.IsBoundedAtImInfty f | false |
Set.IsIntersectingOf | Mathlib.Combinatorics.SetFamily.Intersecting | {α : Type u_1} → [DecidableEq α] → Set ℕ → Set (Finset α) → Prop | true |
DiscreteQuotient.isOpen_preimage | Mathlib.Topology.DiscreteQuotient | ∀ {X : Type u_2} [inst : TopologicalSpace X] (S : DiscreteQuotient X) (A : Set (Quotient S.toSetoid)),
IsOpen (S.proj ⁻¹' A) | true |
Std.HashMap.size_le_size_insertIfNew | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
{v : β}, m.size ≤ (m.insertIfNew k v).size | true |
StandardEtalePair.instCommRingRing._proof_22 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R) (a : P.Ring), 1 * a = a | false |
Int.le_induction_down._proof_2 | Mathlib.Data.Int.Init | ∀ {m : ℤ}, ∀ n ≤ m, n - 1 ≤ m | false |
NNReal.measurableSpace._proof_3 | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | NNReal.measurableSpace._aux_1 ∅ | false |
instCartesianMonoidalCategoryLightCondSet._aux_7 | Mathlib.Condensed.Light.CartesianClosed | {X₁ Y₁ X₂ Y₂ : LightCondSet} →
(X₁ ⟶ Y₁) →
(X₂ ⟶ Y₂) →
(instCartesianMonoidalCategoryLightCondSet._aux_1 X₁ X₂ ⟶ instCartesianMonoidalCategoryLightCondSet._aux_1 Y₁ Y₂) | false |
CategoryTheory.WithTerminal.Hom.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (a : C),
CategoryTheory.WithTerminal.star.Hom (CategoryTheory.WithTerminal.of a) = PEmpty.{v + 1} | true |
LightCondensed.discrete.congr_simp | Mathlib.Condensed.Discrete.Module | ∀ (C : Type w) [inst : CategoryTheory.Category.{u, w} C]
[inst_1 : CategoryTheory.HasSheafify (CategoryTheory.coherentTopology LightProfinite) C],
LightCondensed.discrete C = LightCondensed.discrete C | true |
AlgebraicGeometry.Scheme.Hom.copyBase._proof_2 | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.Hom Y) (g : ↥X → ↥Y), ⇑f = g → Continuous g | false |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.SuccessPoint._sizeOf_inst | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | SizeOf Lean.Elab.Tactic.Do.SuccessPoint✝ | false |
_private.Mathlib.Order.KrullDimension.0.Order.coheight_pos_of_lt_top._proof_1_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {x : α} [inst_1 : OrderTop α], x < ⊤ → ¬IsMax x | false |
CategoryTheory.Mon.instSymmetricCategory._proof_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (X Y : CategoryTheory.Mon C), CategoryTheory.IsMonHom (β_ X.X Y.X).hom | false |
IsLindelof.disjoint_nhdsSet_right | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X} {l : Filter X} [CountableInterFilter l],
IsLindelof s → (Disjoint l (nhdsSet s) ↔ ∀ x ∈ s, Disjoint l (nhds x)) | true |
Matrix.norm_def | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] (A : Matrix m n α), ‖A‖ = ‖fun i j => A i j‖ | true |
CompHausLike.LocallyConstant.functor_map_hom | Mathlib.Condensed.Discrete.LocallyConstant | ∀ (P : TopCat → Prop) [inst : CompHausLike.HasExplicitFiniteCoproducts P] [inst_1 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f))
{X Y : Type (max u w)} (f : X ⟶ Y),
((CompHausLike.LocallyConstant.functor P hs).map f).hom = CompHausLike.LocallyConstant.functorToPresheaves.map f | true |
Vector.getElem_swap_left | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i j : ℕ} (hi : i < n) (hj : j < n), (xs.swap i j hi hj)[i] = xs[j] | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_1.eq_5 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2}
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size Std.DTreeMap.Internal.Impl.leaf.size → Sort u_3)
(ls : ℕ) (lk : α) (lv : β lk) (lls : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (lrs : ℕ) (k_1 : α)
(v_1 : β k_1) (l_1 r_1 : Std.DTreeMap.Internal.Impl α β)
(hlb :
(Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner lls k v l r)
(Std.DTreeMap.Internal.Impl.inner lrs k_1 v_1 l_1 r_1)).Balanced)
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner lls k v l r)
(Std.DTreeMap.Internal.Impl.inner lrs k_1 v_1 l_1 r_1)).size
Std.DTreeMap.Internal.Impl.leaf.size)
(h_1 :
(hlb : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond Std.DTreeMap.Internal.Impl.leaf.size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive Std.DTreeMap.Internal.Impl.leaf hlb hlr)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
(hlb :
(Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf
Std.DTreeMap.Internal.Impl.leaf).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf
Std.DTreeMap.Internal.Impl.leaf).size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf
Std.DTreeMap.Internal.Impl.leaf)
hlb hlr)
(h_3 :
(size : ℕ) →
(lk : α) →
(lv : β lk) →
(size_1 : ℕ) →
(lrk : α) →
(lrv : β lrk) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(hlb :
(Std.DTreeMap.Internal.Impl.inner size lk lv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_1 lrk lrv l r)).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner size lk lv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_1 lrk lrv l r)).size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive
(Std.DTreeMap.Internal.Impl.inner size lk lv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_1 lrk lrv l r))
hlb hlr)
(h_4 :
(size : ℕ) →
(lk : α) →
(lv : β lk) →
(ll : Std.DTreeMap.Internal.Impl α β) →
(size_1 : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
ll = Std.DTreeMap.Internal.Impl.inner size_1 k v l r →
(hlb :
(Std.DTreeMap.Internal.Impl.inner size lk lv (Std.DTreeMap.Internal.Impl.inner size_1 k v l r)
Std.DTreeMap.Internal.Impl.leaf).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner size lk lv
(Std.DTreeMap.Internal.Impl.inner size_1 k v l r)
Std.DTreeMap.Internal.Impl.leaf).size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive
(Std.DTreeMap.Internal.Impl.inner size lk lv
(Std.DTreeMap.Internal.Impl.inner size_1 k v l r) Std.DTreeMap.Internal.Impl.leaf)
hlb hlr)
(h_5 :
(ls : ℕ) →
(lk : α) →
(lv : β lk) →
(lls : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(lrs : ℕ) →
(k_2 : α) →
(v_2 : β k_2) →
(l_2 r_2 : Std.DTreeMap.Internal.Impl α β) →
(hlb :
(Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner lls k v l r)
(Std.DTreeMap.Internal.Impl.inner lrs k_2 v_2 l_2 r_2)).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv
(Std.DTreeMap.Internal.Impl.inner lls k v l r)
(Std.DTreeMap.Internal.Impl.inner lrs k_2 v_2 l_2 r_2)).size
Std.DTreeMap.Internal.Impl.leaf.size) →
motive
(Std.DTreeMap.Internal.Impl.inner ls lk lv
(Std.DTreeMap.Internal.Impl.inner lls k v l r)
(Std.DTreeMap.Internal.Impl.inner lrs k_2 v_2 l_2 r_2))
hlb hlr),
(match
Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner lls k v l r)
(Std.DTreeMap.Internal.Impl.inner lrs k_1 v_1 l_1 r_1),
hlb, hlr with
| Std.DTreeMap.Internal.Impl.leaf, hlb, hlr => h_1 hlb hlr
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf, hlb,
hlr => h_2 size k v hlb hlr
|
Std.DTreeMap.Internal.Impl.inner size lk lv Std.DTreeMap.Internal.Impl.leaf
(Std.DTreeMap.Internal.Impl.inner size_1 lrk lrv l r),
hlb, hlr => h_3 size lk lv size_1 lrk lrv l r hlb hlr
|
Std.DTreeMap.Internal.Impl.inner size lk lv (ll@h:(Std.DTreeMap.Internal.Impl.inner size_1 k v l r))
Std.DTreeMap.Internal.Impl.leaf,
hlb, hlr => h_4 size lk lv ll size_1 k v l r h hlb hlr
|
Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner lls k v l r)
(Std.DTreeMap.Internal.Impl.inner lrs k_2 v_2 l_2 r_2),
hlb, hlr => h_5 ls lk lv lls k v l r lrs k_2 v_2 l_2 r_2 hlb hlr) =
h_5 ls lk lv lls k v l r lrs k_1 v_1 l_1 r_1 hlb hlr | true |
TopModuleCat.instPreadditive | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [inst : Ring R] → [inst_1 : TopologicalSpace R] → CategoryTheory.Preadditive (TopModuleCat R) | true |
_private.Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity.0.HasEnoughRootsOfUnity.of_dvd.match_1_3 | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ (M : Type u_1) [inst : CommMonoid M] {n : ℕ} (motive : (∃ ζ, IsPrimitiveRoot ζ n) → Prop)
(x : ∃ ζ, IsPrimitiveRoot ζ n), (∀ (ζ : M) (hζ : IsPrimitiveRoot ζ n), motive ⋯) → motive x | false |
Vector.mapFinIdx_push | Init.Data.Vector.MapIdx | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {xs : Vector α n} {a : α} {f : (i : ℕ) → α → i < n + 1 → β},
(xs.push a).mapFinIdx f = (xs.mapFinIdx fun i a h => f i a ⋯).push (f n a ⋯) | true |
TopHom.inf_apply | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} [inst : Top α] [inst_1 : SemilatticeInf β] [inst_2 : OrderTop β] (f g : TopHom α β)
(a : α), (f ⊓ g) a = f a ⊓ g a | true |
Submonoid.one | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_4} → [inst : MulOneClass M] → (S : Submonoid M) → One ↥S | true |
Lean.Compiler.LCNF.UnreachableBranches.findVarValue | Lean.Compiler.LCNF.ElimDeadBranches | Lean.FVarId → Lean.Compiler.LCNF.UnreachableBranches.InterpM Lean.Compiler.LCNF.UnreachableBranches.Value | true |
WeierstrassCurve.Affine.map_addPolynomial | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {R : Type r} {S : Type s} [inst : CommRing R] [inst_1 : CommRing S] {W' : WeierstrassCurve.Affine R} (f : R →+* S)
(x y ℓ : R),
(WeierstrassCurve.map W' f).toAffine.addPolynomial (f x) (f y) (f ℓ) = Polynomial.map f (W'.addPolynomial x y ℓ) | true |
Lean.KVMap._sizeOf_inst | Lean.Data.KVMap | SizeOf Lean.KVMap | false |
Mathlib.Tactic.Abel.Context.α | Mathlib.Tactic.Abel | Mathlib.Tactic.Abel.Context → Lean.Expr | true |
DividedPowers.dpow_add' | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {a b : A} (hI : DividedPowers I) {n : ℕ},
a ∈ I → b ∈ I → hI.dpow n (a + b) = ∑ k ∈ Finset.range (n + 1), hI.dpow k a * hI.dpow (n - k) b | true |
ContinuousLinearEquiv.symm_smul_apply | Mathlib.Topology.Algebra.Module.Equiv | ∀ {S : Type u_1} {R : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid V] [inst_3 : Module R V] [inst_4 : TopologicalSpace V] [inst_5 : Module S V]
[inst_6 : ContinuousConstSMul S V] [inst_7 : AddCommMonoid W] [inst_8 : Module R W] [inst_9 : TopologicalSpace W]
[inst_10 : Module S W] [inst_11 : ContinuousConstSMul S W] [inst_12 : SMulCommClass R S W] [inst_13 : SMul S R]
[inst_14 : IsScalarTower S R V] [inst_15 : IsScalarTower S R W] (e : V ≃L[R] W) (α : Sˣ) (x : W),
(α • e).symm x = ↑α⁻¹ • e.symm x | true |
_private.Mathlib.Logic.IsEmpty.Basic.0.isEmpty_pprod._simp_1_1 | Mathlib.Logic.IsEmpty.Basic | ∀ {α : Sort u_1}, IsEmpty α = ¬Nonempty α | false |
NumberField.IsCMField.NumberField.CMExtension.of_isMulCommutative | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_2) [inst : Field K] [inst_1 : CharZero K] [Algebra.IsIntegral ℚ K] [NumberField.IsTotallyComplex K]
[IsAbelianGalois ℚ K], NumberField.IsCMField K | true |
CategoryTheory.GrothendieckTopology.Point.rec | Mathlib.CategoryTheory.Sites.Point.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{motive : J.Point → Sort u_1} →
((fiber : CategoryTheory.Functor C (Type w)) →
(isCofiltered : CategoryTheory.IsCofiltered fiber.Elements) →
(initiallySmall : CategoryTheory.InitiallySmall fiber.Elements) →
(jointly_surjective :
∀ {X : C}, ∀ R ∈ J X, ∀ (x : fiber.obj X), ∃ Y f, ∃ (_ : R.arrows f), ∃ y, fiber.map f y = x) →
motive
{ fiber := fiber, isCofiltered := isCofiltered, initiallySmall := initiallySmall,
jointly_surjective := jointly_surjective }) →
(t : J.Point) → motive t | false |
ContinuousWithinAt.sqrt | Mathlib.Data.Real.Sqrt | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℝ} {s : Set α} {x : α},
ContinuousWithinAt f s x → ContinuousWithinAt (fun x => √(f x)) s x | true |
Poly.coe_mul | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} (f g : Poly α), ⇑(f * g) = ⇑f * ⇑g | true |
algebraMap_mem._simp_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {S : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [OneMemClass S A] [SMulMemClass S R A] (s : S) (r : R), ((algebraMap R A) r ∈ s) = True | false |
RatFunc.ofFractionRing.sizeOf_spec | Mathlib.FieldTheory.RatFunc.Defs | ∀ {K : Type u} [inst : CommRing K] [inst_1 : SizeOf K] (toFractionRing : FractionRing (Polynomial K)),
sizeOf { toFractionRing := toFractionRing } = 1 + sizeOf toFractionRing | true |
_private.Mathlib.Analysis.Normed.Module.Ball.Homeomorph.0.OpenPartialHomeomorph.univUnitBall._simp_7 | Mathlib.Analysis.Normed.Module.Ball.Homeomorph | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Mathlib.GroupTheory.DivisibleHull.0.DivisibleHull.aux_archimedeanClassOrderHom_injective | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_2} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M],
Function.Injective ⇑(DivisibleHull.archimedeanClassOrderHom✝ M) | true |
CommRingCat.Opposite.effectiveEpi_of_faithfullyFlat | Mathlib.Algebra.Category.Ring.EqualizerPushout | ∀ {R S : CommRingCatᵒᵖ} (f : S ⟶ R), (CommRingCat.Hom.hom f.unop).FaithfullyFlat → CategoryTheory.EffectiveEpi f | true |
Algebra.FormallySmooth.liftOfSurjective._proof_2 | Mathlib.RingTheory.Smooth.Basic | ∀ {R : Type u_3} [inst : CommRing R] {B : Type u_1} [inst_1 : CommRing B] [inst_2 : Algebra R B] {C : Type u_2}
[inst_3 : CommRing C] [inst_4 : Algebra R C], RingHomClass (B →ₐ[R] C) B C | false |
Lean.Elab.Term.Do.ToCodeBlock.ToForInTermResult.ctorIdx | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToCodeBlock.ToForInTermResult → ℕ | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.Basic.0.integral_exp_mul_I_eq_sinc._simp_1_7 | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
T4Space.toNormalSpace | Mathlib.Topology.Separation.Regular | ∀ {X : Type u} {inst : TopologicalSpace X} [self : T4Space X], NormalSpace X | true |
LightProfinite.NatUnionInfty | Mathlib.Topology.Category.LightProfinite.Sequence | LightProfinite | true |
Finset.addDysonETransform.eq_1 | Mathlib.Combinatorics.Additive.ETransform | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : AddCommGroup α] (e : α) (x : Finset α × Finset α),
Finset.addDysonETransform e x = (x.1 ∪ (e +ᵥ x.2), x.2 ∩ (-e +ᵥ x.1)) | true |
_private.Mathlib.Topology.EMetricSpace.Paracompact.0.Metric.instParacompactSpace._proof_10 | Mathlib.Topology.EMetricSpace.Paracompact | ∀ (n k m : ℕ), n + k + 1 ≤ m → n < m | false |
Int.dvd_of_mul_dvd | Init.Data.Int.Cooper | ∀ {a b c : ℤ}, a * b ∣ a * c → 0 < a → b ∣ c | true |
Algebra.Extension.Hom.mapKer.congr_simp | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} [inst_3 : CommRing R'] [inst_4 : CommRing S'] [inst_5 : Algebra R' S']
{P' : Algebra.Extension R' S'} [inst_6 : Algebra R R'] [inst_7 : Algebra S S'] (f f_1 : P.Hom P') (e_f : f = f_1)
[alg : Algebra P.Ring P'.Ring] (halg : algebraMap P.Ring P'.Ring = f.toRingHom), f.mapKer halg = f_1.mapKer ⋯ | true |
_private.Mathlib.CategoryTheory.Sites.Over.0.CategoryTheory.GrothendieckTopology.overEquiv_symm_mem_over._simp_1_1 | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {X : C}
{Y : CategoryTheory.Over X} (S : CategoryTheory.Sieve Y),
(S ∈ (J.over X) Y) = ((CategoryTheory.Sieve.overEquiv Y) S ∈ J Y.left) | false |
List.mem_permutationsAux2 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {t : α} {ts ys l l' : List α},
l' ∈ (List.permutationsAux2 t ts [] ys fun x => l ++ x).2 ↔
∃ l₁ l₂, l₂ ≠ [] ∧ ys = l₁ ++ l₂ ∧ l' = l ++ l₁ ++ t :: l₂ ++ ts | true |
_private.Lean.Meta.Iterator.0.Lean.Meta.Iterator.filterMapM.match_1 | Lean.Meta.Iterator | {β : Type} →
(motive : Option β → Sort u_1) → (r : Option β) → (Unit → motive none) → ((r : β) → motive (some r)) → motive r | false |
AlgebraicGeometry.instQuasiCompactFstScheme | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [AlgebraicGeometry.QuasiCompact g],
AlgebraicGeometry.QuasiCompact (CategoryTheory.Limits.pullback.fst f g) | true |
Nat.bitCasesOn_bit | Mathlib.Data.Nat.BinaryRec | ∀ {motive : ℕ → Sort u} (h : (b : Bool) → (n : ℕ) → motive (Nat.bit b n)) (b : Bool) (n : ℕ),
Nat.bitCasesOn (Nat.bit b n) h = h b n | true |
CategoryTheory.MonoidalOpposite.mopMopEquivalenceFunctorMonoidal._proof_8 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : Cᴹᵒᵖᴹᵒᵖ),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj
(CategoryTheory.MonoidalCategoryStruct.tensorUnit Cᴹᵒᵖᴹᵒᵖ))
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X)))
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.map
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom)) | false |
Stream'.map_cons | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (a : α) (s : Stream' α),
Stream'.map f (Stream'.cons a s) = Stream'.cons (f a) (Stream'.map f s) | true |
ContinuousMultilinearMap.isUniformInducing_toUniformOnFun | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup F], IsUniformInducing ContinuousMultilinearMap.toUniformOnFun | true |
CategoryTheory.ObjectProperty.instSmallStrictColimitsOfShapeOfSmallOfLocallySmall | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C) (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] [CategoryTheory.ObjectProperty.Small.{w, v_1, u_1} P]
[CategoryTheory.LocallySmall.{w, v_1, u_1} C] [Small.{w, u'} J] [CategoryTheory.LocallySmall.{w, v', u'} J],
CategoryTheory.ObjectProperty.Small.{w, v_1, u_1} (P.strictColimitsOfShape J) | true |
_private.Mathlib.Topology.Baire.LocallyCompactRegular.0.IsGδ.of_t2Space_locallyCompactSpace._proof_1_2 | Mathlib.Topology.Baire.LocallyCompactRegular | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (x : { x // x ∈ s }), ↑x ∈ closure s | false |
Hyperreal._aux_Mathlib_Analysis_Real_Hyperreal___unexpand_Hyperreal_epsilon_1 | Mathlib.Analysis.Real.Hyperreal | Lean.PrettyPrinter.Unexpander | false |
Module.quotientAnnihilator._proof_1 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
(Module.annihilator R M).IsTwoSided | false |
LieModule.Weight.instFunLike | Mathlib.Algebra.Lie.Weights.Basic | {R : Type u_2} →
{L : Type u_3} →
(M : Type u_4) →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L M] → [inst_7 : LieRing.IsNilpotent L] → FunLike (LieModule.Weight R L M) L R | true |
ProbabilityTheory.Kernel.boolKernel_true | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
(ProbabilityTheory.Kernel.boolKernel μ ν) true = ν | true |
CategoryTheory.FunctorToTypes.coprod._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F G : CategoryTheory.Functor C (Type u_1)) (X : C),
(fun x =>
Sum.casesOn (motive := fun t => x = t → F.obj X ⊕ G.obj X) x
(fun x_1 h => Sum.inl (F.map (CategoryTheory.CategoryStruct.id X) x_1))
(fun x_1 h => Sum.inr (G.map (CategoryTheory.CategoryStruct.id X) x_1)) ⋯) =
CategoryTheory.CategoryStruct.id (F.obj X ⊕ G.obj X) | false |
Nat.mul_max_mul_left | Init.Data.Nat.MinMax | ∀ (a b c : ℕ), max (a * b) (a * c) = a * max b c | true |
Primrec.nat_double_succ | Mathlib.Computability.Primrec.Basic | Primrec fun n => 2 * n + 1 | true |
Lean.Elab.PartialFixpointType._sizeOf_1 | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpointType → ℕ | false |
AlgebraicGeometry.Scheme.Hom.range_fiberι | Mathlib.AlgebraicGeometry.Fiber | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (y : ↥Y),
Set.range ⇑(AlgebraicGeometry.Scheme.Hom.fiberι f y) = ⇑f ⁻¹' {y} | true |
CategoryTheory.PreZeroHypercoverFamily.mk._flat_ctor | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(property : ⦃X : C⦄ → CategoryTheory.ObjectProperty (CategoryTheory.PreZeroHypercover X)) →
(∀ {X : C} {E : CategoryTheory.PreZeroHypercover X}, property E ↔ property E.shrink) →
CategoryTheory.PreZeroHypercoverFamily C | false |
Std.TreeSet.Raw.getD_max? | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {km fallback : α}, t.max? = some km → t.getD km fallback = km | true |
Equiv.normedField | Mathlib.Analysis.Normed.Field.TransferInstance | {α : Type u_1} → {β : Type u_2} → [NormedField β] → α ≃ β → NormedField α | true |
Lean.Meta.Grind.Arith.Linear.getOrderedAddInst | Lean.Meta.Tactic.Grind.Arith.Linear.Util | Lean.Meta.Grind.Arith.Linear.LinearM Lean.Expr | true |
_private.Lean.Data.Json.Printer.0.Lean.Json.escapeAux | Lean.Data.Json.Printer | String → Char → String | true |
TopCat.GlueData.isOpen_iff | Mathlib.Topology.Gluing | ∀ (D : TopCat.GlueData) (U : Set ↑D.glued),
IsOpen U ↔ ∀ (i : D.J), IsOpen (⇑(CategoryTheory.ConcreteCategory.hom (D.ι i)) ⁻¹' U) | true |
List.dedup_eq_cons | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α) (a : α) (l' : List α),
l.dedup = a :: l' ↔ a ∈ l ∧ a ∉ l' ∧ l.dedup.tail = l' | true |
_private.Mathlib.Data.Rat.Lemmas.0.Rat.isSquare_iff._simp_1_1 | Mathlib.Data.Rat.Lemmas | ∀ {α : Type u_2} [inst : Mul α] (r : α), IsSquare (r * r) = True | false |
Relation.cutExpand_zero | Mathlib.Logic.Hydra | ∀ {α : Type u_1} {r : α → α → Prop} {x : α}, Relation.CutExpand r 0 {x} | true |
Sum.nonemptyLeft | Init.Core | ∀ {α : Type u} {β : Type v} [h : Nonempty α], Nonempty (α ⊕ β) | true |
UniqueMDiffOn.uniqueMDiffOn_target_inter | Mathlib.Geometry.Manifold.MFDeriv.UniqueDifferential | ∀ {𝕜 : 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] {s : Set M} [IsManifold I 1 M],
UniqueMDiffOn I s →
∀ (x : M), UniqueMDiffOn (modelWithCornersSelf 𝕜 E) ((extChartAt I x).target ∩ ↑(extChartAt I x).symm ⁻¹' s) | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insertMin.match_3._arg_pusher | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (motive : (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → Sort u_3)
(α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → α_1 → Prop) (t : Std.DTreeMap.Internal.Impl α β)
(hr : t.Balanced)
(h_1 :
(hr : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
((y : α_1) → rel Std.DTreeMap.Internal.Impl.leaf hr y → β_1 y) → motive Std.DTreeMap.Internal.Impl.leaf hr)
(h_2 :
(sz : ℕ) →
(k' : α) →
(v' : β k') →
(l' r' : Std.DTreeMap.Internal.Impl α β) →
(hr : (Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced) →
((y : α_1) → rel (Std.DTreeMap.Internal.Impl.inner sz k' v' l' r') hr y → β_1 y) →
motive (Std.DTreeMap.Internal.Impl.inner sz k' v' l' r') hr),
((match (motive :=
(t : Std.DTreeMap.Internal.Impl α β) → (hr : t.Balanced) → ((y : α_1) → rel t hr y → β_1 y) → motive t hr) t,
hr with
| Std.DTreeMap.Internal.Impl.leaf, hr => fun x => h_1 hr x
| Std.DTreeMap.Internal.Impl.inner sz k' v' l' r', hr => fun x => h_2 sz k' v' l' r' hr x)
fun y h => f y) =
match t, hr with
| Std.DTreeMap.Internal.Impl.leaf, hr => h_1 hr fun y h => f y
| Std.DTreeMap.Internal.Impl.inner sz k' v' l' r', hr => h_2 sz k' v' l' r' hr fun y h => f y | false |
TopCat.GlueData.MkCore.t'._proof_1 | Mathlib.Topology.Gluing | ∀ (h : TopCat.GlueData.MkCore) (i j k : h.J),
CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.cospan (h.V i j).inclusion' (h.V i k).inclusion') | false |
CategoryTheory.FreeMonoidalCategory.HomEquiv.below.α_inv_hom | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u}
{motive :
{X Y : CategoryTheory.FreeMonoidalCategory C} →
(a a_1 : X.Hom Y) → CategoryTheory.FreeMonoidalCategory.HomEquiv a a_1 → Prop}
{X Y Z : CategoryTheory.FreeMonoidalCategory C}, CategoryTheory.FreeMonoidalCategory.HomEquiv.below ⋯ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.