name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.FieldTheory.Finite.Basic.0.termQ | Mathlib.FieldTheory.Finite.Basic | Lean.ParserDescr | true |
Std.Tactic.BVDecide.LRAT.Internal.Clause.empty_eq | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {α : outParam (Type u)} {β : Type v} [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β],
Std.Tactic.BVDecide.LRAT.Internal.Clause.toList Std.Tactic.BVDecide.LRAT.Internal.Clause.empty = [] | true |
CategoryTheory.MonoidalClosed.uncurry_natural_left_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A X X' Y : C}
[inst_2 : CategoryTheory.Closed A] (f : X ⟶ X') (g : X' ⟶ A ⟹ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalClosed.uncurry (CategoryTheory.CategoryStruct.comp f g))
h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft A f)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalClosed.uncurry g) h) | true |
_private.Mathlib.Analysis.Normed.Ring.Ultra.0.IsUltrametricDist.norm_add_one_le_max_norm_one._simp_1_1 | Mathlib.Analysis.Normed.Ring.Ultra | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) | false |
AddGroupSeminorm.mk.noConfusion | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
{inst : AddGroup G} →
{P : Sort u} →
{toFun : G → ℝ} →
{map_zero' : toFun 0 = 0} →
{add_le' : ∀ (r s : G), toFun (r + s) ≤ toFun r + toFun s} →
{neg' : ∀ (r : G), toFun (-r) = toFun r} →
{toFun' : G → ℝ} →
{map_zero'' : toFun' 0 = 0} →
{add_le'' : ∀ (r s : G), toFun' (r + s) ≤ toFun' r + toFun' s} →
{neg'' : ∀ (r : G), toFun' (-r) = toFun' r} →
{ toFun := toFun, map_zero' := map_zero', add_le' := add_le', neg' := neg' } =
{ toFun := toFun', map_zero' := map_zero'', add_le' := add_le'', neg' := neg'' } →
(toFun ≍ toFun' → P) → P | false |
hasSumLocallyUniformlyOn_of_forall_compact | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : AddCommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β],
IsOpen s →
∀ [LocallyCompactSpace β], (∀ K ⊆ s, IsCompact K → HasSumUniformlyOn f g K) → HasSumLocallyUniformlyOn f g s | true |
_private.Mathlib.Analysis.SpecificLimits.FloorPow.0.tendsto_div_of_monotone_of_exists_subseq_tendsto_div._simp_1_3 | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
Lean.getAttributeNames | Lean.Attributes | Lean.Environment → List Lean.Name | true |
SMulCommClass.symm | Mathlib.Algebra.Group.Action.Defs | ∀ (M : Type u_9) (N : Type u_10) (α : Type u_11) [inst : SMul M α] [inst_1 : SMul N α] [SMulCommClass M N α],
SMulCommClass N M α | true |
Std.«term_..._» | Init.Data.Range.Polymorphic.PRange | Lean.TrailingParserDescr | true |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.expandFields | Lean.Elab.Structure | Lean.Syntax → Lean.Elab.Modifiers → Lean.Name → Lean.Elab.TermElabM (Array Lean.Elab.Command.Structure.StructFieldView) | true |
AddMonoidAlgebra.mapDomainRingEquiv._proof_1 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ (R : Type u_1) {M : Type u_3} {N : Type u_2} [inst : Semiring R] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
(e : M ≃+ N),
(AddMonoidAlgebra.mapDomainRingHom R ↑e).comp (AddMonoidAlgebra.mapDomainRingHom R ↑e.symm) =
RingHom.id (AddMonoidAlgebra R N) | false |
Lean.Grind.Config.detailed | Init.Grind.Config | Lean.Grind.Config → ℕ | true |
Nat.testBit_add | Init.Data.Nat.Bitwise.Lemmas | ∀ (x i n : ℕ), x.testBit (i + n) = (x / 2 ^ n).testBit i | true |
Std.HashMap.Raw.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α Unit} [EquivBEq α] [LawfulHashable α]
[inst_4 : Inhabited α],
m.WF →
∀ {l : List α} {k k' : α},
(k == k') = true →
k ∉ m → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (m.insertManyIfNewUnit l).getKey! k' = k | true |
Algebra.normalizedTrace_def | Mathlib.FieldTheory.NormalizedTrace | ∀ (F : Type u_1) (K : Type u_2) [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K] [inst_3 : CharZero F]
[inst_4 : Algebra.IsIntegral F K] (a : K),
(Algebra.normalizedTrace F K) a =
(↑(Module.finrank F ↥F⟮a⟯))⁻¹ • (Algebra.trace F ↥F⟮a⟯) (IntermediateField.AdjoinSimple.gen F a) | true |
_private.Mathlib.AlgebraicGeometry.Limits.0.AlgebraicGeometry.isCompl_opensRange_inl_inr._simp_1_1 | Mathlib.AlgebraicGeometry.Limits | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] {a b : α},
IsCompl a b = (Disjoint a b ∧ Codisjoint a b) | false |
List.Vector.mem_map_succ_iff | Mathlib.Data.Vector.Mem | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} (b : β) (v : List.Vector α (n + 1)) (f : α → β),
b ∈ (List.Vector.map f v).toList ↔ f v.head = b ∨ ∃ a ∈ v.tail.toList, f a = b | true |
Lean.Json.arr.noConfusion | Lean.Data.Json.Basic | {P : Sort u} → {elems elems' : Array Lean.Json} → Lean.Json.arr elems = Lean.Json.arr elems' → (elems = elems' → P) → P | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_lt_twoPow_of_le._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {m n : ℕ}, ¬1 < 2 → False | false |
CategoryTheory.Bicategory.«term⊗𝟙» | Mathlib.Tactic.CategoryTheory.BicategoricalComp | Lean.ParserDescr | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.leftActionOfMonoidalOppositeRightAction_actionHomRight | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction Cᴹᵒᵖ D] (c : C) {d d' : D} (f : d ⟶ d'),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight c f =
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f { unmop := c } | true |
_private.Plausible.Testable.0.Plausible.Decorations._aux_Plausible_Testable___elabRules_Plausible_Decorations_tacticMk_decorations_1._sparseCasesOn_4 | Plausible.Testable | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Std.Net.instInhabitedSocketAddress | Std.Net.Addr | Inhabited Std.Net.SocketAddress | true |
CategoryTheory.Pretriangulated.shortComplexOfDistTriangleIsoOfIso | Mathlib.CategoryTheory.Triangulated.Pretriangulated | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[inst_3 : CategoryTheory.Preadditive C] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[hC : CategoryTheory.Pretriangulated C] →
{T T' : CategoryTheory.Pretriangulated.Triangle C} →
(e : T ≅ T') →
(hT : T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles) →
CategoryTheory.Pretriangulated.shortComplexOfDistTriangle T hT ≅
CategoryTheory.Pretriangulated.shortComplexOfDistTriangle T' ⋯ | true |
AbstractCompletion.uniformStruct | Mathlib.Topology.UniformSpace.AbstractCompletion | {α : Type u} → [inst : UniformSpace α] → (self : AbstractCompletion.{v, u} α) → UniformSpace self.space | true |
Finpartition.IsEquipartition | Mathlib.Order.Partition.Equipartition | {α : Type u_1} → [inst : DecidableEq α] → {s : Finset α} → Finpartition s → Prop | true |
Mathlib.Tactic.ITauto.Proof.andRight.injEq | Mathlib.Tactic.ITauto | ∀ (ak : Mathlib.Tactic.ITauto.AndKind) (p : Mathlib.Tactic.ITauto.Proof) (ak_1 : Mathlib.Tactic.ITauto.AndKind)
(p_1 : Mathlib.Tactic.ITauto.Proof),
(Mathlib.Tactic.ITauto.Proof.andRight ak p = Mathlib.Tactic.ITauto.Proof.andRight ak_1 p_1) = (ak = ak_1 ∧ p = p_1) | true |
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.iUnion_inf._simp_1_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {β : Type u_2} {ι : Sort u_5} (s : Set β) (t : ι → Set β), ⋃ i, t i ∩ s = (⋃ i, t i) ∩ s | false |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosDef.inv._simp_1_2 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] {A : Matrix n n α},
IsUnit A⁻¹ = IsUnit A | false |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.getMsbD_ofFnBE._proof_1_5 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : ℕ) (h_1 : -1 * ↑n + ↑i + 1 ≤ 0) (left : (BitVec.ofFnBE f).getMsbD i = true),
n - (↑⟨n - (i + 1), ⋯⟩ + 1) < n | false |
groupHomology.inhomogeneousChains.d_comp_d | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (n : ℕ),
CategoryTheory.CategoryStruct.comp (groupHomology.inhomogeneousChains.d A (n + 1))
(groupHomology.inhomogeneousChains.d A n) =
0 | true |
ISize.ofInt_tmod | Init.Data.SInt.Lemmas | ∀ {a b : ℤ},
ISize.minValue.toInt ≤ a →
a ≤ ISize.maxValue.toInt →
ISize.minValue.toInt ≤ b → b ≤ ISize.maxValue.toInt → ISize.ofInt (a.tmod b) = ISize.ofInt a % ISize.ofInt b | true |
Matrix.PosSemidef.nonneg | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] {A : Matrix n n 𝕜}, A.PosSemidef → 0 ≤ A | true |
Monoid.CoprodI.Word.empty._proof_1 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)], ∀ l ∈ [], l.snd ≠ 1 | false |
Lean.Lsp.MarkupKind.rec | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.MarkupKind → Sort u} →
motive Lean.Lsp.MarkupKind.plaintext → motive Lean.Lsp.MarkupKind.markdown → (t : Lean.Lsp.MarkupKind) → motive t | false |
NonUnitalAlgHom.prod._proof_2 | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u_4} [inst : Monoid R] {A : Type u_3} {B : Type u_1} {C : Type u_2} [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : NonUnitalNonAssocSemiring C]
[inst_5 : DistribMulAction R B] [inst_6 : DistribMulAction R C] (f : A →ₙₐ[R] B) (g : A →ₙₐ[R] C),
Pi.prod (⇑f) (⇑g) 0 = 0 | false |
Matroid.IsNonloop.contractElem_indep_iff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {e : α} {I : Set α},
M.IsNonloop e → ((M.contract {e}).Indep I ↔ e ∉ I ∧ M.Indep (insert e I)) | true |
IsCoprime.add_mul_left_left_iff | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y z : R}, IsCoprime (x + y * z) y ↔ IsCoprime x y | true |
IsSuccArchimedean.linearOrder._proof_4 | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : DecidableLE α] (a b : α),
(if a ≤ b then b else a) = if a ≤ b then b else a | false |
_private.Mathlib.RingTheory.Valuation.Basic.0.Valuation.map_sub_of_left_eq_zero._simp_1_1 | Mathlib.RingTheory.Valuation.Basic | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a : α}, (0 < a) = (a ≠ 0) | false |
normalClosure_def | Mathlib.FieldTheory.Normal.Closure | ∀ (F : Type u_1) (K : Type u_2) (L : Type u_3) [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra F K] [inst_4 : Algebra F L], IntermediateField.normalClosure F K L = ⨆ f, f.fieldRange | true |
Std.Iter.find? | Init.Data.Iterators.Consumers.Loop | {α β : Type w} → [inst : Std.Iterator α Id β] → [Std.IteratorLoop α Id Id] → Std.Iter β → (β → Bool) → Option β | true |
_private.Mathlib.Topology.Instances.Real.Lemmas.0.Real.isTopologicalBasis_Ioo_rat.match_1_3 | Mathlib.Topology.Instances.Real.Lemmas | ∀ (a w : ℝ) (motive : (∃ q, a < ↑q ∧ ↑q < w) → Prop) (x : ∃ q, a < ↑q ∧ ↑q < w),
(∀ (p : ℚ) (hap : a < ↑p) (hpu : ↑p < w), motive ⋯) → motive x | false |
Condensed.isoLocallyConstantOfIsColimit | Mathlib.Condensed.Discrete.Colimit | (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))) →
[CategoryTheory.Limits.PreservesFiniteProducts F] →
((S : Profinite) → CategoryTheory.Limits.IsColimit (F.mapCocone S.asLimitCone.op)) →
(F ≅
Condensed.locallyConstantPresheaf
(F.obj (FintypeCat.toProfinite.op.obj (Opposite.op (FintypeCat.of PUnit.{u + 1}))))) | true |
Submodule.isOrtho_iSup_right | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Sort u_4} {U : Submodule 𝕜 E} {V : ι → Submodule 𝕜 E}, U ⟂ iSup V ↔ ∀ (i : ι), U ⟂ V i | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (h : Lean.Expr), sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound h) = 1 + sizeOf h | true |
Std.DTreeMap.Raw.maxKey!_alter_eq_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] [inst_1 : Inhabited α],
t.WF →
∀ {k : α} {f : Option (β k) → Option (β k)},
(t.alter k f).isEmpty = false →
((t.alter k f).maxKey! = k ↔ (f (t.get? k)).isSome = true ∧ ∀ k' ∈ t, (cmp k' k).isLE = true) | true |
_private.Mathlib.Algebra.Order.Monovary.0.monovaryOn_iff_forall_smul_nonneg._simp_1_3 | Mathlib.Algebra.Order.Monovary | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b : α}, (0 ≤ a - b) = (b ≤ a) | false |
Std.HashSet.Raw.Equiv.union_right | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ m₃ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → m₃.WF → m₂.Equiv m₃ → (m₁ ∪ m₂).Equiv (m₁ ∪ m₃) | true |
CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_fst_fst | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.diagonalObjPullbackFstIso f g).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.fst f g)
(CategoryTheory.Limits.pullback.fst f g))
(CategoryTheory.Limits.pullback.fst f g)) =
CategoryTheory.Limits.pullback.snd (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd g g) g) f | true |
WithVal.instField._proof_24 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Field R] (v : Valuation R Γ₀)
(q : ℚ) (x : WithVal v),
(WithVal.equiv v).toEquiv ((WithVal.equiv v).symm (q • (WithVal.equiv v).toEquiv x)) = q • (WithVal.equiv v).toEquiv x | false |
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.splitLocalDecl?.match_1 | Lean.Meta.Tactic.Split | (motive : Lean.MVarId × Lean.MVarId → Sort u_1) →
(x : Lean.MVarId × Lean.MVarId) → ((mvarId₁ mvarId₂ : Lean.MVarId) → motive (mvarId₁, mvarId₂)) → motive x | false |
Qq.MaybeDefEq.defEq | Qq.MetaM | {u : Lean.Level} →
{α :
let u := u;
Q(Sort u)} →
{a b : Q(«$α»)} → «$a» =Q «$b» → Qq.MaybeDefEq a b | true |
alternatingGroup.normal_kleinFour | Mathlib.GroupTheory.SpecificGroups.Alternating.KleinFour | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α], Nat.card α = 4 → (alternatingGroup.kleinFour α).Normal | true |
PointedContMDiffMap.smul_def | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : 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] (x : M) (f : PointedContMDiffMap 𝕜 I M (↑⊤) x) (k : 𝕜),
f • k = f x * k | true |
DomMulAct.instSMulSubtypeAEEqFunMemAddSubgroupLp._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | false |
_private.Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject.0.SimplicialObject.Splitting.toKaroubiNondegComplexIsoN₁._simp_5 | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∀ (a : α), p a) = True | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getLsbD_twoPow._proof_1_4 | Init.Data.BitVec.Lemmas | ∀ (i j w : ℕ), j < i → i = j → False | false |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.Indep.mem_fundCircuit_iff._simp_1_1 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} (M : Matroid α) (e : α) (I : Set α), (e ∈ M.fundCircuit e I) = True | false |
Quaternion.dualNumberEquiv._proof_3 | Mathlib.Algebra.DualQuaternion | ∀ {R : Type u_1} [inst : CommRing R] (x y : Quaternion (DualNumber R)),
({ re := TrivSqZeroExt.fst (x * y).re, imI := TrivSqZeroExt.fst (x * y).imI, imJ := TrivSqZeroExt.fst (x * y).imJ,
imK := TrivSqZeroExt.fst (x * y).imK },
{ re := TrivSqZeroExt.snd (x * y).re, imI := TrivSqZeroExt.snd (x * y).imI, imJ := TrivSqZeroExt.snd (x * y).imJ,
imK := TrivSqZeroExt.snd (x * y).imK }) =
({ re := TrivSqZeroExt.fst x.re, imI := TrivSqZeroExt.fst x.imI, imJ := TrivSqZeroExt.fst x.imJ,
imK := TrivSqZeroExt.fst x.imK },
{ re := TrivSqZeroExt.snd x.re, imI := TrivSqZeroExt.snd x.imI, imJ := TrivSqZeroExt.snd x.imJ,
imK := TrivSqZeroExt.snd x.imK }) *
({ re := TrivSqZeroExt.fst y.re, imI := TrivSqZeroExt.fst y.imI, imJ := TrivSqZeroExt.fst y.imJ,
imK := TrivSqZeroExt.fst y.imK },
{ re := TrivSqZeroExt.snd y.re, imI := TrivSqZeroExt.snd y.imI, imJ := TrivSqZeroExt.snd y.imJ,
imK := TrivSqZeroExt.snd y.imK }) | false |
norm_commutator_sub_one_le | Mathlib.Analysis.Normed.Field.Basic | ∀ {α : Type u_2} [inst : NormedDivisionRing α] {a b : α},
a ≠ 0 → b ≠ 0 → ‖a * b * a⁻¹ * b⁻¹ - 1‖ ≤ 2 * ‖a‖⁻¹ * ‖b‖⁻¹ * ‖a - 1‖ * ‖b - 1‖ | true |
Group.IsPerfect.mk._flat_ctor | Mathlib.GroupTheory.IsPerfect | ∀ {G : Type u_1} [inst : Group G], commutator G = ⊤ → Group.IsPerfect G | false |
IsDedekindDomainDvr.is_dvr_at_nonzero_prime | Mathlib.RingTheory.DedekindDomain.Dvr | ∀ {A : Type u_1} {inst : CommRing A} {inst_1 : IsDomain A} [self : IsDedekindDomainDvr A] (P : Ideal A),
P ≠ ⊥ → ∀ (x : P.IsPrime), IsDiscreteValuationRing (Localization.AtPrime P) | true |
exists_nhds_split_inv | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] {s : Set G},
s ∈ nhds 1 → ∃ V ∈ nhds 1, ∀ v ∈ V, ∀ w ∈ V, v / w ∈ s | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.below | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Linear.IneqCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Linear.DiseqCnstr → Sort u} →
{motive_6 : Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof → Sort u} →
{motive_7 : Lean.Meta.Grind.Arith.Linear.UnsatProof → Sort u} →
Lean.Meta.Grind.Arith.Linear.EqCnstrProof → Sort (max 1 u) | false |
Mathlib.Tactic.Rify.ratCast_le._simp_1 | Mathlib.Tactic.Rify | ∀ (a b : ℚ), (a ≤ b) = (↑a ≤ ↑b) | false |
Lean.Parser.Term.unreachable.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
PSigma.RevLex.casesOn | Init.WF | ∀ {α : Sort u} {β : Sort v} {r : α → α → Prop} {s : β → β → Prop}
{motive : (a a_1 : (_ : α) ×' β) → PSigma.RevLex r s a a_1 → Prop} {a a_1 : (_ : α) ×' β}
(t : PSigma.RevLex r s a a_1),
(∀ {a₁ a₂ : α} (b : β) (a : r a₁ a₂), motive ⟨a₁, b⟩ ⟨a₂, b⟩ ⋯) →
(∀ (a₁ : α) {b₁ : β} (a₂ : α) {b₂ : β} (a : s b₁ b₂), motive ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⋯) → motive a a_1 t | false |
AddSubgroup.instFiniteIndexTop | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G], ⊤.FiniteIndex | true |
Nat.bijective_iff_surjective_and_card | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1} {β : Type u_2} [Finite α] (f : α → β),
Function.Bijective f ↔ Function.Surjective f ∧ Nat.card α = Nat.card β | true |
CategoryTheory.Functor.effectiveEpiFamily_of_map | Mathlib.CategoryTheory.EffectiveEpi.Preserves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) [F.ReflectsEffectiveEpiFamilies]
{α : Type u} {B : C} (X : α → C) (π : (a : α) → X a ⟶ B),
(CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)) →
CategoryTheory.EffectiveEpiFamily X π | true |
IsSemireal.recOn | Mathlib.Algebra.Ring.Semireal.Defs | {R : Type u_1} →
[inst : Add R] →
[inst_1 : Mul R] →
[inst_2 : One R] →
[inst_3 : Zero R] →
{motive : IsSemireal R → Sort u} →
(t : IsSemireal R) → ((one_add_ne_zero : ∀ {s : R}, IsSumSq s → 1 + s ≠ 0) → motive ⋯) → motive t | false |
_private.Lean.Meta.Tactic.SplitIf.0.Lean.Meta.FindSplitImpl.isCandidate?.match_1 | Lean.Meta.Tactic.SplitIf | (motive : Option (Option Lean.Expr) → Sort u_1) →
(x : Option (Option Lean.Expr)) → (Unit → motive none) → ((a : Option Lean.Expr) → motive (some a)) → motive x | false |
_private.Mathlib.Algebra.Quandle.0.Rack.toEnvelGroup.mapAux.match_1.eq_3 | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} (motive : Rack.PreEnvelGroup R → Sort u_2) (a b : Rack.PreEnvelGroup R)
(h_1 : Unit → motive Rack.PreEnvelGroup.unit) (h_2 : (x : R) → motive (Rack.PreEnvelGroup.incl x))
(h_3 : (a b : Rack.PreEnvelGroup R) → motive (a.mul b)) (h_4 : (a : Rack.PreEnvelGroup R) → motive a.inv),
(match a.mul b with
| Rack.PreEnvelGroup.unit => h_1 ()
| Rack.PreEnvelGroup.incl x => h_2 x
| a.mul b => h_3 a b
| a.inv => h_4 a) =
h_3 a b | true |
Std.DHashMap.Const.toList_empty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v}, Std.DHashMap.Const.toList ∅ = [] | true |
HopfAlgCat.Hom.noConfusion | Mathlib.Algebra.Category.HopfAlgCat.Basic | {P : Sort u_1} →
{R : Type u} →
{inst : CommRing R} →
{V W : HopfAlgCat R} →
{t : V.Hom W} →
{R' : Type u} →
{inst' : CommRing R'} →
{V' W' : HopfAlgCat R'} →
{t' : V'.Hom W'} →
R = R' → inst ≍ inst' → V ≍ V' → W ≍ W' → t ≍ t' → HopfAlgCat.Hom.noConfusionType P t t' | false |
CategoryTheory.Limits.Cone.extendComp | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
(s : CategoryTheory.Limits.Cone F) →
{X Y : C} →
(f : X ⟶ Y) → (g : Y ⟶ s.pt) → s.extend (CategoryTheory.CategoryStruct.comp f g) ≅ (s.extend g).extend f | true |
Lean.Grind.IntModule.nsmul | Init.Grind.Module.Basic | {M : Type u} → [self : Lean.Grind.IntModule M] → SMul ℕ M | true |
sign_mul_abs | Mathlib.Data.Sign.Basic | ∀ {α : Type u} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (x : α), ↑(SignType.sign x) * |x| = x | true |
FirstOrder.Language.Equiv.instInhabited | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} → {M : Type w} → [inst : L.Structure M] → Inhabited (L.Equiv M M) | true |
CategoryTheory.Dial.Hom.rec | Mathlib.CategoryTheory.Dialectica.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
[inst_2 : CategoryTheory.Limits.HasPullbacks C] →
{X Y : CategoryTheory.Dial C} →
{motive : X.Hom Y → Sort u_1} →
((f : X.src ⟶ Y.src) →
(F : X.src ⨯ Y.tgt ⟶ X.tgt) →
(le :
(CategoryTheory.Subobject.pullback
(CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst F)).obj
X.rel ≤
(CategoryTheory.Subobject.pullback
(CategoryTheory.Limits.prod.map f (CategoryTheory.CategoryStruct.id Y.tgt))).obj
Y.rel) →
motive { f := f, F := F, le := le }) →
(t : X.Hom Y) → motive t | false |
NNReal.rpow_inv_rpow_self | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {y : ℝ}, y ≠ 0 → ∀ (x : NNReal), (x ^ y) ^ (1 / y) = x | true |
Lean.Server.Watchdog.ReferenceRequestContext.mk._flat_ctor | Lean.Server.Watchdog | Std.TreeMap Lean.Lsp.DocumentUri Lean.Name compare →
Lean.Server.References → Lean.Server.Watchdog.ReferenceRequestContext | false |
Aesop.ScriptGenerated.Method.static | Aesop.Stats.Basic | Aesop.ScriptGenerated.Method | true |
Std.Time.instReprPlainDateTime.repr | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → ℕ → Std.Format | true |
ChartedSpaceCore.noConfusion | Mathlib.Geometry.Manifold.ChartedSpace | {P : Sort u} →
{H : Type u_5} →
{inst : TopologicalSpace H} →
{M : Type u_6} →
{t : ChartedSpaceCore H M} →
{H' : Type u_5} →
{inst' : TopologicalSpace H'} →
{M' : Type u_6} →
{t' : ChartedSpaceCore H' M'} →
H = H' → inst ≍ inst' → M = M' → t ≍ t' → ChartedSpaceCore.noConfusionType P t t' | false |
_private.Mathlib.RingTheory.RingHom.Locally.0.RingHom.locally_localizationAwayPreserves._simp_1_2 | Mathlib.RingTheory.RingHom.Locally | ∀ {M : Type u_1} [inst : Monoid M] {n : M} {P : Submonoid M}, (Submonoid.powers n ≤ P) = (n ∈ P) | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint.match_5.splitter | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | {n : ℕ} →
(motive :
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment ×
Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) × Bool × Bool →
Sort u_1) →
(x :
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment ×
Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) × Bool × Bool) →
((assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) →
(derivedLits : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) →
(derivedEmpty encounteredError : Bool) →
motive (assignments, derivedLits, derivedEmpty, encounteredError)) →
motive x | true |
CStarMatrix.toCLM._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : NonUnitalCStarAlgebra A], Continuous ⇑(WithCStarModule.equivL ℂ).symm | false |
Lean.Elab.Term.MatchExpr.getAltFor? | Lean.Elab.MatchExpr | List Lean.Elab.Term.MatchExpr.Alt → Lean.Ident → Option Lean.Elab.Term.MatchExpr.Alt | true |
Orientation.finOrthonormalBasis.congr_simp | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {n : ℕ} (hn : 0 < n)
(h : Module.finrank ℝ E = n) (x x_1 : Orientation ℝ E (Fin n)),
x = x_1 → Orientation.finOrthonormalBasis hn h x = Orientation.finOrthonormalBasis hn h x_1 | true |
Mathlib.Meta.FunProp.State | Mathlib.Tactic.FunProp.Types | Type | true |
Lean.Meta.Simp.Config.warnExponents._default | Init.MetaTypes | Bool | false |
gcd_zero_left' | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] (a : α), Associated (gcd 0 a) a | true |
CategoryTheory.ShortComplex.LeftHomologyData.unop_H | 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ᵒᵖ} (h : S.LeftHomologyData), h.unop.H = Opposite.unop h.H | true |
BddOrd.hasForgetToBipointed._proof_1 | Mathlib.Order.Category.BddOrd | ∀ (X : BddOrd),
{ toFun := ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)), map_fst := ⋯, map_snd := ⋯ } =
CategoryTheory.CategoryStruct.id { X := ↑X.toPartOrd, toProd := (⊥, ⊤) } | false |
AddHom.map_add | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] (f : M →ₙ+ N) (a b : M), f (a + b) = f a + f b | true |
_private.Aesop.Builder.Default.0.Aesop.RuleBuilder.default.err | Aesop.Builder.Default | String → Aesop.RuleBuilderInput → Aesop.ElabM Aesop.LocalRuleSetMember | true |
Lean.Meta.Sym.getMatchWithExtra | Lean.Meta.Sym.Simp.DiscrTree | {α : Type} → Lean.Meta.DiscrTree α → Lean.Expr → Array (α × ℕ) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.