name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AddActionHom.prodMap._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_5} {N : Type u_6} {α : Type u_1} {β : Type u_2} {γ : Type u_4} {δ : Type u_3} [inst : VAdd M α]
[inst_1 : VAdd M β] [inst_2 : VAdd N γ] [inst_3 : VAdd N δ] {σ : M → N} (f : α →ₑ[σ] γ) (g : β →ₑ[σ] δ) (m : M)
(x : α × β),
((f.comp (AddActionHom.fst M α β)).prod (g.comp (AddActionHom.snd M α β))).toFu... | false |
Lean.DefinitionVal.getSafetyEx | Lean.Declaration | Lean.DefinitionVal → Lean.DefinitionSafety | true |
CategoryTheory.Functor.WellOrderInductionData.ofExists._proof_4 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_2)}
(h₁ : ∀ (j : J), ¬IsMax j → Function.Surjective (F.map (CategoryTheory.homOfLE ⋯).op)) (j : J) (hj : ¬IsMax j)
(x : F.obj (Opposite.op j)), F.map (CategoryTheory.homOfLE ⋯).op ⋯.choose = x | false |
Aesop.EqualUpToIdsM.run' | Aesop.Util.EqualUpToIds | {α : Type} →
Aesop.EqualUpToIdsM α →
Option Lean.MetavarContext →
Lean.MetavarContext → Lean.MetavarContext → Bool → Lean.MetaM (α × Aesop.EqualUpToIdsM.State) | true |
Lean.isIdRestAscii | Init.Meta.Defs | UInt8 → Bool | true |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Ici_erase._simp_1_4 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) | false |
Lean.Grind.CommRing.Poly.combine.go.eq_5 | Init.Grind.Ring.CommSolver | ∀ (fuel_2 : ℕ) (k₁ : ℤ) (m₁ : Lean.Grind.CommRing.Mon) (p₁_2 : Lean.Grind.CommRing.Poly) (k₂ : ℤ)
(m₂ : Lean.Grind.CommRing.Mon) (p₂_2 : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.combine.go fuel_2.succ (Lean.Grind.CommRing.Poly.add k₁ m₁ p₁_2)
(Lean.Grind.CommRing.Poly.add k₂ m₂ p₂_2) =
match m₁... | true |
Int32.maxValue_le_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ {a : Int32}, (Int32.maxValue ≤ a) = (a = Int32.maxValue) | false |
Filter.Germ.instAddAction._proof_2 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {M : Type u_3} [inst : AddMonoid M] [inst_1 : AddAction M β] (f : α → β),
0 +ᵥ ↑f = ↑f | false |
RingHom.FinitePresentation.comp_surjective | Mathlib.RingTheory.FinitePresentation | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : CommRing C]
{f : A →+* B} {g : B →+* C},
f.FinitePresentation → Function.Surjective ⇑g → (RingHom.ker g).FG → (g.comp f).FinitePresentation | true |
CategoryTheory.WithTerminal.coneEquiv._proof_5 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {J : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
{X_1 Y : CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K)} (f : X_1 ⟶ Y),
CategoryTheory.CategoryS... | false |
SubgroupClass.inclusion_self | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {S : Type u_4} {H : S} [inst_1 : SetLike S G] [inst_2 : SubgroupClass S G]
[inst_3 : Preorder S] [inst_4 : IsConcreteLE S G] (x : ↥H), (SubgroupClass.inclusion ⋯) x = x | true |
Congruent.index_equiv._simp_1 | Mathlib.Topology.MetricSpace.Congruence | ∀ {ι : Type u_1} {ι' : Type u_2} {P₁ : Type u_3} {P₂ : Type u_4} [inst : PseudoEMetricSpace P₁]
[inst_1 : PseudoEMetricSpace P₂] {E : Type u_7} [inst_2 : EquivLike E ι' ι] (f : E) (v₁ : ι → P₁) (v₂ : ι → P₂),
Congruent (v₁ ∘ ⇑f) (v₂ ∘ ⇑f) = Congruent v₁ v₂ | false |
diagonal_dotProduct | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NonUnitalNonAssocSemiring α]
(v w : m → α) (i : m), Matrix.diagonal v i ⬝ᵥ w = v i * w i | true |
CategoryTheory.ShortComplex.descRightHomology | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) →
{A : C} →
(k : S.X₂ ⟶ A) →
CategoryTheory.CategoryStruct.comp S.f k = 0 → [inst_2 : S.HasRightHomology] → S.rightHomology... | true |
CategoryTheory.Limits.Types.limitConeIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J (Type (max u_3 u_2)))
(s : CategoryTheory.Limits.Cone F) (j : J),
CategoryTheory.CategoryStruct.comp (fun v => ⟨fun j => s.π.app j v, ⋯⟩)
((CategoryTheory.Limits.Types.limitCone F).π.app j) =
s.π.app j | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.size_union_of_not_mem._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {k : α},
(k ∉ m) = (m.contains k = false) | false |
List.range'_eq_singleton_iff._simp_1 | Init.Data.List.Nat.Range | ∀ {s n a : ℕ}, (List.range' s n = [a]) = (s = a ∧ n = 1) | false |
CommBialgCat.isoEquivBialgEquiv._proof_1 | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : Type u_1} [inst_1 : CommRing X] [inst_2 : Bialgebra R X]
[inst_3 : CommRing Y] [inst_4 : Bialgebra R Y] (x : CommBialgCat.of R X ≅ CommBialgCat.of R Y),
CommBialgCat.isoMk (CommBialgCat.bialgEquivOfIso x) = CommBialgCat.isoMk (CommBialgCat.bialgEquivOfIso x) | false |
AddEquiv.ext_int_iff | Mathlib.Data.Int.Cast.Lemmas | ∀ {A : Type u_5} [inst : AddMonoid A] {f g : ℤ ≃+ A}, f = g ↔ f 1 = g 1 | true |
logDeriv.eq_1 | Mathlib.Analysis.Calculus.LogDeriv | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] (f : 𝕜 → 𝕜'), logDeriv f = deriv f / f | true |
Lean.Server.FileWorker.SignatureHelp.CandidateKind.toCtorIdx | Lean.Server.FileWorker.SignatureHelp | Lean.Server.FileWorker.SignatureHelp.CandidateKind → ℕ | false |
closureAddCommutatorRepresentatives.eq_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : AddGroup G],
closureAddCommutatorRepresentatives G =
AddSubgroup.closure (Prod.fst '' addCommutatorRepresentatives G ∪ Prod.snd '' addCommutatorRepresentatives G) | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.trapezoidal_error_le_of_lt._simp_1_4 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
ContinuousLinearMap.instMeasurableSpace._proof_1 | Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], IsTopologicalAddGroup F | false |
Path.trans_apply | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y z : X} (γ : Path x y) (γ' : Path y z) (t : ↑unitInterval),
(γ.trans γ') t = if h : ↑t ≤ 1 / 2 then γ ⟨2 * ↑t, ⋯⟩ else γ' ⟨2 * ↑t - 1, ⋯⟩ | true |
mfderivWithin_prodMap | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
RelSeries.head_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {β : Type u_2} {s : SetRel β β} (p : RelSeries r) (f : r.Hom s),
(p.map f).head = f p.head | true |
Lean.Server.Completion.HoverInfo.noConfusionType | Lean.Server.Completion.CompletionUtils | Sort u → Lean.Server.Completion.HoverInfo → Lean.Server.Completion.HoverInfo → Sort u | false |
IsAddUnit.addUnit_add | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {a b : M} (ha : IsAddUnit a) (hb : IsAddUnit b),
⋯.addUnit = ha.addUnit + hb.addUnit | true |
MonoidHom.finsuppProd_apply | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_7} {N : Type u_10} {P : Type u_11} [inst : Zero β] [inst_1 : MulOneClass N]
[inst_2 : CommMonoid P] (f : α →₀ β) (g : α → β → N →* P) (x : N), (f.prod g) x = f.prod fun i fi => (g i fi) x | true |
CategoryTheory.Limits.Types.Small.productLimitCone | Mathlib.CategoryTheory.Limits.Types.Products | {J : Type v} → (F : J → Type u) → [Small.{u, v} J] → CategoryTheory.Limits.LimitCone (CategoryTheory.Discrete.functor F) | true |
Std.Do.SPred.entails.refl._simp_1 | Std.Do.SPred.Laws | ∀ {σs : List (Type u)} (P : Std.Do.SPred σs), (P ⊢ₛ P) = True | false |
abs_pow_eq_one | Mathlib.Algebra.Order.Ring.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {n : ℕ} (a : α),
n ≠ 0 → (|a ^ n| = 1 ↔ |a| = 1) | true |
Pi.uniformSpace.eq_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)],
Pi.uniformSpace α =
UniformSpace.ofCoreEq (⨅ i, UniformSpace.comap (Function.eval i) (U i)).toCore Pi.topologicalSpace ⋯ | true |
Aesop.RappId.instLT | Aesop.Tree.Data | LT Aesop.RappId | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{w : ℕ} →
(aig : Std.Sat.AIG α) →
(motive : aig.ArbitraryShiftTarget w → Sort u_1) →
(target : aig.ArbitraryShiftTarget w) →
((n : ℕ) →
(input : aig.RefVec w) →
(di... | false |
mem_absConvexHull_iff | Mathlib.Analysis.LocallyConvex.AbsConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : AddCommMonoid E]
[inst_3 : PartialOrder 𝕜] {s : Set E} {x : E}, x ∈ (absConvexHull 𝕜) s ↔ ∀ (t : Set E), s ⊆ t → AbsConvex 𝕜 t → x ∈ t | true |
_private.Lean.Meta.Basic.0.Lean.Meta.getConstTemp?._sparseCasesOn_1 | Lean.Meta.Basic | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
(Nat.hasNotBit 6 t.ctorIdx → motive t) → motive t | false |
Polynomial.eval₂_finset_sum | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} {S : Type v} {ι : Type y} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (s : Finset ι)
(g : ι → Polynomial R) (x : S), Polynomial.eval₂ f x (∑ i ∈ s, g i) = ∑ i ∈ s, Polynomial.eval₂ f x (g i) | true |
Aesop.ForwardHypData | Aesop.RuleTac.Forward.Basic | Type | true |
CoeT.mk.noConfusion | Init.Coe | {α : Sort u} →
{x : α} → {β : Sort v} → {P : Sort u_1} → {coe coe' : β} → { coe := coe } = { coe := coe' } → (coe ≍ coe' → P) → P | false |
Lean.MetavarContext.MkBinding.Context.noConfusionType | Lean.MetavarContext | Sort u → Lean.MetavarContext.MkBinding.Context → Lean.MetavarContext.MkBinding.Context → Sort u | false |
WeierstrassCurve.Jacobian.addZ_self | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R), WeierstrassCurve.Jacobian.addZ P P = 0 | true |
Nat.getD_toList_roc_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i fallback : ℕ}, n ≤ i + m → (m<...=n).toList.getD i fallback = fallback | true |
_private.Mathlib.Algebra.TrivSqZeroExt.Basic.0.TrivSqZeroExt.isUnit_inv_iff._simp_1_3 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] {a : G₀}, (a⁻¹ = 0) = (a = 0) | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.map.match_1.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (X Y : CategoryTheory.WithTerminal C) → (X ⟶ Y) → Sort u_3)
(x : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.star)
(h_1 :
(a a_1 : C) →
(f : CategoryTheory.WithTerminal.of a ⟶ CategoryTheory.WithTerminal.of a_1) ... | true |
Lean.Parser.Term.optSemicolon.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer | true |
Finset.biUnion_congr | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Finset α} {t₁ t₂ : α → Finset β} [inst : DecidableEq β],
s₁ = s₂ → (∀ a ∈ s₁, t₁ a = t₂ a) → s₁.biUnion t₁ = s₂.biUnion t₂ | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.OnCycleFactors.nat_card_range_toPermHom._simp_1_7 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b | false |
Std.TreeSet.forIn_eq_forIn | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {δ : Type w} {m : Type w → Type w'} [inst : Monad m]
[LawfulMonad m] {f : α → δ → m (ForInStep δ)} {init : δ}, Std.TreeSet.forIn f init t = forIn t init f | true |
Matrix.submatrix_gram | Mathlib.Analysis.InnerProductSpace.GramMatrix | ∀ {E : Type u_1} {n : Type u_2} {𝕜 : Type u_4} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] (v : n → E) {m : Set n} (f : ↑m → n),
(Matrix.gram 𝕜 v).submatrix f f = Matrix.gram 𝕜 (v ∘ f) | true |
Subalgebra.frontier_spectrum | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜 : Type u_3} {A : Type u_4} {SA : Type u_5} [inst : NormedRing A] [CompleteSpace A] [inst_2 : SetLike SA A]
[inst_3 : SubringClass SA A] [inst_4 : NormedField 𝕜] [inst_5 : NormedAlgebra 𝕜 A] [instSMulMem : SMulMemClass SA 𝕜 A]
(S : SA) [hS : IsClosed ↑S] (x : ↥S), frontier (spectrum 𝕜 x) ⊆ spectrum 𝕜 ↑x | true |
HahnSeries.SummableFamily.hasFiniteSupport_smul | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} {α : Type u_5} {β : Type u_6} [inst : PartialOrder Γ]
[inst_1 : PartialOrder Γ'] [inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid R] [inst_4 : SMulWithZero R V]
(s : HahnSeries.SummableFamily Γ R α) (t : HahnSeries.SummableFamily Γ' V β) (gh : Γ × Γ')... | true |
ProbabilityTheory.IsFiniteKernel.exists_univ_le | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
[self : ProbabilityTheory.IsFiniteKernel κ], ∃ C < ⊤, ∀ (a : α), (κ a) Set.univ ≤ C | true |
CompletelyPositiveMap.map_cstarMatrix_nonneg' | Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap | ∀ {A₁ : Type u_1} {A₂ : Type u_2} [inst : NonUnitalCStarAlgebra A₁] [inst_1 : NonUnitalCStarAlgebra A₂]
[inst_2 : PartialOrder A₁] [inst_3 : PartialOrder A₂] [inst_4 : StarOrderedRing A₁] [inst_5 : StarOrderedRing A₂]
(self : CompletelyPositiveMap A₁ A₂) (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁), 0 ≤ M → 0 ≤ M.m... | true |
CategoryTheory.Functor.IsLocallyDirected.casesOn | Mathlib.CategoryTheory.LocallyDirected | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{F : CategoryTheory.Functor J (Type u_2)} →
{motive : F.IsLocallyDirected → Sort u} →
(t : F.IsLocallyDirected) →
((cond :
∀ {i j k : J} (fi : i ⟶ k) (fj : j ⟶ k) (xi : F.obj i) (xj : F.obj j),
... | false |
contDiffOn_clm_apply | Mathlib.Analysis.Calculus.ContDiff.FiniteDimension | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {D : Type uD} [inst_1 : NormedAddCommGroup D]
[inst_2 : NormedSpace 𝕜 D] {E : Type uE} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {F : Type uF}
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {n : WithTop ℕ∞} [CompleteSpace 𝕜] {f :... | true |
CategoryTheory.Functor.obj.ζ_def | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] (X : C) [inst_5 : CategoryTheory.AddMonObj X],
... | true |
ZMod.intCast_eq_zero_iff_even | Mathlib.Data.ZMod.Basic | ∀ {n : ℤ}, ↑n = 0 ↔ Even n | true |
generatePiSystem.inter | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {S : Set (Set α)} {s t : Set α},
generatePiSystem S s → generatePiSystem S t → (s ∩ t).Nonempty → generatePiSystem S (s ∩ t) | true |
_private.Mathlib.Computability.StateTransition.0.StateTransition.tr_eval'.match_1_1 | Mathlib.Computability.StateTransition | ∀ {σ₁ σ₂ : Type u_1} (f₁ : σ₁ → Option σ₁) (tr : σ₁ → σ₂) (a₁ : σ₁) (b₂ : σ₂)
(motive : (∃ b₁, tr b₁ = b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁) → Prop)
(x : ∃ b₁, tr b₁ = b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁),
(∀ (b₁ : σ₁) (bb : tr b₁ = b₂) (hb : b₁ ∈ StateTransition.eval f₁ a₁), motive ⋯) → motive x | false |
ContinuousLinearMap.mulLeftRight._proof_3 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (R : Type u_2) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R], SMulCommClass 𝕜 𝕜 (R →L[𝕜] R) | false |
Std.HashMap.getKey!_filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → β → Option γ} {k : α},
(Std.HashMap.filterMap f m).getKey! k = ((m.getKey? k).pfilter fun x_2 h' => (f x_2 m[x_2]).isSome).get! | true |
Bifunctor.mapEquiv_refl_refl | Mathlib.Logic.Equiv.Functor | ∀ {α : Type u} {α' : Type v} (F : Type u → Type v → Type w) [inst : Bifunctor F] [inst_1 : LawfulBifunctor F],
Bifunctor.mapEquiv F (Equiv.refl α) (Equiv.refl α') = Equiv.refl (F α α') | true |
CategoryTheory.CategoryOfElements.instHasInitialElementsOfIsCorepresentable | Mathlib.CategoryTheory.Limits.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type u_1)}
[F.IsCorepresentable], CategoryTheory.Limits.HasInitial F.Elements | true |
Std.TreeMap.Raw.getKey?_insert_self | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).getKey? k = some k | true |
DistLat.mk.injEq | Mathlib.Order.Category.DistLat | ∀ (carrier : Type u_1) [str : DistribLattice carrier] (carrier_1 : Type u_1) (str_1 : DistribLattice carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) | true |
DiffContOnCl.ball_subset_image_closedBall | Mathlib.Analysis.Complex.OpenMapping | ∀ {f : ℂ → ℂ} {z₀ : ℂ} {ε r : ℝ},
DiffContOnCl ℂ f (Metric.ball z₀ r) →
0 < r →
(∀ z ∈ Metric.sphere z₀ r, ε ≤ ‖f z - f z₀‖) →
(∃ᶠ (z : ℂ) in nhds z₀, f z ≠ f z₀) → Metric.ball (f z₀) (ε / 2) ⊆ f '' Metric.closedBall z₀ r | true |
PartialEquiv.disjointUnion._proof_5 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_2} {β : Type u_1} (e e' : PartialEquiv α β), e.target.ite e.target e'.target = e.target ∪ e'.target | false |
NoetherNormalization.T1._proof_1 | Mathlib.RingTheory.NoetherNormalization | ∀ {n : ℕ}, NeZero (n + 1) | false |
_private.Mathlib.Probability.ProbabilityMassFunction.Monad.0.PMF.bindOnSupport_eq_zero_iff._simp_1_1 | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {f : α → ENNReal}, (∑' (i : α), f i = 0) = ∀ (i : α), f i = 0 | false |
Homotopy.mkCoinductiveAux₂._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : CochainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 1 ⟶ Q.X 0),
e.f 0 = CategoryTheory.CategoryStruct.comp (P.d 0 1) zero →
e.f 0 =
CategoryTheory.CategoryStruct.comp 0 (HomologicalComplex.dTo Q 0) +
... | false |
BitVec.toNat_intMin | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, (BitVec.intMin w).toNat = 2 ^ (w - 1) % 2 ^ w | true |
HMul.hMul | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → [self : HMul α β γ] → α → β → γ | true |
ContinuousLinearMap.smulRight.congr_simp | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {M₁ : Type u_4} [inst : TopologicalSpace M₁] [inst_1 : AddCommMonoid M₁] {M₂ : Type u_6}
[inst_2 : TopologicalSpace M₂] [inst_3 : AddCommMonoid M₂] {R : Type u_9} {S : Type u_10} [inst_4 : Semiring R]
[inst_5 : Semiring S] [inst_6 : Module R M₁] [inst_7 : Module R M₂] [inst_8 : Module R S] [inst_9 : Module S M₂]
... | true |
Set.finset_prod_mem_finset_prod | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] (t : Finset ι) (f : ι → Set α) (g : ι → α),
(∀ i ∈ t, g i ∈ f i) → ∏ i ∈ t, g i ∈ ∏ i ∈ t, f i | true |
SimpleGraph.Walk.isHamiltonianCycle_iff_isCycle_and_length_eq | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a} [inst_1 : Fintype α],
p.IsHamiltonianCycle ↔ p.IsCycle ∧ p.length = Fintype.card α | true |
EMetricSpace.rec | Mathlib.Topology.EMetricSpace.Defs | {α : Type u} →
{motive : EMetricSpace α → Sort u_1} →
([toPseudoEMetricSpace : PseudoEMetricSpace α] →
(eq_of_edist_eq_zero : ∀ {x y : α}, edist x y = 0 → x = y) →
motive { toPseudoEMetricSpace := toPseudoEMetricSpace, eq_of_edist_eq_zero := eq_of_edist_eq_zero }) →
(t : EMetricSpace α) → ... | false |
Lean.Meta.ApplyConfig.mk.sizeOf_spec | Init.Meta.Defs | ∀ (newGoals : Lean.Meta.ApplyNewGoals) (synthAssignedInstances allowSynthFailures approx : Bool),
sizeOf
{ newGoals := newGoals, synthAssignedInstances := synthAssignedInstances,
allowSynthFailures := allowSynthFailures, approx := approx } =
1 + sizeOf newGoals + sizeOf synthAssignedInstances + size... | true |
FiniteArchimedeanClass.mk.congr_simp | Mathlib.RingTheory.HahnSeries.Lex | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (a a_1 : M)
(e_a : a = a_1) (h : a ≠ 0), FiniteArchimedeanClass.mk a h = FiniteArchimedeanClass.mk a_1 ⋯ | true |
Lean.Meta.Grind.Arith.isArithTerm | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Bool | true |
_private.Mathlib.Data.Nat.Factors.0.Nat.mem_primeFactorsList_mul._simp_1_1 | Mathlib.Data.Nat.Factors | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | false |
NumberField.IsTotallyComplex.casesOn | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | {K : Type u_1} →
[inst : Field K] →
{motive : NumberField.IsTotallyComplex K → Sort u} →
(t : NumberField.IsTotallyComplex K) →
((isComplex : ∀ (v : NumberField.InfinitePlace K), v.IsComplex) → motive ⋯) → motive t | false |
minpoly.mem_range_of_degree_eq_one | Mathlib.FieldTheory.Minpoly.Basic | ∀ (A : Type u_1) {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] (x : B),
(minpoly A x).degree = 1 → x ∈ (algebraMap A B).range | true |
CategoryTheory.Pseudofunctor.mapComp_assoc_left_hom_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) {Z : F.obj a ⟶ F.obj d}
(h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (F.map f) (F.map g)... | true |
Matroid.IsBase.ncard_eq_ncard_of_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {B₁ B₂ : Set α}, M.IsBase B₁ → M.IsBase B₂ → B₁.ncard = B₂.ncard | true |
Sym2.Mem.other' | Mathlib.Data.Sym.Sym2 | {α : Type u_1} → [DecidableEq α] → {a : α} → {z : Sym2 α} → a ∈ z → α | true |
CategoryTheory.Functor.IsLeftKanExtension.recOn | Mathlib.CategoryTheory.Functor.KanExtension.Basic | {C : Type u_1} →
{H : Type u_3} →
{D : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} D] →
{F' : CategoryTheory.Functor D H} →
{L : CategoryTheory.Functor C... | false |
CategoryTheory.Functor.category._proof_4 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {X Y : CategoryTheory.Functor C D} (f : CategoryTheory.NatTrans X Y),
f.vcomp (CategoryTheory.NatTrans.id Y) = f | false |
LinearEquiv.extendScalarsOfIsLocalization._proof_1 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_4} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_2) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_3} {N : Type u_1} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[i... | false |
TopologicalSpace.Clopens.mk.injEq | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_4} [inst : TopologicalSpace α] (carrier : Set α) (isClopen' : IsClopen carrier) (carrier_1 : Set α)
(isClopen'_1 : IsClopen carrier_1),
({ carrier := carrier, isClopen' := isClopen' } = { carrier := carrier_1, isClopen' := isClopen'_1 }) =
(carrier = carrier_1) | true |
Lean.Parser.Term.rightact._regBuiltin.Lean.Parser.Term.rightact_1 | Lean.Parser.Term | IO Unit | false |
Std.DTreeMap.Internal.Impl.SizedBalancedTree.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{lb ub : ℕ} →
(impl : Std.DTreeMap.Internal.Impl α β) →
impl.Balanced → lb ≤ impl.size → impl.size ≤ ub → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β lb ub | false |
MonObj.mopEquiv | Mathlib.CategoryTheory.Monoidal.Opposite.Mon_ | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → CategoryTheory.Mon C ≌ CategoryTheory.Mon Cᴹᵒᵖ | true |
_private.Mathlib.Algebra.Module.TransferInstance.0.Equiv.noZeroSMulDivisors._simp_1_1 | Mathlib.Algebra.Module.TransferInstance | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (y = e.symm x) = (e y = x) | false |
Class.instCompleteLattice._proof_24 | Mathlib.SetTheory.ZFC.Class | ∀ (s : Set Class.{u_1}), IsGLB s (sInf s) | false |
Array.replicate_append_replicate | Init.Data.Array.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α} {m : ℕ}, Array.replicate n a ++ Array.replicate m a = Array.replicate (n + m) a | true |
_private.Mathlib.Analysis.Fourier.FourierTransformDeriv.0.VectorFourier.norm_iteratedFDeriv_fourierPowSMulRight._proof_1_5 | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {k : ℕ} (i : ℕ), k - i ≤ k | false |
Polynomial.taylor_mul | Mathlib.Algebra.Polynomial.Taylor | ∀ {R : Type u_1} [inst : CommSemiring R] (r : R) (p q : Polynomial R),
(Polynomial.taylor r) (p * q) = (Polynomial.taylor r) p * (Polynomial.taylor r) q | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.