name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Meta.Grind.Arith.Linear.State.forbiddenNatModules._default | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.PHashSet Lean.Meta.Sym.ExprPtr | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap.0.Std.IterM.step_flattenAfter.match_3.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | {α₂ β : Type u_1} →
{m : Type u_1 → Type u_2} →
[inst : Std.Iterator α₂ m β] →
(it₂ : Std.IterM m β) →
(motive : it₂.Step → Sort u_3) →
(x : it₂.Step) →
((it₂' : Std.IterM m β) →
(out : β) →
(h : it₂.IsPlausibleStep (Std.IterStep.yield it₂' out... | true |
Array.reverse._proof_3 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (i : ℕ) (j : Fin as.size) (h : i < ↑j), ↑j - 1 < (as.swap i ↑j ⋯ ⋯).size | false |
MvPowerSeries.coeff_index_single_X | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : DecidableEq σ] (s t : σ),
(MvPowerSeries.coeff fun₀ | t => 1) (MvPowerSeries.X s) = if t = s then 1 else 0 | true |
Lean.IR.mkDummyExternDecl | Lean.Compiler.IR.Basic | Lean.IR.FunId → Array Lean.IR.Param → Lean.IR.IRType → Lean.IR.Decl | true |
Set.toFinset_Iio | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α) [inst_2 : Fintype ↑(Set.Iio a)],
(Set.Iio a).toFinset = Finset.Iio a | true |
FreeAddGroup.map_injective | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {β : Type v} {f : α → β}, Function.Injective f → Function.Injective ⇑(FreeAddGroup.map f) | true |
NormedAddGroupHom.recOn | Mathlib.Analysis.Normed.Group.Hom | {V : Type u_1} →
{W : Type u_2} →
[inst : SeminormedAddCommGroup V] →
[inst_1 : SeminormedAddCommGroup W] →
{motive : NormedAddGroupHom V W → Sort u} →
(t : NormedAddGroupHom V W) →
((toFun : V → W) →
(map_add' : ∀ (v₁ v₂ : V), toFun (v₁ + v₂) = toFun v₁ + toFun... | false |
ByteArray.append_left_inj | Init.Data.ByteArray.Lemmas | ∀ {xs₁ xs₂ : ByteArray} (ys : ByteArray), xs₁ ++ ys = xs₂ ++ ys ↔ xs₁ = xs₂ | true |
AddSubsemigroup.gciMapComap | Mathlib.Algebra.Group.Subsemigroup.Operations | {M : Type u_1} →
{N : Type u_2} →
[inst : Add M] →
[inst_1 : Add N] →
{f : M →ₙ+ N} → Function.Injective ⇑f → GaloisCoinsertion (AddSubsemigroup.map f) (AddSubsemigroup.comap f) | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int32.instRxcHasSize_eq | Init.Data.Range.Polymorphic.SInt | Int32.instRxcHasSize = HasModel.instRxcHasSize✝ | true |
_private.Init.Data.List.Basic.0.List.replicateTR_loop_eq.match_1_1 | Init.Data.List.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | false |
Int16.zero_add | Init.Data.SInt.Lemmas | ∀ (a : Int16), 0 + a = a | true |
Lean.Elab.Term.Do.Code.matchExpr.noConfusion | Lean.Elab.Do.Legacy | {P : Sort u} →
{ref : Lean.Syntax} →
{«meta» : Bool} →
{discr : Lean.Syntax} →
{alts : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)} →
{elseBranch : Lean.Elab.Term.Do.Code} →
{ref' : Lean.Syntax} →
{meta' : Bool} →
{discr' : Lean.Syntax... | false |
Std.HashMap.Raw.WF.mk | Std.Data.HashMap.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β}, m.inner.WF → m.WF | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurable_updateFinset'._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {δ : Type u_4} {X : δ → Type u_6} [inst : MeasurableSpace α] [inst_1 : (a : δ) → MeasurableSpace (X a)]
{g : α → (a : δ) → X a}, Measurable g = ∀ (a : δ), Measurable fun x => g x a | false |
Mathlib.Tactic.Translate.Reorder.recOn | Mathlib.Tactic.Translate.Reorder | {motive_1 : Mathlib.Tactic.Translate.Reorder → Sort u} →
{motive_2 : Array (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_3 : List (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_4 : ℕ × Mathlib.Tactic.Translate.Reorder → Sort u} →
(t : Mathlib.Tactic.Translate.Reorder) →
... | false |
Std.ExtHashSet.get!_eq_get!_get? | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
[inst_2 : Inhabited α] {a : α}, m.get! a = (m.get? a).get! | true |
CategoryTheory.Over.μ_pullback_left_fst_snd' | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X R Y Z : C} {f : R ⟶ X} (g₁ : Y ⟶ X) (g₂ : Z ⟶ X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Over.pullback f) (CategoryTheory.Over.mk g₁)
(C... | true |
ISize.xor_right_inj._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : ISize} (c : ISize), (c ^^^ a = c ^^^ b) = (a = b) | false |
KaehlerDifferential.endEquiv._proof_5 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
IsScalarTower R (TensorProduct R S S ⧸ KaehlerDifferential.ideal R S ^ 2)
(TensorProduct R S S ⧸ KaehlerDifferential.ideal R S ^ 2) | false |
CategoryTheory.monadicCreatesColimitsOfShapeOfPreservesColimitsOfShape._proof_3 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
(R : CategoryTheory.Functor D C) [inst_3 : CategoryTheory.MonadicRightAdjoint R]
[CategoryTheory.Limits.PreservesColimitsOfSh... | false |
Equiv.Set.imageOfInjOn._proof_2 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) (s : Set α) (p : ↑(f '' s)), ↑p ∈ f '' s | false |
Std.ExtHashMap.getElem_filterMap'._proof_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β}
[inst : LawfulBEq α] {f : α → β → Option γ} {k : α} {h : k ∈ Std.ExtHashMap.filterMap f m}, (f k m[k]).isSome = true | false |
KaehlerDifferential.endEquivAuxEquiv._proof_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(KaehlerDifferential.ideal R S).cotangentIdeal.IsTwoSided | false |
CategoryTheory.CommGrp.instCategory | Mathlib.CategoryTheory.Monoidal.CommGrp_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Category.{v₁, max u₁ v₁} (CategoryTheory.CommGrp C) | true |
_private.Std.Data.ByteSlice.0.ByteSlice.forM.loop | Std.Data.ByteSlice | {m : Type v → Type w} → [Monad m] → (UInt8 → m PUnit.{v + 1}) → ByteSlice → ℕ → m PUnit.{v + 1} | true |
Pi.Lex.instSupSetLexForall | Mathlib.Order.CompleteLattice.PiLex | {ι : Type u_1} →
{α : ι → Type u_2} →
[inst : LinearOrder ι] →
[(i : ι) → CompleteLinearOrder (α i)] → [WellFoundedLT ι] → SupSet (Lex ((i : ι) → (fun i => α i) i)) | true |
Right.inv_pos | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [MulPosReflectLT G₀] {a : G₀}, 0 < a⁻¹ ↔ 0 < a | true |
_private.Mathlib.Data.Finset.Basic.0.Finset.filter_and._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} (p q : α → Prop) [inst : DecidablePred p] [inst_1 : DecidablePred q] [inst_2 : DecidableEq α]
(s : Finset α), {a ∈ s | p a ∧ q a} = Finset.filter p s ∩ Finset.filter q s | false |
_private.Lean.Elab.Tactic.Unfold.0.Lean.Elab.Tactic.evalUnfold.go | Lean.Elab.Tactic.Unfold | Lean.Syntax → Lean.Elab.Tactic.Location → Lean.Elab.Tactic.TacticM Unit | true |
Array.flatten_toArray_map_toArray | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {L : List (List α)}, (List.map List.toArray L).toArray.flatten = L.flatten.toArray | true |
_private.Mathlib.Topology.Compactness.Compact.0.Filter.coprodᵢ_cocompact._simp_1_3 | Mathlib.Topology.Compactness.Compact | ∀ {α : Type u_1} {s t : Set α}, (sᶜ ⊆ tᶜ) = (t ⊆ s) | false |
CochainComplex.mappingCone.inr_f_descShortComplex_f | Mathlib.Algebra.Homology.HomotopyCategory.ShortExact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ)) (n : ℤ),
CategoryTheory.CategoryStruct.comp ((CochainComplex.mappingCone.inr S.f).f n)
((CochainComplex.mappingCone.descShortComplex S).f n) =
S.g.f n | true |
Finset.sym2_image | Mathlib.Data.Finset.Sym | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] (f : α → β) (s : Finset α),
(Finset.image f s).sym2 = Finset.image (Sym2.map f) s.sym2 | true |
ZFSet.instDefinableOfDefinable₁ | Mathlib.SetTheory.ZFC.Basic | (f : ZFSet.{u_1} → ZFSet.{u_1}) →
[ZFSet.Definable₁ f] →
(n : ℕ) → (g : (Fin n → ZFSet.{u_1}) → ZFSet.{u_1}) → [ZFSet.Definable n g] → ZFSet.Definable n fun s => f (g s) | true |
RCLike.tendsto_ofReal_cobounded_cobounded | Mathlib.Analysis.SpecificLimits.RCLike | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], Filter.Tendsto RCLike.ofReal (Bornology.cobounded ℝ) (Bornology.cobounded 𝕜) | true |
_private.Mathlib.Topology.Connected.PathConnected.0.IsPathConnected.joinedIn.match_1_1 | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {F : Set X} (motive : IsPathConnected F → Prop) (h : IsPathConnected F),
(∀ (_b : X) (_b_in : _b ∈ F) (hb : ∀ ⦃y : X⦄, y ∈ F → JoinedIn F _b y), motive ⋯) → motive h | false |
SupHom.dual_id | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} [inst : Max α], SupHom.dual (SupHom.id α) = InfHom.id αᵒᵈ | true |
_private.Mathlib.Algebra.Star.Subalgebra.0.Subalgebra.involutiveStar._simp_1 | Mathlib.Algebra.Star.Subalgebra | ∀ {α : Type u_1} {s : Set α} {a : α} [inst : Star α], (a ∈ star s) = (star a ∈ s) | false |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Array.0.Std.Iterators.Types.ArrayIterator.instIterator.match_1.eq_3 | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (motive : Std.IterStep (Std.IterM m α) α → Sort u_3)
(h_1 : (it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out))
(h_2 : (it : Std.IterM m α) → motive (Std.IterStep.skip it)) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
| ... | true |
Lean.Meta.getFunIndInfo? | Lean.Meta.Tactic.FunIndInfo | Bool → Bool → Lean.Name → Lean.CoreM (Option Lean.Meta.FunIndInfo) | true |
instMonadAttachReaderTOfMonad._proof_1 | Init.Control.Reader | ∀ {m : Type u_1 → Type u_2} {ρ : Type u_1} [inst : MonadAttach m] {α : Type u_1} (x : ReaderT ρ m α) (r : ρ) (a : α),
MonadAttach.CanReturn (x.run r) a → ∃ r, MonadAttach.CanReturn (x.run r) a | false |
AlgebraicGeometry.Scheme.AffineZariskiSite.PreservesLocalization.colimitDesc_preimage | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} (F : CategoryTheory.Functor X.AffineZariskiSiteᵒᵖ CommRingCat)
(α : (AlgebraicGeometry.Scheme.AffineZariskiSite.toOpensFunctor X).op.comp X.presheaf ⟶ F)
(H : CategoryTheory.NatTrans.Coequifibered α) (U : X.AffineZariskiSite),
(TopologicalSpace.Opens.map (AlgebraicGeometry.Scheme.... | true |
Tactic.NormNum.findNotPowerCertificate | Mathlib.Tactic.NormNum.Irrational | (m n : Q(ℕ)) → Lean.MetaM (Tactic.NormNum.NotPowerCertificate m n) | true |
Lean.SubExpr.GoalsLocation | Lean.SubExpr | Type | true |
MDifferentiableAt.smul_section | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {E : B → Type u_6} [inst : TopologicalSpace B]
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : (x : B) → TopologicalSpace (E x)]
[inst_3 : NormedAddCommGroup F] [inst_4 : NontriviallyNormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : FiberBundle F E... | true |
Lean.Elab.CheckTactic.elabCheckTactic._regBuiltin.Lean.Elab.CheckTactic.elabCheckTactic.declRange_3 | Lean.Elab.CheckTactic | IO Unit | false |
Mathlib.Tactic.Push.resolvePushId? | Mathlib.Tactic.Push | Lean.Term → Lean.Elab.TermElabM (Option Lean.Expr) | true |
Lean.Meta.Match.Example.rec | Lean.Meta.Match.Basic | {motive_1 : Lean.Meta.Match.Example → Sort u} →
{motive_2 : List Lean.Meta.Match.Example → Sort u} →
((a : Lean.FVarId) → motive_1 (Lean.Meta.Match.Example.var a)) →
motive_1 Lean.Meta.Match.Example.underscore →
((a : Lean.Name) →
(a_1 : List Lean.Meta.Match.Example) → motive_2 a_1 → mot... | false |
Submodule.inf_iInf | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
[Nonempty ι] {p : ι → Submodule R M} (q : Submodule R M), q ⊓ ⨅ i, p i = ⨅ i, q ⊓ p i | true |
_private.Mathlib.Analysis.Asymptotics.Defs.0.Asymptotics.IsLittleO.comp_snd._simp_1_1 | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =o[l] g = ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ | false |
Mathlib.Tactic.useLoop | Mathlib.Tactic.Use | Bool →
List Lean.MVarId →
List Lean.Term →
List Lean.MVarId → List Lean.MVarId → Lean.Elab.TermElabM (List Lean.MVarId × List Lean.MVarId × List Lean.MVarId) | true |
_private.Mathlib.LinearAlgebra.Matrix.Gershgorin.0.eigenvalue_mem_ball._simp_1_6 | Mathlib.LinearAlgebra.Matrix.Gershgorin | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | false |
Mathlib.Tactic.Sat.buildReify.reifyFmla | Mathlib.Tactic.Sat.FromLRAT | ℕ → Lean.Expr → Lean.Expr × Lean.Expr | true |
WithLp.unitizationAlgEquiv._proof_2 | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NormedField 𝕜] [inst_1 : NonUnitalNormedRing A] [inst_2 : NormedSpace 𝕜 A]
[inst_3 : IsScalarTower 𝕜 A A] [inst_4 : SMulCommClass 𝕜 A A] (R : Type u_3) [inst_5 : CommSemiring R]
[inst_6 : Algebra R 𝕜] [inst_7 : DistribMulAction R A] [inst_8 : IsScalarTower R 𝕜 A],
Fu... | false |
Lean.Elab.Term.elabLetTmpDecl._regBuiltin.Lean.Elab.Term.elabLetTmpDecl.declRange_3 | Lean.Elab.Binders | IO Unit | false |
Absorbs.eventually_nhds_zero | Mathlib.Analysis.LocallyConvex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedDivisionRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{s t : Set E}, Absorbs 𝕜 s t → 0 ∈ s → ∀ᶠ (c : 𝕜) in nhds 0, Set.MapsTo (fun x => c • x) t s | true |
iteratedFDerivWithin_two_apply' | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
(f : E → F) {z : E},
UniqueDiffOn 𝕜 s →
z ∈ s → ∀ (v w : E), (iteratedFDerivWithin 𝕜 2 f s z) ![... | true |
CategoryTheory.Functor.mapMonFunctor._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (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] [inst_3 : CategoryTheory.MonoidalCategory D]
{X Y Z : CategoryTheory.LaxMonoidalFunctor C D} (x : X ⟶ Y) (x_1 : Y ⟶ Z) (A : CategoryTheory.Mon C)... | false |
CategoryTheory.Subfunctor.IsGeneratedBy.mem | Mathlib.CategoryTheory.Subfunctor.Finite | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor Cᵒᵖ (Type w)}
{G : CategoryTheory.Subfunctor F} {ι : Type w'} {X : ι → Cᵒᵖ} {x : (i : ι) → F.obj (X i)},
G.IsGeneratedBy x → ∀ (i : ι), x i ∈ G.obj (X i) | true |
Poly.instAddCommGroup._proof_9 | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} (n : ℕ) (a : Poly α), zsmulRec nsmulRec (↑n.succ) a = zsmulRec nsmulRec (↑n) a + a | false |
AlgEquivClass | Mathlib.Algebra.Algebra.Equiv | (F : Type u_1) →
(R : outParam (Type u_2)) →
(A : outParam (Type u_3)) →
(B : outParam (Type u_4)) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Semiring B] → [Algebra R A] → [Algebra R B] → [EquivLike F A B] → Prop | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.atMostAux._unsafe_rec | Lean.DocString.Parser | ℕ → Lean.Parser.ParserFn → String → Lean.Parser.ParserFn | false |
QuadraticAlgebra.coe_ofNat | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : AddCommMonoidWithOne R] (n : ℕ) [inst_1 : n.AtLeastTwo],
QuadraticAlgebra.C (OfNat.ofNat n) = OfNat.ofNat n | true |
_private.Mathlib.Topology.Category.TopCat.Limits.Konig.0.TopCat.nonempty_limitCone_of_compact_t2_cofiltered_system._proof_1_2 | Mathlib.Topology.Category.TopCat.Limits.Konig | ∀ {J : Type u_1} {X Y : J}, Y ∈ {X, Y} | false |
Matrix.vecMulLinear._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : Semiring R] {n : Type u_2}, SMulCommClass R Rᵐᵒᵖ (n → R) | false |
_private.Mathlib.Algebra.Polynomial.Div.0.Polynomial.X_pow_dvd_iff._simp_1_4 | Mathlib.Algebra.Polynomial.Div | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∀ (a : α), p a) = True | false |
CategoryTheory.ShortComplex.SnakeInput.h₃ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
(self : CategoryTheory.ShortComplex.SnakeInput C) →
CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ self.v₂₃ ⋯) | true |
BoundedContinuousFunction.mkOfBound.congr_simp | Mathlib.MeasureTheory.Measure.DiracProba | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] (f f_1 : C(α, β)) (e_f : f = f_1)
(C C_1 : ℝ) (e_C : C = C_1) (h : ∀ (x y : α), dist (f x) (f y) ≤ C),
BoundedContinuousFunction.mkOfBound f C h = BoundedContinuousFunction.mkOfBound f_1 C_1 ⋯ | true |
CategoryTheory.Functor.mapAction_δ_hom | Mathlib.CategoryTheory.Action.Monoidal | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {W : Type u_3}
[inst_2 : CategoryTheory.Category.{v_2, u_3} W] [inst_3 : CategoryTheory.MonoidalCategory V]
[inst_4 : CategoryTheory.MonoidalCategory W] (F : CategoryTheory.Functor V W) [inst_5 : F.OplaxMonoidal]
(X ... | true |
AddMonoid.Coprod.swap._proof_4 | Mathlib.GroupTheory.Coprod.Basic | ∀ (M : Type u_1) (N : Type u_2) [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (x y : N),
(AddMonoid.Coprod.mk.comp (FreeAddMonoid.map Sum.swap)) (FreeAddMonoid.of (Sum.inr (x + y))) =
(AddMonoid.Coprod.mk.comp (FreeAddMonoid.map Sum.swap))
(FreeAddMonoid.of (Sum.inr x) + FreeAddMonoid.of (Sum.inr y)) | false |
ContinuousAddEquiv.ofUnique | Mathlib.Topology.Algebra.ContinuousMonoidHom | {M : Type u_3} →
{N : Type u_4} →
[Unique M] →
[Unique N] →
[inst : Add M] → [inst_1 : Add N] → [inst_2 : TopologicalSpace M] → [inst_3 : TopologicalSpace N] → M ≃ₜ+ N | true |
Sym.filterNe.eq_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] (a : α) (m : Sym α n),
Sym.filterNe a m = ⟨⟨Multiset.count a ↑m, ⋯⟩, ⟨Multiset.filter (fun x => a ≠ x) ↑m, ⋯⟩⟩ | true |
IncompRel.rfl | Mathlib.Order.Comparable | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Irrefl r] {a : α}, IncompRel r a a | true |
CategoryTheory.Functor.instCommShiftCochainComplexIntObjFlipMap₂CochainComplex._proof_2 | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_2} {C₂ : Type u_6} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_5, u_6} C₂] [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
[inst_3 : CategoryTheory.Preadditive C₁] [inst_4 : CategoryTheory.Preadditive C₂]
[inst_5 : CategoryTheory.Preadditive D]... | false |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.evalIntOfNat._sparseCasesOn_5 | Mathlib.Tactic.NormNum.Basic | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
isPullbackOfIsTerminalIsProduct | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W X Y Z : C} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
(h : W ⟶ X) →
(k : W ⟶ Y) →
(H₁ : CategoryTheory.Limits.IsTerminal Z) →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.BinaryFan.mk h k) →
... | true |
List.sum_le_foldr_max | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : Zero N] [inst_2 : LinearOrder N] (f : M → N),
f 0 ≤ 0 → (∀ (x y : M), f (x + y) ≤ max (f x) (f y)) → ∀ (l : List M), f l.sum ≤ List.foldr max 0 (List.map f l) | true |
IO.FS.SystemTime.mk.inj | Init.System.IO | ∀ {sec : ℤ} {nsec : UInt32} {sec_1 : ℤ} {nsec_1 : UInt32},
{ sec := sec, nsec := nsec } = { sec := sec_1, nsec := nsec_1 } → sec = sec_1 ∧ nsec = nsec_1 | true |
Polynomial.cyclotomic.isCoprime_rat | Mathlib.RingTheory.Polynomial.Cyclotomic.Roots | ∀ {n m : ℕ}, n ≠ m → IsCoprime (Polynomial.cyclotomic n ℚ) (Polynomial.cyclotomic m ℚ) | true |
Batteries.BinomialHeap.Imp.Heap.WF.findMin._proof_3 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} {le : α → α → Bool} {res : Batteries.BinomialHeap.Imp.FindMin α} (a : α),
le res.val a = false → false = le res.val a | false |
TopologicalSpace.IsOpenCover.eq_1 | Mathlib.Topology.Sets.OpenCover | ∀ {ι : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] (u : ι → TopologicalSpace.Opens X),
TopologicalSpace.IsOpenCover u = (iSup u = ⊤) | true |
OrderIso.prodAssoc | Mathlib.Order.Hom.Basic | (α : Type u_6) →
(β : Type u_7) → (γ : Type u_8) → [inst : LE α] → [inst_1 : LE β] → [inst_2 : LE γ] → (α × β) × γ ≃o α × β × γ | true |
Language.instMulLeftMono | Mathlib.Computability.Language | ∀ {α : Type u_1}, MulLeftMono (Language α) | true |
translate_sub_right | Mathlib.Algebra.Group.Translate | ∀ {α : Type u_2} {G : Type u_5} [inst : AddCommGroup G] [inst_1 : Sub α] (a : G) (f g : G → α),
translate a (f - g) = translate a f - translate a g | true |
Rep.instAddCommGroupHom._proof_10 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_2} {G : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] {A B : Rep.{u_1, u_2, u_3} k G} (a : A ⟶ B),
-a + a = 0 | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeSomeUsingDefaultPrio.visit | Lean.Elab.SyntheticMVars | ℕ → List Lean.MVarId → List Lean.MVarId → Lean.Elab.TermElabM Bool | true |
dite_eq_or_eq | Mathlib.Logic.Basic | ∀ {α : Sort u_1} (P : Prop) [inst : Decidable P] {A : P → α} {B : ¬P → α},
(∃ (h : P), dite P A B = A h) ∨ ∃ (h : ¬P), dite P A B = B h | true |
Lean.Meta.Closure.MkValueTypeClosureResult | Lean.Meta.Closure | Type | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Defs.0.EisensteinSeries.gammaSetEquiv._simp_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Defs | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
(A B : Matrix.SpecialLinearGroup n R), ↑A * ↑B = ↑(A * B) | false |
Array.of_mem_zip | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} {as : Array α} {bs : Array β}, (a, b) ∈ as.zip bs → a ∈ as ∧ b ∈ bs | true |
Std.DTreeMap.Internal.Impl.getKeyD_insert! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {k a fallback : α} {v : β k},
(Std.DTreeMap.Internal.Impl.insert! k v t).getKeyD a fallback =
if compare k a = Ordering.eq then k else t.getKeyD a fallback | true |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.JoinPointFinder.findCandidate? | Lean.Compiler.LCNF.JoinPoints | Lean.FVarId → Lean.Compiler.LCNF.JoinPointFinder.FindM (Option Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo) | true |
ContinuousAffineEquiv.image_eq_preimage_symm | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁]
[inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂] [inst_8 : TopologicalSpace P₂]
(... | true |
CategoryTheory.AdditiveFunctor.ofLeftExact | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | (C : Type u₁) →
(D : Type u₂) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
[CategoryTheory.Limits.HasZeroObject C] →
[CategoryThe... | true |
Set.encard_eq_three | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, s.encard = 3 ↔ ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z} | true |
MeasureTheory.Lp.fourierTransformₗᵢ._proof_15 | Mathlib.Analysis.Fourier.LpSpace | ∀ (F : Type u_1) [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℂ F], IsBoundedSMul ℝ F | false |
Set.mulIndicator_mul_eq_left | Mathlib.Algebra.Group.Indicator | ∀ {α : Type u_1} {M : Type u_4} [inst : MulOneClass M] {f g : α → M},
Disjoint (Function.mulSupport f) (Function.mulSupport g) → (Function.mulSupport f).mulIndicator (f * g) = f | true |
_private.Mathlib.NumberTheory.FLT.Three.0.fermatLastTheoremThree_of_dvd_a_of_gcd_eq_one_of_case2._simp_1_3 | Mathlib.NumberTheory.FLT.Three | ∀ (z : ℤ), normalize z = |z| | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.