name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
OpenSubgroup.instPartialOrder | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} → [inst : Group G] → [inst_1 : TopologicalSpace G] → PartialOrder (OpenSubgroup G) | true |
_private.Aesop.Forward.Substitution.0.Aesop.Substitution.openRuleType.match_1 | Aesop.Forward.Substitution | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((mvars : Array Lean.Expr) → (binfos : Array Lean.BinderInfo) → (body : Lean.Expr) → motive (mvars, binfos, body)) →
motive __discr | false |
MulAction.orbitProdStabilizerEquivGroup | Mathlib.GroupTheory.GroupAction.Quotient | (α : Type u) →
{β : Type v} →
[inst : Group α] → [inst_1 : MulAction α β] → (b : β) → ↑(MulAction.orbit α b) × ↥(MulAction.stabilizer α b) ≃ α | true |
Bundle.Pretrivialization.noConfusionType | Mathlib.Topology.FiberBundle.Trivialization | Sort u →
{B : Type u_1} →
{F : Type u_2} →
{Z : Type u_4} →
[inst : TopologicalSpace B] →
[inst_1 : TopologicalSpace F] →
{proj : Z → B} →
Bundle.Pretrivialization F proj →
{B' : Type u_1} →
{F' : Type u_2} →
{... | false |
BoundedLatticeHom.asBoolRing._proof_2 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_2} {β : Type u_1} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] (f : BoundedLatticeHom α β)
(a b : α), f.toFun (a ⊓ b) = f.toFun a ⊓ f.toFun b | false |
DirectSum.Decomposition.baseChange._proof_7 | Mathlib.LinearAlgebra.TensorProduct.Decomposition | ∀ {ι : Type u_4} {R : Type u_3} {M : Type u_1} {S : Type u_2} [inst : DecidableEq ι] [inst_1 : CommSemiring R]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (ℳ : ι → Submodule R M) [inst_4 : CommSemiring S]
[inst_5 : Algebra R S] [inst_6 : DirectSum.Decomposition ℳ],
(DirectSum.coeLinearMap fun i => Submodule.... | false |
MeasureTheory.ae_le_const_iff_forall_gt_measure_zero | Mathlib.MeasureTheory.Function.AEEqOfLIntegral | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {β : Type u_2} [inst : LinearOrder β] [inst_1 : TopologicalSpace β]
[OrderTopology β] [FirstCountableTopology β] {μ : MeasureTheory.Measure α} (f : α → β) (c : β),
(∀ᵐ (x : α) ∂μ, f x ≤ c) ↔ ∀ (b : β), c < b → μ {x | b ≤ f x} = 0 | true |
AddSubmonoid.instUniqueOfSubsingleton._proof_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : AddZeroClass M] [Subsingleton M] (a : AddSubmonoid M), a = default | false |
LieAlgebra.SemiDirectSum.instModule | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → (ψ : L →ₗ⁅R⁆ LieDerivation R K K) → Module R (K ⋊⁅ψ⁆ L) | true |
_private.Mathlib.Analysis.Calculus.IteratedDeriv.Defs.0.ContDiffOn.continuousOn_iteratedDerivWithin._simp_1_1 | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | false |
Lean.Meta.Grind.filterENodes | Lean.Meta.Tactic.Grind.Types | (Lean.Meta.Grind.ENode → Lean.Meta.Grind.GoalM Bool) → Lean.Meta.Grind.GoalM (Array Lean.Meta.Grind.ENode) | true |
LinearMap.isSymm_dualProd | Mathlib.LinearAlgebra.QuadraticForm.Dual | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
LinearMap.IsSymm (LinearMap.dualProd R M) | true |
dist_left_midpoint_eq_dist_right_midpoint | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {V : Type u_1} {P : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] {𝕜 : Type u_5} [inst_3 : NormedField 𝕜] [inst_4 : NormedSpace 𝕜 V]
[inst_5 : Invertible 2] (p₁ p₂ : P), dist p₁ (midpoint 𝕜 p₁ p₂) = dist p₂ (midpoint 𝕜 p₁ p₂) | true |
_private.Mathlib.Topology.Algebra.Group.Basic.0.IsTopologicalGroup.exists_antitone_basis_nhds_one._simp_1_2 | Mathlib.Topology.Algebra.Group.Basic | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | false |
CategoryTheory.Under.instHasLimitsOfShape | Mathlib.CategoryTheory.Limits.Over | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{X : C} [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Under X) | true |
Lean.Meta.EtaStructMode.toCtorIdx | Init.MetaTypes | Lean.Meta.EtaStructMode → ℕ | false |
CommAlgCat.isInitialSelf | Mathlib.Algebra.Category.CommAlgCat.Monoidal | {R : Type u} → [inst : CommRing R] → CategoryTheory.Limits.IsInitial (CommAlgCat.of R R) | true |
Aesop.GlobalRuleSet.rec | Aesop.RuleSet | {motive : Aesop.GlobalRuleSet → Sort u} →
((toBaseRuleSet : Aesop.BaseRuleSet) →
(simpTheorems : Lean.Meta.SimpTheorems) →
(simprocs : Lean.Meta.Simprocs) →
motive { toBaseRuleSet := toBaseRuleSet, simpTheorems := simpTheorems, simprocs := simprocs }) →
(t : Aesop.GlobalRuleSet) → motive t | false |
CategoryTheory.Over.rightUnitor_inv_left_fst_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C}
(Y : CategoryTheory.Over X) {Z : C} (h : Y.left ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).inv.left
(CategoryTheory.CategoryStruct.comp
... | true |
_private.Mathlib.CategoryTheory.Shift.Adjunction.0.CategoryTheory.Adjunction.CommShift.compatibilityCounit_of_compatibilityUnit._simp_1_1 | Mathlib.CategoryTheory.Shift.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
String.Slice.Pos.le_iff_remainingBytes_le | Init.Data.String.Termination | ∀ {s : String.Slice} (p q : s.Pos), p ≤ q ↔ q.remainingBytes ≤ p.remainingBytes | true |
DilationEquiv.trans_refl | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] (e : X ≃ᵈ Y),
e.trans (DilationEquiv.refl Y) = e | true |
Minimal.not_prop_of_lt | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P : α → Prop} {x y : α} [inst : Preorder α], Minimal P x → y < x → ¬P y | true |
CategoryTheory.ShortComplex.HomologyMapData.comp_right | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {φ' : S₂ ⟶ S₃} {h₁ : S₁.HomologyData} {h₂ : S₂.HomologyData}
{h₃ : S₃.HomologyData} (ψ : CategoryTheory.ShortComplex.HomologyMapData φ h₁ h₂)
(ψ' : ... | true |
IsHausdorff.of_map | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] {I : Ideal R} {M : Type u_4} [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : CommRing S] [inst_4 : Module S M] {J : Ideal S} [inst_5 : Algebra R S]
[IsScalarTower R S M], Ideal.map (algebraMap R S) I ≤ J → ∀ [IsHausdorff J M], IsHausdorff I M | true |
Matrix.UnitaryGroup.mul_apply | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
(A B : ↥(Matrix.unitaryGroup n α)), ↑(A * B) = ↑A * ↑B | true |
Function.Surjective.commMonoid.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Mul M₂] [inst_1 : One M₂] [inst_2 : Pow M₂ ℕ] [inst_3 : CommMonoid M₁]
(f : M₁ → M₂) (hf : Function.Surjective f) (one : f 1 = 1) (mul : ∀ (x y : M₁), f (x * y) = f x * f y)
(npow : ∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n),
Function.Surjective.commMonoid f hf one mul npow... | true |
CategoryTheory.Limits.Cofork.isColimitOfπEquivIsLimitOp | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y P : C} →
{f g : X ⟶ Y} →
(π π' : Y ⟶ P) →
(w : CategoryTheory.CategoryStruct.comp f π = CategoryTheory.CategoryStruct.comp g π) →
(w' : CategoryTheory.CategoryStruct.comp π'.op f.op = CategoryTheory.CategoryStru... | true |
CategoryTheory.ShortComplex.SnakeInput.functorP_map | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{X Y : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y),
CategoryTheory.ShortComplex.SnakeInput.functorP.map f =
CategoryTheory.Limits.pullback.map X.L₁.g X.v₀₁.τ₃ Y.L₁.g Y.v₀₁.τ₃ f.f₁.τ₂ f.f₀.τ₃ f.f₁.τ₃ ⋯ ⋯ | true |
sign_pow | Mathlib.Data.Sign.Basic | ∀ {α : Type u} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (x : α) (n : ℕ),
SignType.sign (x ^ n) = SignType.sign x ^ n | true |
Std.Time.Month.Ordinal.days | Std.Time.Date.Unit.Month | Bool → Std.Time.Month.Ordinal → Std.Time.Day.Ordinal | true |
Subadditive.lim.eq_1 | Mathlib.Analysis.Subadditive | ∀ {u : ℕ → ℝ} (_h : Subadditive u), _h.lim = sInf ((fun n => u n / ↑n) '' Set.Ici 1) | true |
Subfield.subset_closure | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} [inst : DivisionRing K] {s : Set K}, s ⊆ ↑(Subfield.closure s) | true |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeAssignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Bool → Std.Tactic.BVDecide.LRAT.Internal.Assignment → Std.Tactic.BVDecide.LRAT.Internal.Assignment | true |
PartOrd.str | Mathlib.Order.Category.PartOrd | (self : PartOrd) → PartialOrder ↑self | true |
ByteArray.get.match_1 | Init.Data.ByteArray.Basic | (motive : (x : ByteArray) → (x_1 : ℕ) → x_1 < x.size → Sort u_1) →
(x : ByteArray) →
(x_1 : ℕ) →
(x_2 : x_1 < x.size) →
((bs : Array UInt8) → (i : ℕ) → (x : i < { data := bs }.size) → motive { data := bs } i x) → motive x x_1 x_2 | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.uaddOverflow_assoc._simp_1_2 | Init.Data.BitVec.Lemmas | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | false |
Finset.weightedVSubOfPoint_eq_of_sum_eq_zero | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w : ι → k) (p : ι → P),
∑ i ∈ s, w i = 0 → ∀ (b₁ b₂ : P), (s.weightedVSubOfPoint p b₁) w = (s.weightedVSubOfPoint p b₂) w | true |
_private.Lean.Meta.Basic.0.Lean.Meta.forallTelescopeReducingAuxAux.process._unsafe_rec | Lean.Meta.Basic | {α : Type} →
Bool →
Option ℕ →
(Array Lean.Expr → Lean.Expr → Lean.MetaM α) →
Bool → Bool → Lean.LocalContext → Array Lean.Expr → ℕ → Lean.Expr → Lean.MetaM α | false |
CategoryTheory.Idempotents.karoubiUniversal.eq_1 | Mathlib.CategoryTheory.Idempotents.FunctorExtension | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.IsIdempotentComplete D],
CategoryTheory.Idempotents.karoubiUniversal C D =
(CategoryTheory.Idempotents.karoubiUniversal₂ C D).trans
(CategoryTheory.Idempot... | true |
IsCompact.sInf_mem | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [ClosedIicTopology α]
{s : Set α}, IsCompact s → s.Nonempty → sInf s ∈ s | true |
_private.Mathlib.Data.List.Defs.0.List.permutationsAux.rec.match_1._arg_pusher | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (α_1 : Sort u✝) (β : α_1 → Sort v✝) (f : (x : α_1) → β x)
(rel : List α → List α → α_1 → Prop) (x x_1 : List α)
(h_1 : (is : List α) → ((y : α_1) → rel [] is y → β y) → motive [] is)
(h_2 : (t : α) → (ts is : List α) → ((y : α_1) → rel (t :: ts) is y → β y) →... | false |
Filter.tendsto_bot._simp_1 | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : Filter β}, Filter.Tendsto f ⊥ l = True | false |
FirstOrder.Language.Equiv.comp_right_inj | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N] {P : Type u_1}
[inst_2 : L.Structure P] (h : L.Equiv M N) (f g : L.Equiv N P), f.comp h = g.comp h ↔ f = g | true |
_private.Mathlib.Analysis.Convex.Segment.0.openSegment_subset_iff.match_1_1 | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_2) {E : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] {x y : E} (x_1 : E) (motive : x_1 ∈ openSegment 𝕜 x y → Prop) (x_2 : x_1 ∈ openSegment 𝕜 x y),
(∀ (a b : 𝕜) (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) (hz : a • x + b • y = x_1), moti... | false |
SimpleGraph.Subgraph.sSup_adj._simp_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {a b : V} {s : Set G.Subgraph}, (sSup s).Adj a b = ∃ G_1 ∈ s, G_1.Adj a b | false |
Array.empty_of_isEmpty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, xs.isEmpty = true → xs = #[] | true |
Std.DTreeMap.Internal.RiiSliceData.casesOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
{motive : Std.DTreeMap.Internal.RiiSliceData α β → Sort u_1} →
(t : Std.DTreeMap.Internal.RiiSliceData α β) →
((treeMap : Std.DTreeMap.Internal.Impl α β) →
(range : Std.Rii α) → motive { treeMap := treeMap, range := range }) →
motive t | false |
Int8.toInt16_le._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, (a.toInt16 ≤ b.toInt16) = (a ≤ b) | false |
CliffordAlgebra.EquivEven.Q' | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → QuadraticForm R M → QuadraticForm R (M × R) | true |
NonUnitalSubring.topologicalClosure_minimal | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonUnitalRing R] [inst_2 : IsSemitopologicalRing R]
(s : NonUnitalSubring R) {t : NonUnitalSubring R}, s ≤ t → IsClosed ↑t → s.topologicalClosure ≤ t | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rco_succ_right_eq_push._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {α : Type u_1} {as : List α} {bs : Array α}, (as.toArray = bs) = (as = bs.toList) | false |
_private.Std.Data.Iterators.Combinators.Monadic.Zip.0.Option.SomeLtNone.lt.match_1.eq_2 | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {β : Type u_2} {α : Type u_1} (motive : Option α → Option β → Sort u_3) (val : α)
(h_1 : (x : Option β) → motive none x) (h_2 : (val : α) → motive (some val) none)
(h_3 : (x : α) → (y : β) → motive (some x) (some y)),
(match some val, none with
| none, x => h_1 x
| some val, none => h_2 val
| some x... | true |
LatticeHom.withBotWithTop' | Mathlib.Order.Hom.WithTopBot | {α : Type u_1} →
{β : Type u_2} →
[inst : Lattice α] →
[inst_1 : Lattice β] → [inst_2 : BoundedOrder β] → LatticeHom α β → BoundedLatticeHom (WithBot (WithTop α)) β | true |
HahnSeries.cardSupp_add_le | Mathlib.RingTheory.HahnSeries.Cardinal | ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddMonoid R] (x y : HahnSeries Γ R),
(x + y).cardSupp ≤ x.cardSupp + y.cardSupp | true |
_private.Mathlib.NumberTheory.NumberField.Units.Regulator.0.NumberField.Units.finrank_mul_regOfFamily_eq_det._simp_1_2 | Mathlib.NumberTheory.NumberField.Units.Regulator | ∀ {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [inst : FunLike F α β] [i : EmbeddingLike F α β] (f : F) {x y : α},
(f x = f y) = (x = y) | false |
ContinuousMapZero.instMetricSpace._proof_1 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {α : Type u_2} {R : Type u_1} [inst : TopologicalSpace α] [inst_1 : Zero α] [inst_2 : MetricSpace R]
[inst_3 : Zero R], ContinuousMapClass (ContinuousMapZero α R) α R | false |
Nat.gcd_add_right_left_of_dvd | Init.Data.Nat.Gcd | ∀ {m k : ℕ} (n : ℕ), m ∣ k → (n + k).gcd m = n.gcd m | true |
Projectivization.Subspace.span | Mathlib.LinearAlgebra.Projectivization.Subspace | {K : Type u_1} →
{V : Type u_2} →
[inst : Field K] →
[inst_1 : AddCommGroup V] → [inst_2 : Module K V] → Set (Projectivization K V) → Projectivization.Subspace K V | true |
MeasurableEquiv.prodComm._proof_4 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β],
Measurable ⇑(Equiv.prodComm α β).symm | false |
Lean.Elab.Deriving.FromToJson.mkFromJsonHeader | Lean.Elab.Deriving.FromToJson | Lean.InductiveVal → Lean.Elab.TermElabM Lean.Elab.Deriving.Header | true |
MulSemiringAction.toRingEquiv | Mathlib.Algebra.Ring.Action.Group | (G : Type u_1) → [inst : Group G] → (R : Type u_2) → [inst_1 : Semiring R] → [MulSemiringAction G R] → G → R ≃+* R | true |
Set.powerset | Mathlib.Data.Set.Defs | {α : Type u} → Set α → Set (Set α) | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheorem.noConfusion | Lean.Elab.Tactic.Do.Attr | {P : Sort u} →
{t t' : Lean.Elab.Tactic.Do.SpecAttr.SpecTheorem} →
t = t' → Lean.Elab.Tactic.Do.SpecAttr.SpecTheorem.noConfusionType P t t' | false |
ContinuousAlgHom.map_smul_of_tower | Mathlib.Topology.Algebra.Algebra | ∀ {A : Type u_2} [inst : Semiring A] [inst_1 : TopologicalSpace A] {B : Type u_3} [inst_2 : Semiring B]
[inst_3 : TopologicalSpace B] {R : Type u_4} {S : Type u_5} [inst_4 : CommSemiring S] [inst_5 : SMul R A]
[inst_6 : Algebra S A] [inst_7 : SMul R B] [inst_8 : Algebra S B] [MulActionHomClass (A →A[S] B) R A B]
... | true |
Int64.toInt8_ofIntLE | Init.Data.SInt.Lemmas | ∀ {n : ℤ} (h₁ : Int64.minValue.toInt ≤ n) (h₂ : n ≤ Int64.maxValue.toInt), (Int64.ofIntLE n h₁ h₂).toInt8 = Int8.ofInt n | true |
RingPreordering.mem_mk' | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_2} [inst : CommRing R] {P : Set R} {add : ∀ {x y : R}, x ∈ P → y ∈ P → x + y ∈ P}
{mul : ∀ {x y : R}, x ∈ P → y ∈ P → x * y ∈ P} {sq : ∀ (x : R), x * x ∈ P} {neg_one : -1 ∉ P} {x : R},
x ∈ RingPreordering.mk' P add mul sq neg_one ↔ x ∈ P | true |
CategoryTheory.MonoidalClosed.enrichedCategorySelf._proof_4 | Mathlib.CategoryTheory.Monoidal.Closed.Enrichment | ∀ (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),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor (X ⟹ Y)).inv
(CategoryTheory.CategoryStruct.comp
(Cate... | false |
AlgebraicGeometry.iSup_basicOpen_of_span_eq_top | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens) (s : Set ↑(X.presheaf.obj (Opposite.op U))),
Ideal.span s = ⊤ → ⨆ i ∈ s, X.basicOpen i = U | true |
CategoryTheory.Pseudofunctor.map₂_left_unitor_app_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (self : CategoryTheory.Pseudofunctor B CategoryTheory.Cat)
{a b : B} (f : a ⟶ b) (X : ↑(self.obj a)) {Z : ↑(self.obj b)} (h : (self.map f).toFunctor.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp ((self.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom).toNatTra... | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore.0.SSet.Subcomplex.PairingCore.instIsRegularPairingOfIsRegular._simp_3 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} (h : A.PairingCore) (s t : h.ι),
h.AncestralRel s t = h.pairing.AncestralRel (h.equivII s) (h.equivII t) | false |
LaurentPolynomial.eval₂_T_neg_n | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_3} [inst_1 : CommSemiring S] (f : R →+* S) (x : Sˣ) (n : ℕ),
(LaurentPolynomial.eval₂ f x) (LaurentPolynomial.T (-↑n)) = ↑x⁻¹ ^ n | true |
MeasureTheory.Measure.prod.instIsAddHaarMeasure | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_3} [inst : AddGroup G] [inst_1 : TopologicalSpace G] {x : MeasurableSpace G} {H : Type u_4}
[inst_2 : AddGroup H] [inst_3 : TopologicalSpace H] {x_1 : MeasurableSpace H} (μ : MeasureTheory.Measure G)
(ν : MeasureTheory.Measure H) [μ.IsAddHaarMeasure] [ν.IsAddHaarMeasure] [MeasureTheory.SFinite μ]
[M... | true |
Lean.Meta.Simp.SimprocEntry.noConfusion | Lean.Meta.Tactic.Simp.Types | {P : Sort u} → {t t' : Lean.Meta.Simp.SimprocEntry} → t = t' → Lean.Meta.Simp.SimprocEntry.noConfusionType P t t' | false |
_private.Std.Sat.CNF.RelabelFin.0.Std.Sat.CNF.lt_numLiterals._proof_1_2 | Std.Sat.CNF.RelabelFin | ∀ {v : ℕ} (n : ℕ), v ≤ n → ¬v < n + 1 → False | false |
AddOpposite.op_inj._simp_1 | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} {x y : α}, (AddOpposite.op x = AddOpposite.op y) = (x = y) | false |
CategoryTheory.Bicategory.Equivalence.hom | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u} → [inst : CategoryTheory.Bicategory B] → {a b : B} → CategoryTheory.Bicategory.Equivalence a b → (a ⟶ b) | true |
PresheafOfModules.instFullSheafOfModulesCompObjFunctorOppositeRingCatIsSheafForgetRestrictScalars | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafification | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[CategoryTheory.Presheaf.IsLocallyInjective J α] [CategoryTheory.Presheaf.IsLocallySurjective J α]
[J.WEqualsLocal... | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint.match_1.congr_eq_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ}
(motive : Std.Tactic.BVDecide.LRAT.Internal.ReduceResult (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) → Sort u_1)
(x : Std.Tactic.BVDecide.LRAT.Internal.ReduceResult (Std.Tactic.BVDecide.LRAT.Internal.PosFin n))
(h_1 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth)
(h_2 ... | true |
Std.ExtDTreeMap.minKey_eq_minKey! | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {he : t ≠ ∅}, t.minKey he = t.minKey! | true |
_private.Init.Prelude.0.of_decide_eq_false.match_1_1 | Init.Prelude | ∀ {p : Prop} (motive : Decidable p → Prop) (inst : Decidable p),
(∀ (h₁ : p), motive (isTrue h₁)) → (∀ (h₁ : ¬p), motive (isFalse h₁)) → motive inst | false |
Mathlib.Tactic.AtomM.State.mk.inj | Mathlib.Util.AtomM | ∀ {atoms atoms_1 : Array Lean.Expr}, { atoms := atoms } = { atoms := atoms_1 } → atoms = atoms_1 | true |
Tropical.instCommSemiring._proof_12 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrderedAddCommMonoidWithTop R] (a : Tropical R), a * 1 = a | false |
USize.not_inj._simp_1 | Init.Data.UInt.Bitwise | ∀ {a b : USize}, (~~~a = ~~~b) = (a = b) | false |
nndist_eq_nnnorm | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] (a b : E), nndist a b = ‖a - b‖₊ | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.SurjectiveOnStalks.0.AlgebraicGeometry.SurjectiveOnStalks.isEmbedding_pullback._simp_1_6 | Mathlib.AlgebraicGeometry.Morphisms.SurjectiveOnStalks | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | false |
Stream'.getElem?_take_succ | Mathlib.Data.Stream.Init | ∀ {α : Type u} (n : ℕ) (s : Stream' α), (Stream'.take n.succ s)[n]? = some (s.get n) | true |
Std.ExtHashSet.instReflBEq | Std.Data.ExtHashSet.Basic | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α],
ReflBEq (Std.ExtHashSet α) | true |
Holor.slice.congr_simp | Mathlib.Data.Holor | ∀ {α : Type} {d : ℕ} {ds : List ℕ} (x x_1 : Holor α (d :: ds)),
x = x_1 →
∀ (i i_1 : ℕ) (e_i : i = i_1) (h : i < d) (a a_1 : HolorIndex ds), a = a_1 → x.slice i h a = x_1.slice i_1 ⋯ a_1 | true |
IsPreconnected.iUnion_of_reflTransGen | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] {ι : Type u_3} {s : ι → Set α},
(∀ (i : ι), IsPreconnected (s i)) →
(∀ (i j : ι), Relation.ReflTransGen (fun i j => (s i ∩ s j).Nonempty) i j) → IsPreconnected (⋃ n, s n) | true |
CategoryTheory.Injective.instProjectiveOppositeOp | Mathlib.CategoryTheory.Preadditive.Injective.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : C} [CategoryTheory.Injective J],
CategoryTheory.Projective (Opposite.op J) | true |
Fin.append_rev | Mathlib.Data.Fin.Tuple.Basic | ∀ {α : Sort u_1} {m n : ℕ} (xs : Fin m → α) (ys : Fin n → α) (i : Fin (m + n)),
Fin.append xs ys i.rev = Fin.append (ys ∘ Fin.rev) (xs ∘ Fin.rev) (Fin.cast ⋯ i) | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_ric_eq_toArray_rio._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...=n).toArray = (*...=n).toList.toArray | false |
meromorphicOrderAt_id_sub_const | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {x : 𝕜}, meromorphicOrderAt (fun x_1 => x_1 - x) x = 1 | true |
AddSubgroup.neg_mem | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) {x : G}, x ∈ H → -x ∈ H | true |
Delone.DeloneSet.mk.noConfusion | Mathlib.Analysis.AperiodicOrder.Delone.Basic | {X : Type u_3} →
{inst : MetricSpace X} →
{P : Sort u} →
{carrier : Set X} →
{packingRadius : NNReal} →
{packingRadius_pos : 0 < packingRadius} →
{isSeparated_packingRadius : Metric.IsSeparated (↑packingRadius) carrier} →
{coveringRadius : NNReal} →
... | false |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_8 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ¬Std.Tactic.BVDecide.BVUnOp.not = Std.Tactic.BVDecide.BVUnOp.cpop | false |
Dioph.«term_D/_» | Mathlib.NumberTheory.Dioph | Lean.TrailingParserDescr | true |
CategoryTheory.Endofunctor.Coalgebra.functorOfNatTransId_hom_app_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
(X : CategoryTheory.Endofunctor.Coalgebra F),
(CategoryTheory.Endofunctor.Coalgebra.functorOfNatTransId.hom.app X).f = CategoryTheory.CategoryStruct.id X.V | true |
AddSubsemigroup.comap_top | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (f : M →ₙ+ N), AddSubsemigroup.comap f ⊤ = ⊤ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.