name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.Array.Zip.0.Array.getElem?_zipWith.match_1.eq_1 | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} (motive : Option α → Option β → Sort u_3) (a : α) (b : β)
(h_1 : (a : α) → (b : β) → motive (some a) (some b)) (h_2 : (x : Option α) → (x_1 : Option β) → motive x x_1),
(match some a, some b with
| some a, some b => h_1 a b
| x, x_1 => h_2 x x_1) =
h_1 a b | true |
IsDedekindDomain.HeightOneSpectrum.mk.injEq | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] (asIdeal : Ideal R) (isPrime : asIdeal.IsPrime) (ne_bot : asIdeal ≠ ⊥)
(asIdeal_1 : Ideal R) (isPrime_1 : asIdeal_1.IsPrime) (ne_bot_1 : asIdeal_1 ≠ ⊥),
({ asIdeal := asIdeal, isPrime := isPrime, ne_bot := ne_bot } =
{ asIdeal := asIdeal_1, isPrime := isPrime_1, ne_bot := ... | true |
IO.FS.readBinFile | Init.System.IO | System.FilePath → IO ByteArray | true |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.edgeSet_subgraphOfAdj._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
Std.ExtDTreeMap.keyAtIdx._proof_1 | Std.Data.ExtDTreeMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} [Std.TransCmp cmp] (t : Std.ExtDTreeMap α β cmp) (n : ℕ)
(h : n < t.size) (x x_1 : Std.DTreeMap α β cmp) (x_2 : t = Std.ExtDTreeMap.mk x),
t = Std.ExtDTreeMap.mk x_1 → ∀ (h_1 : x.Equiv x_1), x.keyAtIdx n ⋯ = x_1.keyAtIdx n ⋯ | false |
Lean.Environment.PromiseCheckedResult._sizeOf_inst | Lean.Environment | SizeOf Lean.Environment.PromiseCheckedResult | false |
Module.End.mem_invtSubmodule_adjoint_iff | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] {T : E →ₗ[𝕜] E} {U : Submodule 𝕜 E},
U ∈ Module.End.invtSubmodule (LinearMap.adjoint T) ↔ Uᗮ ∈ Module.End.invtSubmodule T | true |
Mathlib.Notation3.matchForall | Mathlib.Util.Notation3 | Mathlib.Notation3.Matcher → (Lean.Expr → Mathlib.Notation3.Matcher) → Mathlib.Notation3.Matcher | true |
_private.Mathlib.LinearAlgebra.Complex.Module.0.skewAdjoint.negISMul._simp_2 | Mathlib.LinearAlgebra.Complex.Module | ∀ {R : Type u_1} [inst : AddGroup R] [inst_1 : StarAddMonoid R] {x : R}, (x ∈ selfAdjoint R) = (star x = x) | false |
CategoryTheory.Abelian.SpectralObject.dShortComplex_f | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{i₀ i₁ i₂ i₃ i₄ i₅ i₆ i₇ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅)
... | true |
Lean.Grind.IntInterval.ci.inj | Init.Grind.ToInt | ∀ {lo lo_1 : ℤ}, Lean.Grind.IntInterval.ci lo = Lean.Grind.IntInterval.ci lo_1 → lo = lo_1 | true |
Matrix.reindexLinearEquiv._proof_2 | Mathlib.LinearAlgebra.Matrix.Reindex | ∀ {m : Type u_1} {n : Type u_2} {m' : Type u_4} {n' : Type u_5} (R : Type u_6) (A : Type u_3) [inst : Semiring R]
[inst_1 : AddCommMonoid A] [inst_2 : Module R A] (eₘ : m ≃ m') (eₙ : n ≃ n') (x : R) (x_1 : Matrix m n A),
(Matrix.reindex eₘ eₙ).toFun (x • x_1) = (Matrix.reindex eₘ eₙ).toFun (x • x_1) | false |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteAddGrpCatAddMonoidHomCarrier.eq_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteAddGrpCatAddMonoidHomCarrier =
{
forget₂ :=
{ obj := fun P => AddGrpCat.of ↑P.toProfinite.toTop,
map := fun {X Y} f => AddGrpCat.ofHom (ProfiniteAddGrp.Hom.hom f).toAddMonoidHom,
map_id :=
... | true |
_private.Mathlib.MeasureTheory.Function.LocallyIntegrable.0.MeasureTheory.LocallyIntegrableOn.norm.match_1_1 | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {E : Type u_2} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : NormedAddCommGroup E]
{μ : MeasureTheory.Measure X} {s : Set X} {f : X → E} (t : X)
(motive : MeasureTheory.IntegrableAtFilter f (nhdsWithin t s) μ → Prop)
(x : MeasureTheory.IntegrableAtFilter f (nhdsWithin t s) μ)... | false |
CommRingCat.Colimits.Relation.left_distrib | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
(x y z : CommRingCat.Colimits.Prequotient F),
CommRingCat.Colimits.Relation F (x.mul (y.add z)) ((x.mul y).add (x.mul z)) | true |
Filter.Germ.instPow | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {l : Filter α} → {M : Type u_5} → {G : Type u_6} → [Pow G M] → Pow (l.Germ G) M | true |
CategoryTheory.Cat.FreeRefl.instUniqueHom | Mathlib.CategoryTheory.Category.ReflQuiv | (V : Type u_2) →
[inst : CategoryTheory.ReflQuiver V] →
[Unique V] → [(x y : V) → Unique (x ⟶ y)] → (x y : CategoryTheory.Cat.FreeRefl V) → Unique (x ⟶ y) | true |
LinearIndepOn.id_insert | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
{x : V}, LinearIndepOn K id s → x ∉ Submodule.span K s → LinearIndepOn K id (insert x s) | true |
FreeAbelianGroup.support_of | Mathlib.Algebra.FreeAbelianGroup.Finsupp | ∀ {X : Type u_1} (x : X), (FreeAbelianGroup.of x).support = {x} | true |
Affine.Simplex.independent | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (self : Affine.Simplex k P n), AffineIndependent k self.points | true |
OreLocalization.instCommGroupWithZeroNonZeroDivisors._proof_1 | Mathlib.RingTheory.OreLocalization.NonZeroDivisors | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [inst_1 : Nontrivial R]
[inst_2 : OreLocalization.OreSet (nonZeroDivisors R)] [inst_3 : NoZeroDivisors R]
(a b : OreLocalization (nonZeroDivisors R) R), a / b = a * b⁻¹ | false |
Std.HashMap.Equiv.symm | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β}, m₁.Equiv m₂ → m₂.Equiv m₁ | true |
_private.Lean.Meta.Eqns.0.Lean.Meta.getEqnsFor?Core.match_3 | Lean.Meta.Eqns | (motive : Option (Option (Array Lean.Name)) → Sort u_1) →
(x : Option (Option (Array Lean.Name))) →
(Unit → motive none) → ((a : Option (Array Lean.Name)) → motive (some a)) → motive x | false |
CategoryTheory.Limits.CreatesFiniteLimits.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
autoParam
((J : Type) →
[inst_2 : CategoryTheory.SmallCategory J] →
[CategoryTheo... | false |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.eq_0_of_lt | Init.Data.Nat.Bitwise.Lemmas | ∀ (x : ℕ), x < 2 ^ 0 ↔ x = 0 | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer.noConfusion | Std.Sync.Channel | {P : Sort u} →
{α : Type} →
{t : Std.CloseableChannel.Consumer✝ α} →
{α' : Type} →
{t' : Std.CloseableChannel.Consumer✝¹ α'} →
α = α' → t ≍ t' → Std.CloseableChannel.Consumer.noConfusionType✝ P t t' | false |
Mathlib.Tactic.Ring.extractCoeff._sunfold | Mathlib.Tactic.Ring.Common | {a : Q(ℕ)} → Mathlib.Tactic.Ring.ExProd Mathlib.Tactic.Ring.sℕ a → Mathlib.Tactic.Ring.ExtractCoeff a | false |
TensorProduct.quotTensorEquivQuotSMul._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_2} (M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R),
Submodule.map (↑(TensorProduct.lid R M)) (TensorProduct.map (Submodule.subtype I) LinearMap.id).range = I • ⊤ | false |
List.forall₂_cons_left_iff | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {a : α} {l : List α} {u : List β},
List.Forall₂ R (a :: l) u ↔ ∃ b u', R a b ∧ List.Forall₂ R l u' ∧ u = b :: u' | true |
Polynomial.expand_monomial | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p q : ℕ) (r : R),
(Polynomial.expand R p) ((Polynomial.monomial q) r) = (Polynomial.monomial (q * p)) r | true |
Batteries.RBNode.toList_node | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {c : Batteries.RBColor} {a : Batteries.RBNode α} {x : α} {b : Batteries.RBNode α},
(Batteries.RBNode.node c a x b).toList = a.toList ++ x :: b.toList | true |
Matrix.isSymm_transpose_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {A : Matrix n n α}, A.transpose.IsSymm = A.IsSymm | false |
Std.Do.Spec.IterM.forIn_mapWithPostcondition | Std.Do.Triple.SpecLemmas | ∀ {α : Type u₁} {n : Type u₁ → Type u_1} {o : Type u₁ → Type u_2} {β₂ γ : Type u₁} {m : Type u₁ → Type u_3}
{β : Type u₁} {ps : Std.Do.PostShape} [inst : Monad m] [LawfulMonad m] [inst_2 : Monad n] [LawfulMonad n]
[inst_4 : Monad o] [LawfulMonad o] [inst_6 : Std.Do.WPMonad o ps] [inst_7 : MonadLiftT m n] [LawfulMon... | true |
SimpleGraph.chromaticNumber_mono_of_hom | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u} {G : SimpleGraph V} {V' : Type u_4} {G' : SimpleGraph V'} (f : G →g G'),
G.chromaticNumber ≤ G'.chromaticNumber | true |
NNReal.sqrt_pos_of_pos | Mathlib.Data.Real.Sqrt | ∀ {x : NNReal}, 0 < x → 0 < NNReal.sqrt x | true |
FP.ofRatUp | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → ℚ → FP.Float | true |
Lean.Meta.Grind.SplitStatus._sizeOf_inst | Lean.Meta.Tactic.Grind.Split | SizeOf Lean.Meta.Grind.SplitStatus | false |
Lean.IR.modifyJPsM | Lean.Compiler.IR.Basic | {m : Type → Type} → [Monad m] → Array Lean.IR.FnBody → (Lean.IR.FnBody → m Lean.IR.FnBody) → m (Array Lean.IR.FnBody) | true |
MeasureTheory.lintegral_sum_measure | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {ι : Type u_4} (f : α → ENNReal) (μ : ι → MeasureTheory.Measure α),
∫⁻ (a : α), f a ∂MeasureTheory.Measure.sum μ = ∑' (i : ι), ∫⁻ (a : α), f a ∂μ i | true |
HasEnoughRootsOfUnity.natCard_rootsOfUnity | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) [NeZero n] [HasEnoughRootsOfUnity M n], Nat.card ↥(rootsOfUnity n M) = n | true |
ENNReal.ofReal_ne_top._simp_1 | Mathlib.Data.ENNReal.Basic | ∀ {r : ℝ}, (ENNReal.ofReal r = ⊤) = False | false |
_private.Mathlib.RingTheory.Ideal.AssociatedPrime.Localization.0.Module.associatedPrimes.mem_associatedPrimes_of_comap_mem_associatedPrimes_of_isLocalizedModule._simp_1_9 | Mathlib.RingTheory.Ideal.AssociatedPrime.Localization | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
{x : M} {r : R}, (r • x ∈ N) = (r ∈ N.colon {x}) | false |
ArchimedeanClass.instLinearOrderedAddCommGroupWithTop._proof_6 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : Field R] [IsOrderedRing R], IsStrictOrderedRing R | false |
Aesop.Match.casesOn | Aesop.Forward.Match.Types | {motive : Aesop.Match → Sort u} →
(t : Aesop.Match) →
((subst : Aesop.Substitution) →
(patInstSubsts : Array Aesop.Substitution) →
(level : Aesop.SlotIndex) →
(forwardDeps conclusionDeps : Array Aesop.PremiseIndex) →
motive
{ subst := subst, patInstSubst... | false |
Set.preimage_const_mul_Iic | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b : α),
(fun x => a * x) ⁻¹' Set.Iic b = Set.Iic (b / a) | true |
RootPairingCat.coweightIsAddCommGroup | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {R : Type u} → [inst : CommRing R] → (self : RootPairingCat R) → AddCommGroup self.coweight | true |
Finset.falling.eq_1 | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : DecidableEq α] (k : ℕ) (𝒜 : Finset (Finset α)),
Finset.falling k 𝒜 = 𝒜.sup (Finset.powersetCard k) | true |
Real.iteratedFDeriv_fourierIntegral | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
{f : V → E} {N : ℕ∞},
(∀ (n : ℕ), ↑n ≤ N → MeasureTheory.Integrable (fun v... | true |
lTensor.inverse_of_rightInverse._proof_10 | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_1} {P : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_2) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | false |
_private.Init.Data.UInt.Lemmas.0.UInt32.toUInt8_lt._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a < b) = (a.toNat < b.toNat) | false |
Holor.instModule._proof_5 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : Semiring α] (r s : α) (x : Holor α ds), (r + s) • x = r • x + s • x | false |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurableSet_inl_image._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {s : Set (α ⊕ β)},
MeasurableSet s = (MeasurableSet (Sum.inl ⁻¹' s) ∧ MeasurableSet (Sum.inr ⁻¹' s)) | false |
List.isChain_cons_eq_iff_eq_replicate | Mathlib.Data.List.Chain | ∀ {α : Type u} {a : α} {l : List α}, List.IsChain (fun x1 x2 => x1 = x2) (a :: l) ↔ l = List.replicate l.length a | true |
iSupIndep_iff_pairwiseDisjoint | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_3} [inst : Order.Frame α] {f : ι → α}, iSupIndep f ↔ Pairwise (Function.onFun Disjoint f) | true |
Vitali.exists_disjoint_subfamily_covering_enlargement_closedBall | Mathlib.MeasureTheory.Covering.Vitali | ∀ {α : Type u_1} {ι : Type u_2} [inst : PseudoMetricSpace α] (t : Set ι) (x : ι → α) (r : ι → ℝ) (R : ℝ),
(∀ a ∈ t, r a ≤ R) →
∀ (τ : ℝ),
3 < τ →
∃ u ⊆ t,
(u.PairwiseDisjoint fun a => Metric.closedBall (x a) (r a)) ∧
∀ a ∈ t, ∃ b ∈ u, Metric.closedBall (x a) (r a) ⊆ Metric.clos... | true |
Algebra.IsPushout.cancelBaseChange | Mathlib.RingTheory.IsTensorProduct | (R : Type u_1) →
(S : Type v₃) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] →
(A : Type u_8) →
(B : Type u_9) →
[inst_3 : CommRing A] →
[inst_4 : CommRing B] →
[inst_5 : Algebra R A] →
... | true |
Prod.lex_iff | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {x y : α × β},
Prod.Lex r s x y ↔ r x.1 y.1 ∨ x.1 = y.1 ∧ s x.2 y.2 | true |
SemiNormedGrp.Hom.mk | Mathlib.Analysis.Normed.Group.SemiNormedGrp | {M N : SemiNormedGrp} → NormedAddGroupHom M.carrier N.carrier → M.Hom N | true |
AlgebraicGeometry.StructureSheaf.IsLocalization.to_basicOpen | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u) [inst : CommRing R] (r : R),
IsLocalization.Away r ↑((AlgebraicGeometry.Spec.structureSheaf R).obj.obj (Opposite.op (PrimeSpectrum.basicOpen r))) | true |
Metric.PiNatEmbed.continuous_distDenseSeq_inv | Mathlib.Topology.MetricSpace.PiNat | ∀ {X : Type u_3} [inst : MetricSpace X] [inst_1 : TopologicalSpace.SeparableSpace X],
Continuous Metric.PiNatEmbed.ofPiNat | true |
Real.instField._proof_5 | Mathlib.Data.Real.Basic | ∀ (a : ℝ), a ≠ 0 → a * a⁻¹ = 1 | false |
FiniteGaloisIntermediateField.noConfusionType | Mathlib.FieldTheory.Galois.GaloisClosure | Sort u →
{k : Type u_1} →
{K : Type u_2} →
[inst : Field k] →
[inst_1 : Field K] →
[inst_2 : Algebra k K] →
FiniteGaloisIntermediateField k K →
{k' : Type u_1} →
{K' : Type u_2} →
[inst' : Field k'] →
[inst'_1 ... | false |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.InsertUnitInvariant._proof_1 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment),
assignments.size = n → ∀ (i : Fin n), ↑i < assignments.size | false |
MonoidWithZeroHom.ValueGroup₀ | Mathlib.Algebra.GroupWithZero.Range | {A : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
[inst : FunLike F A B] →
F → [inst_1 : MonoidWithZero A] → [inst_2 : MonoidWithZero B] → [MonoidWithZeroHomClass F A B] → Type u_2 | true |
HasDerivWithinAt.hasFDerivWithinAt | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[inst_3 : TopologicalSpace F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜} [inst_4 : ContinuousSMul 𝕜 F] {f' : F},
HasDerivWithinAt f f' s x → HasFDerivWithinAt f (ContinuousLinearMap.toSpanSingleton 𝕜 f') s x | true |
Std.DHashMap.Raw.getKey | Std.Data.DHashMap.Raw | {α : Type u} →
{β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → (m : Std.DHashMap.Raw α β) → (a : α) → a ∈ m → α | true |
Std.IterM.toListRev.go | Init.Data.Iterators.Consumers.Monadic.Collect | {α : Type w} →
{m : Type w → Type w'} → [Monad m] → {β : Type w} → [Std.Iterator α m β] → Std.IterM m β → List β → m (List β) | true |
Std.DTreeMap.Internal.Impl.ordered_containsThenInsertIfNew! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] {k : α} {v : β k} {l : Std.DTreeMap.Internal.Impl α β},
l.Balanced → l.Ordered → (Std.DTreeMap.Internal.Impl.containsThenInsertIfNew! k v l).2.Ordered | true |
Lean.Meta.Occurrences.noConfusionType | Init.MetaTypes | Sort u → Lean.Meta.Occurrences → Lean.Meta.Occurrences → Sort u | false |
List.cons_diff_of_not_mem | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l₂ : List α},
a ∉ l₂ → ∀ (l₁ : List α), (a :: l₁).diff l₂ = a :: l₁.diff l₂ | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Affine.CoordinateRing.mk_ψ._simp_1_5 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | false |
RingEquivClass.toLinearEquivClassRat | Mathlib.Algebra.Algebra.Rat | ∀ {F : Type u_1} {R : Type u_2} {S : Type u_3} [inst : DivisionRing R] [inst_1 : CharZero R] [inst_2 : DivisionRing S]
[inst_3 : CharZero S] [inst_4 : EquivLike F R S] [RingEquivClass F R S], LinearEquivClass F ℚ R S | true |
_private.Init.Data.Int.Order.0.Int.mem_toNat?.match_1_9 | Init.Data.Int.Order | ∀ (m n : ℕ) (motive : Int.negSucc m = ↑n → Prop) (a : Int.negSucc m = ↑n), motive a | false |
Std.Time.Day.Offset.toMinutes | Std.Time.Date.Unit.Day | Std.Time.Day.Offset → Std.Time.Minute.Offset | true |
Turing.proj | Mathlib.Computability.TuringMachine.Tape | {ι : Type u_1} →
{Γ : ι → Type u_2} → [inst : (i : ι) → Inhabited (Γ i)] → (i : ι) → Turing.PointedMap ((i : ι) → Γ i) (Γ i) | true |
Std.DTreeMap.Internal.Impl.balance!.match_1 | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) →
(r : Std.DTreeMap.Internal.Impl α β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β k) →
motive
... | false |
CategoryTheory.Arrow.augmentedCechConerve_right | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom],
f.augmentedCechConerve.right = f.cechConerve | true |
ENNReal.tsum_eq_zero._simp_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {f : α → ENNReal}, (∑' (i : α), f i = 0) = ∀ (i : α), f i = 0 | false |
_private.Mathlib.Data.List.TFAE.0.List.forall_tfae._simp_1_2 | Mathlib.Data.List.TFAE | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α} {P : β → Prop}, (∀ i ∈ List.map f l, P i) = ∀ j ∈ l, P (f j) | false |
Std.Format.defUnicode | Init.Data.Format.Basic | Bool | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.IsTopologicalBasis.nonemptyCompacts.match_1_2 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} {B : Set (Set α)} ⦃u : Set (Set α)⦄ (motive : u ∈ {u | u.Finite ∧ u ⊆ B} → Prop)
(h : u ∈ {u | u.Finite ∧ u ⊆ B}), (∀ (hu : u.Finite) (huB : u ⊆ B), motive ⋯) → motive h | false |
Std.DTreeMap.Internal.Impl.recOn | Std.Data.DTreeMap.Internal.Def | {α : Type u} →
{β : α → Type v} →
{motive : Std.DTreeMap.Internal.Impl α β → Sort u_1} →
(t : Std.DTreeMap.Internal.Impl α β) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
motive l → motive r → motive (Std.D... | false |
one_div_pow | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (n : ℕ), (1 / a) ^ n = 1 / a ^ n | true |
QuadraticMap.polar_sub_right | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] (Q : QuadraticMap R M N) (x y y' : M),
QuadraticMap.polar (⇑Q) x (y - y') = QuadraticMap.polar (⇑Q) x y - QuadraticMap.polar (⇑Q) x y' | true |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Name.mapPrefix._sparseCasesOn_1 | Mathlib.Lean.Expr.Basic | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
LinearEquiv.uniqueProd_symm_apply | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] [inst_5 : Unique M₂] (a : M),
LinearEquiv.uniqueProd.symm a = (default, a) | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_380 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α) (h_2 : 2 ≤ List.count w [a, g a, g (g a)])
(h_3 : ¬[g a, g (g a)].Nodup) (w_1 : α) (h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1))
[g a,
g
(g
a)])[(List.find... | false |
Int.eq_mul_of_fdiv_eq_left | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, b ∣ a → a.fdiv b = c → a = c * b | true |
LightProfinite.instHasPropAndTotallyDisconnectedSpaceCarrierSecondCountableTopology | Mathlib.Topology.Category.LightProfinite.Basic | ∀ (X : Type u_1) [inst : TopologicalSpace X] [TotallyDisconnectedSpace X] [SecondCountableTopology X],
CompHausLike.HasProp (fun Y => TotallyDisconnectedSpace ↑Y ∧ SecondCountableTopology ↑Y) X | true |
PFun.image_mono | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} (f : α →. β) {s t : Set α}, s ⊆ t → f.image s ⊆ f.image t | true |
noZeroSMulDivisors_iff | Mathlib.Algebra.NoZeroSMulDivisors.Defs | ∀ (R : Type u_4) (M : Type u_5) [inst : Zero R] [inst_1 : Zero M] [inst_2 : SMul R M],
NoZeroSMulDivisors R M ↔ ∀ {c : R} {x : M}, c • x = 0 → c = 0 ∨ x = 0 | true |
RootPairing.GeckConstruction.equivRootSystem._proof_14 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {ι : Type u_1} {K : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : DecidableEq ι]
[inst_2 : Field K] [inst_3 : CharZero K] [inst_4 : AddCommGroup M] [inst_5 : Module K M] [inst_6 : AddCommGroup N]
[inst_7 : Module K N] {P : RootPairing ι K M N} [inst_8 : P.IsReduced] [inst_9 : P.IsCrystallog... | false |
Std.Internal.List.getValueD_filter_not_contains_map_fst_of_containsKey_eq_false_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α} {fallback : β},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = false →
Std.Internal.List.getValueD k (List.filter (fun p => !(List.map Sigma.fst l₂).contains p.fst) l₁) fallback =
S... | true |
neg_add_nonpos_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a b : α}, -a + b ≤ 0 ↔ b ≤ a | true |
Ordinal.familyOfBFamily'._proof_1 | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_1} (r : ι → ι → Prop) [inst : IsWellOrder ι r] {o : Ordinal.{u_1}},
Ordinal.type r = o → ∀ (i : ι), (Ordinal.typein r).toRelEmbedding i < o | false |
Monoid.CoprodI.NeWord.replaceHead.congr_simp | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {i j : ι} (x x_1 : M i) (e_x : x = x_1)
(_hnotone : x ≠ 1) (_w _w_1 : Monoid.CoprodI.NeWord M i j),
_w = _w_1 → Monoid.CoprodI.NeWord.replaceHead x _hnotone _w = Monoid.CoprodI.NeWord.replaceHead x_1 ⋯ _w_1 | true |
CategoryTheory.Limits.preservesColimitsOfShape_of_reflects_of_preserves | 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] {E : Type u₃} [ℰ : CategoryTheory.Category.{v₃, u₃} E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E)
[CategoryTheory... | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.State.rec | Lean.Elab.Tactic.Induction | {motive : Lean.Elab.Tactic.ElimApp.State✝ → Sort u} →
((argPos targetPos : ℕ) →
(motive_1 : Option Lean.MVarId) →
(f fType : Lean.Expr) →
(alts : Array Lean.Elab.Tactic.ElimApp.Alt) →
(insts : Array Lean.MVarId) →
motive
{ argPos := argPos, targetPos :... | false |
_private.Mathlib.Algebra.Order.Algebra.0.Mathlib.Meta.Positivity.evalAlgebraMap._proof_6 | Mathlib.Algebra.Order.Algebra | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | false |
Lean.Lsp.ColorInformation.range | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ColorInformation → Lean.Lsp.Range | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.