name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.letId.formatter_53 | Lean.Parser.Term | IO Unit | false |
Affine.Simplex.faceOppositeCentroid_vsub_faceOppositeCentroid | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} [inst_4 : NeZero n] [CharZero k] (s : Affine.Simplex k P n) (i j : Fin (n + 1)),
s.faceOppositeCentroid i -ᵥ s.faceOppositeCentroid j = (↑n)⁻¹ • (s.points j -ᵥ s.points i) | true |
Module.End.disjoint_iInf_maxGenEigenspace | Mathlib.LinearAlgebra.Eigenspace.Pi | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(f : ι → Module.End R M) [IsDomain R] [Module.IsTorsionFree R M] {χ₁ χ₂ : ι → R},
χ₁ ≠ χ₂ → Disjoint (⨅ i, (f i).maxGenEigenspace (χ₁ i)) (⨅ i, (f i).maxGenEigenspace (χ₂ i)) | true |
FirstOrder.Language.LHom.onBoundedFormula.eq_def | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u'} (g : L →ᴸ L') (x : ℕ) (x_1 : L.BoundedFormula α x),
g.onBoundedFormula x_1 =
match x, x_1 with
| _k, FirstOrder.Language.BoundedFormula.falsum => FirstOrder.Language.BoundedFormula.falsum
| _k, FirstOrder.Language.BoundedFormula.equal t₁ t₂ => (g.onTerm t₁).bdEqual (g.onTerm t₂)
| _k, FirstOrder.Language.BoundedFormula.rel R ts => (g.onRelation R).boundedFormula (g.onTerm ∘ ts)
| _k, f₁.imp f₂ => (g.onBoundedFormula f₁).imp (g.onBoundedFormula f₂)
| _k, f.all => (g.onBoundedFormula f).all | true |
Homeomorph.coe_punitProd | Mathlib.Topology.Constructions.SumProd | ∀ (X : Type u) [inst : TopologicalSpace X], ⇑(Homeomorph.punitProd X) = Prod.snd | true |
MvPowerSeries.map_algebraMap_eq_subst_X | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] {S : Type u_5} [inst_1 : CommRing S] [inst_2 : Algebra R S]
(f : MvPowerSeries σ R), (MvPowerSeries.map (algebraMap R S)) f = MvPowerSeries.subst MvPowerSeries.X f | true |
OrthonormalBasis.toBasis_adjustToOrientation | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {ι : Type u_2} [inst_2 : Fintype ι]
[inst_3 : DecidableEq ι] (e : OrthonormalBasis ι ℝ E) (x : Orientation ℝ E ι) [inst_4 : Nonempty ι],
(e.adjustToOrientation x).toBasis = e.toBasis.adjustToOrientation x | true |
Std.Sat.AIG.LawfulVecOperator.denote_cast_entry | Std.Sat.AIG.LawfulVecOperator | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Std.Sat.AIG α → ℕ → Type}
{f : {len : ℕ} → (aig : Std.Sat.AIG α) → β aig len → Std.Sat.AIG.RefVecEntry α len}
[Std.Sat.AIG.LawfulVecOperator α β fun {len} => f] {len : ℕ} {assign : α → Bool} (entry : Std.Sat.AIG.Entrypoint α)
{input : β entry.aig len} {h : entry.aig.decls.size ≤ (f entry.aig input).aig.decls.size},
⟦assign, { aig := (f entry.aig input).aig, ref := entry.ref.cast h }⟧ = ⟦assign, entry⟧ | true |
NormedAddGroupHom.sub | Mathlib.Analysis.Normed.Group.Hom | {V₁ : Type u_2} →
{V₂ : Type u_3} →
[inst : SeminormedAddCommGroup V₁] → [inst_1 : SeminormedAddCommGroup V₂] → Sub (NormedAddGroupHom V₁ V₂) | true |
_private.Mathlib.Analysis.Complex.Poisson.0.DiffContOnCl.circleAverage_re_smul_on_ball_zero._simp_1_12 | Mathlib.Analysis.Complex.Poisson | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
DihedralGroup.oddCommuteEquiv_apply | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (hn : Odd n) (x : { p // Commute p.1 p.2 }),
(DihedralGroup.oddCommuteEquiv hn) x =
match x with
| ⟨(DihedralGroup.sr i, DihedralGroup.r a), property⟩ => Sum.inl i
| ⟨(DihedralGroup.r a, DihedralGroup.sr j), property⟩ => Sum.inr (Sum.inl j)
| ⟨(DihedralGroup.sr i, DihedralGroup.sr j), property⟩ => Sum.inr (Sum.inr (Sum.inl (i + j)))
| ⟨(DihedralGroup.r i, DihedralGroup.r j), property⟩ => Sum.inr (Sum.inr (Sum.inr (i, j))) | true |
HomologicalComplex.truncLEXIsoCycles | Mathlib.Algebra.Homology.Embedding.TruncLE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embedding c') →
[inst_2 : e.IsTruncLE] →
[inst_3 : ∀ (i' : ι'), K.HasHomology i'] →
[inst_4 : CategoryTheory.Limits.HasZeroObject C] →
{i : ι} → {i' : ι'} → e.f i = i' → e.BoundaryLE i → ((K.truncLE e).X i' ≅ K.cycles i') | true |
Lean.Server.FileWorker.RefreshInfo.successiveRefreshAttempts | Lean.Server.FileWorker | Lean.Server.FileWorker.RefreshInfo → ℕ | true |
BooleanSubalgebra.val_top | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L : BooleanSubalgebra α}, ↑⊤ = ⊤ | true |
SimpleGraph.connected_iff_diam_ne_zero | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1} {G : SimpleGraph α} [Finite α] [Nontrivial α], G.Connected ↔ G.diam ≠ 0 | true |
CliffordAlgebra.evenOdd_mul_le | Mathlib.LinearAlgebra.CliffordAlgebra.Grading | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (i j : ZMod 2),
CliffordAlgebra.evenOdd Q i * CliffordAlgebra.evenOdd Q j ≤ CliffordAlgebra.evenOdd Q (i + j) | true |
_private.Mathlib.Data.Set.Insert.0.Set.forall_of_forall_insert._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {P : α → Prop} {a : α} {s : Set α}, (∀ x ∈ insert a s, P x) → ∀ x ∈ s, P x | false |
CategoryTheory.IsPullback.inr_fst' | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.BicartesianSq | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {b : CategoryTheory.Limits.BinaryBicone X Y}
(h : b.IsBilimit), CategoryTheory.IsPullback b.inr 0 b.fst 0 | true |
synthesizeUsing | Mathlib.Util.SynthesizeUsing | {u : Lean.Level} → (type : Q(Sort u)) → Lean.Elab.Tactic.TacticM Unit → Lean.MetaM (List Lean.MVarId × Q(«$type»)) | true |
Submonoid.IsMulPointed.eq_one_of_mem_of_inv_mem | Mathlib.Algebra.Group.Submonoid.Support | ∀ {G : Type u_1} [inst : Group G] {M : Submonoid G}, M.IsMulPointed → ∀ {x : G}, x ∈ M → x⁻¹ ∈ M → x = 1 | true |
Lean.Meta.Grind.TheoremGuard.check | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.TheoremGuard → Bool | true |
Int32.toInt16_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int32), (a ^^^ b).toInt16 = a.toInt16 ^^^ b.toInt16 | true |
PartialEquiv.trans_transEquiv | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (e : PartialEquiv α β) (e' : PartialEquiv β γ)
(f'' : γ ≃ δ), (e.trans e').transEquiv f'' = e.trans (e'.transEquiv f'') | true |
PiTensorProduct.dualDistribEquiv.eq_1 | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_1} {R : Type u_2} {M : ι → Type u_4} [inst : CommRing R] [inst_1 : (i : ι) → AddCommGroup (M i)]
[inst_2 : (i : ι) → Module R (M i)] [inst_3 : ∀ (i : ι), Module.Finite R (M i)]
[inst_4 : ∀ (i : ι), Module.Free R (M i)] [inst_5 : Finite ι],
PiTensorProduct.dualDistribEquiv = PiTensorProduct.dualDistribEquivOfBasis fun i => Module.Free.chooseBasis R (M i) | true |
Equiv.permCongrHom_coe | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} (e : α ≃ β), ⇑e.permCongrHom = ⇑e.permCongr | true |
Nat.primeFactorsList_one | Mathlib.Data.Nat.Factors | Nat.primeFactorsList 1 = [] | true |
ContinuousMultilinearMap.prodEquiv._proof_1 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u_5} {ι : Type u_1} {M₁ : ι → Type u_2} {M₂ : Type u_3} {M₃ : Type u_4} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃]
[inst_4 : (i : ι) → Module R (M₁ i)] [inst_5 : Module R M₂] [inst_6 : Module R M₃]
[inst_7 : (i : ι) → TopologicalSpace (M₁ i)] [inst_8 : TopologicalSpace M₂] [inst_9 : TopologicalSpace M₃],
Function.LeftInverse
(fun f =>
((ContinuousLinearMap.fst R M₂ M₃).compContinuousMultilinearMap f,
(ContinuousLinearMap.snd R M₂ M₃).compContinuousMultilinearMap f))
fun f => f.1.prod f.2 | false |
CategoryTheory.Abelian.FreydMitchell.instRingEmbeddingRing._proof_26 | Mathlib.CategoryTheory.Abelian.FreydMitchell | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | false |
ConvexCone.instAdd | Mathlib.Geometry.Convex.Cone.Basic | {R : Type u_2} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : PartialOrder R] → [inst_2 : AddCommMonoid M] → [inst_3 : Module R M] → Add (ConvexCone R M) | true |
Lean.Meta.Sym.AlphaShareCommon.State._sizeOf_1 | Lean.Meta.Sym.AlphaShareCommon | Lean.Meta.Sym.AlphaShareCommon.State → ℕ | false |
NumberField.InfinitePlace.nat_card_stabilizer_eq_one_or_two | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ (k : Type u_1) [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
(w : NumberField.InfinitePlace K),
Nat.card ↥(MulAction.stabilizer Gal(K/k) w) = 1 ∨ Nat.card ↥(MulAction.stabilizer Gal(K/k) w) = 2 | true |
IsCompact.finite_cover_balls | Mathlib.Topology.MetricSpace.Pseudo.Basic | ∀ {X : Type u_2} [inst : PseudoMetricSpace X] {s : Set X},
IsCompact s → ∀ {e : ℝ}, 0 < e → ∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ x ∈ t, Metric.ball x e | true |
Lean.Widget.instRpcEncodableWidgetInstance.enc._@.Lean.Widget.Types.2243429567._hygCtx._hyg.1 | Lean.Widget.Types | Lean.Widget.WidgetInstance → StateM Lean.Server.RpcObjectStore Lean.Json | false |
Differentiable.inversion | Mathlib.Geometry.Euclidean.Inversion.Calculus | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : InnerProductSpace ℝ F] {c x : E → F} {R : E → ℝ},
Differentiable ℝ c →
Differentiable ℝ R →
Differentiable ℝ x →
(∀ (a : E), x a ≠ c a) → Differentiable ℝ fun a => EuclideanGeometry.inversion (c a) (R a) (x a) | true |
PeriodPair.«term℘'[_-_]» | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | Lean.ParserDescr | true |
CategoryTheory.MonoidalClosed.internalHomAdjunction₂._proof_2 | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.MonoidalClosed C] {X₁ Y₁ : C} (f : X₁ ⟶ Y₁),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ihom.adjunction X₁).unit
(CategoryTheory.Functor.whiskerRight ((CategoryTheory.MonoidalCategory.curriedTensor C).map f)
(CategoryTheory.MonoidalClosed.internalHom.obj (Opposite.op X₁))) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.ihom.adjunction Y₁).unit
(((CategoryTheory.MonoidalCategory.curriedTensor C).obj Y₁).whiskerLeft
(CategoryTheory.MonoidalClosed.internalHom.map f.op)) | false |
LinearMap.IsSymm.tmul | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ {R : Type uR} {A : Type uA} {M₁ : Type uM₁} {M₂ : Type uM₂} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : Algebra R A] [inst_5 : Module R M₁]
[inst_6 : Module A M₁] [inst_7 : SMulCommClass R A M₁] [inst_8 : IsScalarTower R A M₁] [inst_9 : Module R M₂]
{B₁ : LinearMap.BilinForm A M₁} {B₂ : LinearMap.BilinForm R M₂},
LinearMap.IsSymm B₁ → LinearMap.IsSymm B₂ → LinearMap.IsSymm (B₁.tmul B₂) | true |
SNum.le | Mathlib.Data.Num.Lemmas | LE SNum | true |
disjoint_compl_left_iff | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], Disjoint xᶜ y ↔ y ≤ x | true |
AlgebraicGeometry.HasAffineProperty.affineAnd_le_affineAnd | Mathlib.AlgebraicGeometry.Morphisms.AffineAnd | ∀ {Q Q' : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
{P P' : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme},
AlgebraicGeometry.HasAffineProperty P (AlgebraicGeometry.affineAnd fun {R S} [CommRing R] [CommRing S] => Q) →
AlgebraicGeometry.HasAffineProperty P' (AlgebraicGeometry.affineAnd fun {R S} [CommRing R] [CommRing S] => Q') →
(∀ {R S : Type u} [inst : CommRing R] [inst_1 : CommRing S] {f : R →+* S}, Q f → Q' f) → P ≤ P' | true |
Std.TreeMap.Raw.Equiv.mergeWith | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ t₃ t₄ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp],
t₁.WF →
t₂.WF →
t₃.WF →
t₄.WF →
∀ (f : α → β → β → β),
t₁.Equiv t₂ → t₃.Equiv t₄ → (Std.TreeMap.Raw.mergeWith f t₁ t₃).Equiv (Std.TreeMap.Raw.mergeWith f t₂ t₄) | true |
Lean.Meta.Grind.ExprWithAnchor.anchor | Lean.Meta.Tactic.Grind.Anchor | Lean.Meta.Grind.ExprWithAnchor → UInt64 | true |
CategoryTheory.Preadditive.homSelfLinearEquivEndMulOpposite | Mathlib.CategoryTheory.Preadditive.Opposite | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] → (G : C) → (G ⟶ G) ≃ₗ[(CategoryTheory.End G)ᵐᵒᵖ] (CategoryTheory.End G)ᵐᵒᵖ | true |
Lean.Meta.UnificationHintEntry.mk.noConfusion | Lean.Meta.UnificationHint | {P : Sort u} →
{keys : Array Lean.Meta.UnificationHintKey} →
{val : Lean.Name} →
{keys' : Array Lean.Meta.UnificationHintKey} →
{val' : Lean.Name} →
{ keys := keys, val := val } = { keys := keys', val := val' } → (keys = keys' → val = val' → P) → P | false |
BoundedContinuousFunction.dist_toContinuousMap | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : PseudoMetricSpace β]
(f g : BoundedContinuousFunction α β), dist f.toContinuousMap g.toContinuousMap = dist f g | true |
Besicovitch.TauPackage.mk | Mathlib.MeasureTheory.Covering.Besicovitch | {β : Type u_1} → {α : Type u_2} → Besicovitch.BallPackage β α → (τ : ℝ) → 1 < τ → Besicovitch.TauPackage β α | true |
HomologicalComplex.shortComplexTruncLE | Mathlib.Algebra.Homology.Embedding.TruncLEHomology | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Abelian C] →
HomologicalComplex C c' →
(e : c.Embedding c') → [e.IsTruncLE] → CategoryTheory.ShortComplex (HomologicalComplex C c') | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.smul_stabilizer_of_no_doubling_aux | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {A : Finset G} {a : G},
(A * A).card ≤ A.card →
a ∈ A → a • ↑(MulAction.stabilizer G A) = ↑A ∧ MulOpposite.op a • ↑(MulAction.stabilizer G A) = ↑A | true |
CategoryTheory.ComposableArrows.exact_iff_δlast | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} (S : CategoryTheory.ComposableArrows C (n + 2)),
S.Exact ↔
S.δlast.Exact ∧ (CategoryTheory.ComposableArrows.mk₂ (S.map' n (n + 1) ⋯ ⋯) (S.map' (n + 1) (n + 2) ⋯ ⋯)).Exact | true |
Lean.Parser.hygieneInfo._regBuiltin.Lean.Parser.hygieneInfo.docString_1 | Lean.Parser.Extra | IO Unit | false |
IsStrongAntichain.isAntichain | Mathlib.Order.Antichain | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} [Std.Refl r], IsStrongAntichain r s → IsAntichain r s | true |
AddCommMagma.mk._flat_ctor | Mathlib.Algebra.Group.Defs | {G : Type u} → (add : G → G → G) → (∀ (a b : G), a + b = b + a) → AddCommMagma G | false |
AdicCompletion.subalgebra._proof_2 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (x y : (n : ℕ) → R ⧸ I ^ n • ⊤),
x ∈ AdicCompletion.submodule I R →
y ∈ AdicCompletion.submodule I R →
∀ (m n : ℕ) (hmn : m ≤ n), (AdicCompletion.transitionMap I R hmn) ((x * y) n) = (x * y) m | false |
TopHom.casesOn | Mathlib.Order.Hom.Bounded | {α : Type u_6} →
{β : Type u_7} →
[inst : Top α] →
[inst_1 : Top β] →
{motive : TopHom α β → Sort u} →
(t : TopHom α β) →
((toFun : α → β) → (map_top' : toFun ⊤ = ⊤) → motive { toFun := toFun, map_top' := map_top' }) → motive t | false |
ProofWidgets.ExprPresenter.recOn | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.ExprPresenter → Sort u} →
(t : ProofWidgets.ExprPresenter) →
((userName : String) →
(layoutKind : ProofWidgets.LayoutKind) →
(present : Lean.Expr → Lean.MetaM ProofWidgets.Html) →
motive { userName := userName, layoutKind := layoutKind, present := present }) →
motive t | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.mkInductiveDeclCore | Lean.Elab.MutualInductive | {α : Type} →
(Lean.Elab.Command.AddAndFinalizeContext✝ → Lean.Elab.TermElabM α) →
Array Lean.Expr →
Array Lean.Elab.Command.InductiveElabStep1 →
Array Lean.Elab.Command.PreElabHeaderResult → List Lean.Name → Lean.Elab.TermElabM α | true |
Topology.WithUpper.toUpper | Mathlib.Topology.Order.LowerUpperTopology | {α : Type u_1} → α ≃ Topology.WithUpper α | true |
CategoryTheory.Aut.isoPerm | Mathlib.Algebra.Category.Grp.Basic | {α : Type u} → GrpCat.of (CategoryTheory.Aut α) ≅ GrpCat.of (Equiv.Perm α) | true |
tendsto_euler_sin_prod' | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {x : ℂ},
x ≠ 0 →
Filter.Tendsto (fun n => ∏ i ∈ Finset.range n, (1 + sineTerm x i)) Filter.atTop
(nhds (Complex.sin (↑Real.pi * x) / (↑Real.pi * x))) | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabAppImplicitCore.tryAppUnexpanders.go._sunfold | Lean.PrettyPrinter.Delaborator.Builtins | Lean.Term →
Array Lean.PrettyPrinter.Delaborator.AppImplicitArg →
List Lean.PrettyPrinter.Unexpander → ℕ → ℕ → Array Lean.Syntax → Lean.PrettyPrinter.Delaborator.DelabM Lean.Term | false |
CategoryTheory.StrictlyUnitaryPseudofunctor.mk.inj | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{toPseudofunctor : CategoryTheory.Pseudofunctor B C}
{map_id :
autoParam
(∀ (X : B),
toPseudofunctor.map (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (toPseudofunctor.obj X))
CategoryTheory.StrictlyUnitaryPseudofunctor.map_id._autoParam}
{mapId_eq_eqToIso :
autoParam (∀ (X : B), toPseudofunctor.mapId X = CategoryTheory.eqToIso ⋯)
CategoryTheory.StrictlyUnitaryPseudofunctor.mapId_eq_eqToIso._autoParam}
{toPseudofunctor_1 : CategoryTheory.Pseudofunctor B C}
{map_id_1 :
autoParam
(∀ (X : B),
toPseudofunctor_1.map (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (toPseudofunctor_1.obj X))
CategoryTheory.StrictlyUnitaryPseudofunctor.map_id._autoParam}
{mapId_eq_eqToIso_1 :
autoParam (∀ (X : B), toPseudofunctor_1.mapId X = CategoryTheory.eqToIso ⋯)
CategoryTheory.StrictlyUnitaryPseudofunctor.mapId_eq_eqToIso._autoParam},
{ toPseudofunctor := toPseudofunctor, map_id := map_id, mapId_eq_eqToIso := mapId_eq_eqToIso } =
{ toPseudofunctor := toPseudofunctor_1, map_id := map_id_1, mapId_eq_eqToIso := mapId_eq_eqToIso_1 } →
toPseudofunctor = toPseudofunctor_1 | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizePattern.go.match_4 | Lean.Meta.Tactic.Grind.Internalize | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((e : Lean.Expr) → motive (some e)) → ((x : Option Lean.Expr) → motive x) → motive x | false |
Aesop.EqualUpToIdsM.State.leftUnassignedMVarValues | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIdsM.State → Std.HashMap Lean.MVarId Lean.Expr | true |
CategoryTheory.Functor.RepresentableBy.ofIsoObj | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} → {X Y : C} → F.RepresentableBy X → (Y ≅ X) → F.RepresentableBy Y | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0._regBuiltin.Int64.reduceOfInt.declare_349._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.4041591762._hygCtx._hyg.374 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
Lean.Meta.Grind.Split.State.argsAt | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Split.State → Lean.PHashMap (Lean.Expr × ℕ) (List Lean.Meta.Grind.SplitArg) | true |
Turing.TM1.Stmt.halt.sizeOf_spec | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} [inst : SizeOf Γ] [inst_1 : SizeOf Λ] [inst_2 : SizeOf σ],
sizeOf Turing.TM1.Stmt.halt = 1 | true |
UInt8.le_iff_toNat_le_toNat | Batteries.Data.UInt | ∀ {x y : UInt8}, x ≤ y ↔ x.toNat ≤ y.toNat | true |
Lean.KVMap.setSyntax | Lean.Data.KVMap | Lean.KVMap → Lean.Name → Lean.Syntax → Lean.KVMap | true |
RootPairing.Base.cartanMatrix | Mathlib.LinearAlgebra.RootSystem.CartanMatrix | {ι : 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} → (b : P.Base) → [P.IsCrystallographic] → Matrix ↥b.support ↥b.support ℤ | true |
Lean.Widget.WidgetSource._sizeOf_1 | Lean.Widget.UserWidget | Lean.Widget.WidgetSource → ℕ | false |
_private.Init.Data.Nat.Bitwise.Basic.0.Nat.bitwise.eq_def | Init.Data.Nat.Bitwise.Basic | ∀ (f : Bool → Bool → Bool) (n m : ℕ),
Nat.bitwise f n m =
if n = 0 then if f false true = true then m else 0
else
if m = 0 then if f true false = true then n else 0
else
have n' := n / 2;
have m' := m / 2;
let b₁ := n % 2 = 1;
let b₂ := m % 2 = 1;
have r := Nat.bitwise f n' m';
if f (decide b₁) (decide b₂) = true then r + r + 1 else r + r | true |
TensorProduct.«termSym[_]__» | Mathlib.LinearAlgebra.TensorPower.Symmetric | Lean.ParserDescr | true |
Group.conjugatesOfSet_mono | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {s t : Set G}, s ⊆ t → Group.conjugatesOfSet s ⊆ Group.conjugatesOfSet t | true |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Polynomial.support_restriction._simp_1_2 | Mathlib.RingTheory.Polynomial.Basic | ∀ {a b : Prop}, (¬a ↔ ¬b) = (a ↔ b) | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_slope_of_ne._simp_1_4 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | false |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isDefEqEtaStruct.go | Lean.Meta.ExprDefEq | Lean.Expr → Lean.Expr → Lean.ConstructorVal → List Lean.Level → Lean.MetaM Bool | true |
CategoryTheory.Functor.flip_map_app | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) {d d' : D} (f : d ⟶ d') (c : C),
(F.flip.map f).app c = (F.obj c).map f | true |
_private.Lean.Environment.0.Lean.AsyncContext.noConfusion | Lean.Environment | {P : Sort u} → {t t' : Lean.AsyncContext✝} → t = t' → Lean.AsyncContext.noConfusionType✝ P t t' | false |
CategoryTheory.GrothendieckTopology.OneHypercover.mk'_toPreOneHypercover | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C}
(E : CategoryTheory.PreOneHypercover S) [inst_1 : E.HasPullbacks] (mem₀ : E.sieve₀ ∈ J S)
(mem₁' : ∀ (i₁ i₂ : E.I₀), E.sieve₁' i₁ i₂ ∈ J (CategoryTheory.Limits.pullback (E.f i₁) (E.f i₂))),
(CategoryTheory.GrothendieckTopology.OneHypercover.mk' E mem₀ mem₁').toPreOneHypercover = E | true |
SimpleGraph.Subgraph.instCompletelyDistribLattice._proof_5 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (a b c : G.Subgraph), a \ b ≤ c ↔ a ≤ b ⊔ c | false |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM.computeCoefficients.go._unsafe_rec | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap →
Lean.Expr →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap | false |
CategoryTheory.ObjectProperty.Is.mk | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {P : CategoryTheory.ObjectProperty C} {X : C},
P X → P.Is X | true |
Mathlib.Explode.Entries.noConfusion | Mathlib.Tactic.Explode.Datatypes | {P : Sort u} → {t t' : Mathlib.Explode.Entries} → t = t' → Mathlib.Explode.Entries.noConfusionType P t t' | false |
CochainComplex.ConnectData.mk.noConfusion | Mathlib.Algebra.Homology.Embedding.Connect | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{K : ChainComplex C ℕ} →
{L : CochainComplex C ℕ} →
{P : Sort u_1} →
{d₀ : K.X 0 ⟶ L.X 0} →
{comp_d₀ : CategoryTheory.CategoryStruct.comp (K.d 1 0) d₀ = 0} →
{d₀_comp : CategoryTheory.CategoryStruct.comp d₀ (L.d 0 1) = 0} →
{d₀' : K.X 0 ⟶ L.X 0} →
{comp_d₀' : CategoryTheory.CategoryStruct.comp (K.d 1 0) d₀' = 0} →
{d₀_comp' : CategoryTheory.CategoryStruct.comp d₀' (L.d 0 1) = 0} →
{ d₀ := d₀, comp_d₀ := comp_d₀, d₀_comp := d₀_comp } =
{ d₀ := d₀', comp_d₀ := comp_d₀', d₀_comp := d₀_comp' } →
(d₀ ≍ d₀' → P) → P | false |
HahnSeries.orderTopSubOnePos | Mathlib.RingTheory.HahnSeries.Multiplication | (Γ : Type u_6) →
(R : Type u_7) →
[inst : LinearOrder Γ] →
[inst_1 : AddCommMonoid Γ] →
[inst_2 : IsOrderedCancelAddMonoid Γ] → [inst_3 : CommRing R] → Subgroup (HahnSeries Γ R)ˣ | true |
Lean.MessageData.isTrace._sunfold | Lean.Message | Lean.MessageData → Bool | false |
isOpen_iInter₂ | Mathlib.Topology.AlexandrovDiscrete | ∀ {ι : Sort u_1} {κ : ι → Sort u_2} {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α]
{f : (i : ι) → κ i → Set α}, (∀ (i : ι) (j : κ i), IsOpen (f i j)) → IsOpen (⋂ i, ⋂ j, f i j) | true |
CoalgEquiv.rec | Mathlib.RingTheory.Coalgebra.Equiv | {R : Type u_5} →
[inst : CommSemiring R] →
{A : Type u_6} →
{B : Type u_7} →
[inst_1 : AddCommMonoid A] →
[inst_2 : AddCommMonoid B] →
[inst_3 : Module R A] →
[inst_4 : Module R B] →
[inst_5 : CoalgebraStruct R A] →
[inst_6 : CoalgebraStruct R B] →
{motive : (A ≃ₗc[R] B) → Sort u} →
((toCoalgHom : A →ₗc[R] B) →
(invFun : B → A) →
(left_inv : Function.LeftInverse invFun toCoalgHom.toFun) →
(right_inv : Function.RightInverse invFun toCoalgHom.toFun) →
motive
{ toCoalgHom := toCoalgHom, invFun := invFun, left_inv := left_inv,
right_inv := right_inv }) →
(t : A ≃ₗc[R] B) → motive t | false |
SkewMonoidAlgebra.update_eq_erase_add_single | Mathlib.Algebra.SkewMonoidAlgebra.Single | ∀ {M : Type u_4} {α : Type u_5} [inst : AddCommMonoid M] (f : SkewMonoidAlgebra M α) (a : α) (b : M),
f.update a b = (SkewMonoidAlgebra.erase a) f + SkewMonoidAlgebra.single a b | true |
AddMonoidHom.instDistribSMul._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Hom | ∀ {M : Type u_3} {A : Type u_1} {B : Type u_2} [inst : AddZeroClass A] [inst_1 : AddCommMonoid B]
[inst_2 : DistribSMul M B] (x : M) (x_1 x_2 : A →+ B), x • (x_1 + x_2) = x • x_1 + x • x_2 | false |
CategoryTheory.createsLimitOfFullyFaithfulOfIso | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
[F.Full] →
[F.Faithful] →
[inst_5 : CategoryTheory.Limits.HasLimit (K.comp F)] →
(X : C) → (F.obj X ≅ CategoryTheory.Limits.limit (K.comp F)) → CategoryTheory.CreatesLimit K F | true |
Polynomial.reflect_C_mul | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (f : Polynomial R) (r : R) (N : ℕ),
Polynomial.reflect N (Polynomial.C r * f) = Polynomial.C r * Polynomial.reflect N f | true |
cfcₙHomSuperset._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : MetricSpace R] [inst_2 : NonUnitalRing A]
[inst_3 : Module R A] {a : A} {s : Set R} (hs : quasispectrum R a ⊆ s), Continuous (Subtype.map id hs) | false |
LinearEquiv.symm_symm | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂),
e.symm.symm = e | true |
_private.Mathlib.Combinatorics.SetFamily.Compression.Down.0.Finset.image_insert_memberSubfamily.match_1_3 | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} (𝒜 : Finset (Finset α)) (a : α) (s : Finset α) (motive : s ∈ 𝒜 ∧ a ∈ s → Prop) (x : s ∈ 𝒜 ∧ a ∈ s),
(∀ (hs : s ∈ 𝒜) (ha : a ∈ s), motive ⋯) → motive x | false |
LinearOrderedField.inducedMap_self | Mathlib.Algebra.Order.CompleteField | ∀ {β : Type u_3} [inst : Field β] [inst_1 : ConditionallyCompleteLinearOrder β] [IsStrictOrderedRing β] (b : β),
ConditionallyCompleteLinearOrderedField.inducedMap β β b = b | true |
Sum3.in₀ | Mathlib.Data.Sum.Basic | {α : Type u} → {β : Type v} → {γ : Type u_1} → α → α ⊕ β ⊕ γ | true |
GrpCat.forget_isCorepresentable | Mathlib.Algebra.Category.Grp.ForgetCorepresentable | (CategoryTheory.forget GrpCat).IsCorepresentable | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.reduceProp._sparseCasesOn_7 | Mathlib.Tactic.FieldSimp | {motive : Mathlib.Ineq → Sort u} →
(t : Mathlib.Ineq) →
motive Mathlib.Ineq.eq → motive Mathlib.Ineq.le → (Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.