name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Compiler.LCNF.ElimDeadBranches.0.Lean.Compiler.LCNF.UnreachableBranches.Value.merge._sparseCasesOn_1 | Lean.Compiler.LCNF.ElimDeadBranches | {motive_1 : Lean.Compiler.LCNF.UnreachableBranches.Value → Sort u} →
(t : Lean.Compiler.LCNF.UnreachableBranches.Value) →
motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.bot →
motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.top →
((vs : List Lean.Compiler.LCNF.UnreachableBranches.Value) →
motive_1 (Lean.Compiler.LCNF.UnreachableBranches.Value.choice vs)) →
(Nat.hasNotBit 11 t.ctorIdx → motive_1 t) → motive_1 t | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.VarInfo.mk._flat_ctor | Lean.Compiler.LCNF.ExplicitRC | Bool → Bool → Bool → ℕ → Lean.Compiler.LCNF.VarInfo✝ | false |
Int.le_emod_self_add_one_iff | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 < b → (b ≤ a % b + 1 ↔ b ∣ a + 1) | true |
Topology.instIsLowerSet | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α], Topology.IsLowerSet α | true |
StandardEtalePair.instCommRingRing._aux_8 | Mathlib.RingTheory.Etale.StandardEtale | {R : Type u_1} → [inst : CommRing R] → (P : StandardEtalePair R) → ℕ → P.Ring → P.Ring | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate.0.PartialOrder.mem_nerve_nonDegenerate_iff_strictMono._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate | ∀ {X : Type u_1} [inst : PartialOrder X] {n : ℕ}
(s : (CategoryTheory.nerve X).obj (Opposite.op (SimplexCategory.mk (n + 1)))) (i : Fin (n + 1)),
(s ∈ Set.range (CategoryTheory.SimplicialObject.σ (CategoryTheory.nerve X) i)) = (s.obj i.castSucc = s.obj i.succ) | false |
Nat.iSup_le_succ | Mathlib.Data.Nat.Lattice | ∀ {α : Type u_1} [inst : CompleteLattice α] (u : ℕ → α) (n : ℕ),
⨆ k, ⨆ (_ : k ≤ n + 1), u k = (⨆ k, ⨆ (_ : k ≤ n), u k) ⊔ u (n + 1) | true |
ContinuousMap.compMonoidHom'._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_2}
[inst_2 : TopologicalSpace γ] [inst_3 : MulOneClass γ] (g : C(α, β)), ContinuousMap.comp 1 g = 1 | false |
CategoryTheory.Pseudofunctor.ObjectProperty.ι | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat} →
(P : F.ObjectProperty) → [inst_1 : P.IsClosedUnderMapObj] → P.fullsubcategory.StrongTrans F | true |
Order.exists_series_of_le_coheight | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (a : α) {n : ℕ}, ↑n ≤ Order.coheight a → ∃ p, RelSeries.head p = a ∧ p.length = n | true |
Mathlib.Tactic.Bicategory.evalWhiskerRight_cons_of_of | Mathlib.Tactic.CategoryTheory.Bicategory.Normalize | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g h i : a ⟶ b} {j : b ⟶ c} {α : f ≅ g} {η : g ⟶ h}
{ηs : h ⟶ i} {ηs₁ : CategoryTheory.CategoryStruct.comp h j ⟶ CategoryTheory.CategoryStruct.comp i j}
{η₁ : CategoryTheory.CategoryStruct.comp g j ⟶ CategoryTheory.CategoryStruct.comp h j}
{η₂ : CategoryTheory.CategoryStruct.comp g j ⟶ CategoryTheory.CategoryStruct.comp i j}
{η₃ : CategoryTheory.CategoryStruct.comp f j ⟶ CategoryTheory.CategoryStruct.comp i j},
CategoryTheory.Bicategory.whiskerRight ηs j = ηs₁ →
CategoryTheory.Bicategory.whiskerRight η j = η₁ →
CategoryTheory.CategoryStruct.comp η₁ ηs₁ = η₂ →
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRightIso α j).hom η₂ = η₃ →
CategoryTheory.Bicategory.whiskerRight
(CategoryTheory.CategoryStruct.comp α.hom (CategoryTheory.CategoryStruct.comp η ηs)) j =
η₃ | true |
MeasureTheory.tendsto_of_uncrossing_lt_top | Mathlib.Probability.Martingale.Convergence | ∀ {Ω : Type u_1} {f : ℕ → Ω → ℝ} {ω : Ω},
Filter.liminf (fun n => ↑‖f n ω‖₊) Filter.atTop < ⊤ →
(∀ (a b : ℚ), a < b → MeasureTheory.upcrossings (↑a) (↑b) f ω < ⊤) →
∃ c, Filter.Tendsto (fun n => f n ω) Filter.atTop (nhds c) | true |
Mathlib.Tactic.RingNF.RingMode.recOn | Mathlib.Tactic.Ring.RingNF | {motive : Mathlib.Tactic.RingNF.RingMode → Sort u} →
(t : Mathlib.Tactic.RingNF.RingMode) →
motive Mathlib.Tactic.RingNF.RingMode.SOP → motive Mathlib.Tactic.RingNF.RingMode.raw → motive t | false |
Algebra.Generators.toExtendScalars._proof_2 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_4} {S : Type u_3} {ι : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T]
(P : Algebra.Generators R T ι) (i : ι),
(MvPolynomial.aeval (Algebra.Generators.extendScalars S P).val) (MvPolynomial.X i) = (algebraMap T T) (P.val i) | false |
Polynomial.natDegree_pow_X_add_C | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] [Nontrivial R] (n : ℕ) (r : R), ((Polynomial.X + Polynomial.C r) ^ n).natDegree = n | true |
Substring.Raw.ValidFor.isEmpty | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {s : Substring.Raw}, Substring.Raw.ValidFor l m r s → (s.isEmpty = true ↔ m = []) | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.step_intermediateZip.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ β₁ : Type u_1} [inst : Std.Iterator α₁ Id β₁] {it₁ : Std.Iter β₁} (motive : it₁.Step → Sort u_2)
(it₁' : Std.Iter β₁) (hp : it₁.IsPlausibleStep (Std.IterStep.skip it₁'))
(h_1 :
(it₁' : Std.Iter β₁) →
(out : β₁) → (hp : it₁.IsPlausibleStep (Std.IterStep.yield it₁' out)) → motive ⟨Std.IterStep.yield it₁' out, hp⟩)
(h_2 :
(it₁' : Std.Iter β₁) → (hp : it₁.IsPlausibleStep (Std.IterStep.skip it₁')) → motive ⟨Std.IterStep.skip it₁', hp⟩)
(h_3 : (hp : it₁.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, hp⟩),
(match ⟨Std.IterStep.skip it₁', hp⟩ with
| ⟨Std.IterStep.yield it₁' out, hp⟩ => h_1 it₁' out hp
| ⟨Std.IterStep.skip it₁', hp⟩ => h_2 it₁' hp
| ⟨Std.IterStep.done, hp⟩ => h_3 hp) =
h_2 it₁' hp | true |
Batteries.instOrientedCmpCompareOnOfOrientedOrd | Batteries.Classes.Deprecated | ∀ {β : Type u_1} {α : Sort u_2} [inst : Ord β] [Batteries.OrientedOrd β] (f : α → β),
Batteries.OrientedCmp (compareOn f) | true |
PFun.prodMap_id_id | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2}, (PFun.id α).prodMap (PFun.id β) = PFun.id (α × β) | true |
ModularForm.mk.noConfusion | Mathlib.NumberTheory.ModularForms.Basic | {Γ : Subgroup (GL (Fin 2) ℝ)} →
{k : ℤ} →
{P : Sort u} →
{toSlashInvariantForm : SlashInvariantForm Γ k} →
{holo' : MDiff ⇑toSlashInvariantForm} →
{bdd_at_cusps' : ∀ {c : OnePoint ℝ}, IsCusp c Γ → c.IsBoundedAt toSlashInvariantForm.toFun k} →
{toSlashInvariantForm' : SlashInvariantForm Γ k} →
{holo'' : MDiff ⇑toSlashInvariantForm'} →
{bdd_at_cusps'' : ∀ {c : OnePoint ℝ}, IsCusp c Γ → c.IsBoundedAt toSlashInvariantForm'.toFun k} →
{ toSlashInvariantForm := toSlashInvariantForm, holo' := holo', bdd_at_cusps' := bdd_at_cusps' } =
{ toSlashInvariantForm := toSlashInvariantForm', holo' := holo'',
bdd_at_cusps' := bdd_at_cusps'' } →
(toSlashInvariantForm ≍ toSlashInvariantForm' → P) → P | false |
Fin.foldr_congr | Init.Data.Fin.Fold | ∀ {α : Sort u_1} {n k : ℕ} (w : n = k) (f : Fin n → α → α), Fin.foldr n f = Fin.foldr k fun i => f (Fin.cast ⋯ i) | true |
topologicalGroup_of_lieGroup | Mathlib.Geometry.Manifold.Algebra.LieGroup | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (n : WithTop ℕ∞)
{G : Type u_4} [inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Group G] [LieGroup I n G],
IsTopologicalGroup G | true |
_private.Mathlib.Data.Finset.Prod.0.Finset.subset_product_image_fst._simp_1_1 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | false |
Finset.prod_bij' | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : CommMonoid M] {s : Finset ι} {t : Finset κ} {f : ι → M}
{g : κ → M} (i : (a : ι) → a ∈ s → κ) (j : (a : κ) → a ∈ t → ι) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t)
(hj : ∀ (a : κ) (ha : a ∈ t), j a ha ∈ s),
(∀ (a : ι) (ha : a ∈ s), j (i a ha) ⋯ = a) →
(∀ (a : κ) (ha : a ∈ t), i (j a ha) ⋯ = a) →
(∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) → ∏ x ∈ s, f x = ∏ x ∈ t, g x | true |
Lean.Lsp.DependencyBuildMode._sizeOf_inst | Lean.Data.Lsp.Extra | SizeOf Lean.Lsp.DependencyBuildMode | false |
CategoryTheory.Limits.Trident.ι | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : J → (X ⟶ Y)} →
(t : CategoryTheory.Limits.Trident f) →
((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingParallelFamily J)).obj t.pt).obj
CategoryTheory.Limits.WalkingParallelFamily.zero ⟶
(CategoryTheory.Limits.parallelFamily f).obj CategoryTheory.Limits.WalkingParallelFamily.zero | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_toInt_lt_neg_two_pow_iff._proof_1_8 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
((w + 1) * 2 - 2 < (w + 1) * 2 - 1 → 2 ^ ((w + 1) * 2 - 2) < 2 ^ ((w + 1) * 2 - 1)) →
x.toInt * y.toInt ≤ 2 ^ ((w + 1) * 2 - 2) → ¬x.toInt * y.toInt * 2 < 2 ^ ((w + 1) * 2 - 1) * 2 → False | false |
AlgebraicGeometry.Scheme.OpenCover.finiteSubcover_X | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [H : CompactSpace ↥X] (x : ↥⋯.choose),
𝒰.finiteSubcover.X x = 𝒰.X (AlgebraicGeometry.Scheme.Cover.idx 𝒰 ↑x) | true |
Lean.RBNode.leaf | Lean.Data.RBMap | {α : Type u} → {β : α → Type v} → Lean.RBNode α β | true |
Multiset.countP_congr | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} {s s' : Multiset α},
s = s' →
∀ {p p' : α → Prop} [inst : DecidablePred p] [inst_1 : DecidablePred p'],
(∀ x ∈ s, p x = p' x) → Multiset.countP p s = Multiset.countP p' s' | true |
instToStringFloat32 | Init.Data.Float32 | ToString Float32 | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput.lhs | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput aig len → aig.RefVec len | true |
Lean.Server.RequestHandler._sizeOf_inst | Lean.Server.Requests | SizeOf Lean.Server.RequestHandler | false |
BddOrd.instConcreteCategoryBoundedOrderHomCarrier._proof_2 | Mathlib.Order.Category.BddOrd | ∀ {X Y : BddOrd} (f : X ⟶ Y), { hom' := f.hom' } = f | false |
Set.coe_snd_biUnionEqSigmaOfDisjoint | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_5} {ι : Type u_6} {s : Set ι} {f : ι → Set α} (h : s.PairwiseDisjoint f) (x : ↑(⋃ i ∈ s, f i)),
↑((Set.biUnionEqSigmaOfDisjoint h) x).snd = ↑x | true |
Quaternion.instNormedAddCommGroupReal._proof_3 | Mathlib.Analysis.Quaternion | ∀ (x y : Quaternion ℝ) (r : ℝ), inner ℝ (r • x) y = (starRingEnd ℝ) r * inner ℝ x y | false |
Aesop.TraceOption.mk.noConfusion | Aesop.Tracing | {P : Sort u} →
{traceClass : Lean.Name} →
{option : Lean.Option Bool} →
{traceClass' : Lean.Name} →
{option' : Lean.Option Bool} →
{ traceClass := traceClass, option := option } = { traceClass := traceClass', option := option' } →
(traceClass = traceClass' → option = option' → P) → P | false |
MvPolynomial.killCompl_monomial_eq_monomial_comapDomain_of_subset | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] {f : σ → τ} (hf : Function.Injective f)
{s : τ →₀ ℕ} (c : R),
↑s.support ⊆ Set.range f →
(MvPolynomial.killCompl hf) ((MvPolynomial.monomial s) c) = (MvPolynomial.monomial (Finsupp.comapDomain f s ⋯)) c | true |
CategoryTheory.Functor.Elements.initialOfCorepresentableBy | Mathlib.CategoryTheory.Elements | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C (Type u_1)} → {X : C} → F.CorepresentableBy X → F.Elements | true |
torusMap_zero_radius | Mathlib.MeasureTheory.Integral.TorusIntegral | ∀ {n : ℕ} (c : Fin n → ℂ), torusMap c 0 = Function.const (Fin n → ℝ) c | true |
Ordinal.inductionOnWellOrder | Mathlib.SetTheory.Ordinal.Basic | ∀ {motive : Ordinal.{u_1} → Prop} (o : Ordinal.{u_1}),
(∀ (α : Type u_1) [inst : LinearOrder α] [inst_1 : WellFoundedLT α], motive (Ordinal.type fun x1 x2 => x1 < x2)) →
motive o | true |
MeasureTheory.MemLp.exists_boundedContinuous_integral_rpow_sub_le | Mathlib.MeasureTheory.Function.ContinuousMapDense | ∀ {α : Type u_1} [inst : TopologicalSpace α] [NormalSpace α] [inst_2 : MeasurableSpace α] [BorelSpace α] {E : Type u_2}
[inst_4 : NormedAddCommGroup E] {μ : MeasureTheory.Measure α} [NormedSpace ℝ E] [μ.WeaklyRegular] {p : ℝ},
0 < p →
∀ {f : α → E},
MeasureTheory.MemLp f (ENNReal.ofReal p) μ →
∀ {ε : ℝ}, 0 < ε → ∃ g, ∫ (x : α), ‖f x - g x‖ ^ p ∂μ ≤ ε ∧ MeasureTheory.MemLp (⇑g) (ENNReal.ofReal p) μ | true |
ContinuousOpenMap._sizeOf_inst | Mathlib.Topology.Hom.Open | (α : Type u_6) →
(β : Type u_7) →
{inst : TopologicalSpace α} → {inst_1 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → SizeOf (α →CO β) | false |
indicator_ae_eq_zero_of_restrict_ae_eq_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} {f : α → β}
[inst_1 : Zero β], MeasurableSet s → f =ᵐ[μ.restrict s] 0 → s.indicator f =ᵐ[μ] 0 | true |
AlgebraicGeometry.pointEquivClosedPoint._proof_4 | Mathlib.AlgebraicGeometry.AlgClosed.Basic | ∀ {X : AlgebraicGeometry.Scheme} {K : Type u_1} [inst : Field K] [inst_1 : IsAlgClosed K]
(f : X ⟶ AlgebraicGeometry.Spec (CommRingCat.of K)) [inst_2 : AlgebraicGeometry.LocallyOfFiniteType f]
(x : ↑(closedPoints ↥X)),
(fun p => ⟨↑p (IsLocalRing.closedPoint K), ⋯⟩) ((fun x => ⟨AlgebraicGeometry.pointOfClosedPoint f ↑x ⋯, ⋯⟩) x) = x | false |
CategoryTheory.CommMon.X | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommMon C → C | true |
CategoryTheory.Limits.WalkingMulticospan.ctorElim | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u} →
(ctorIdx : ℕ) →
(t : CategoryTheory.Limits.WalkingMulticospan J) →
ctorIdx = t.ctorIdx → CategoryTheory.Limits.WalkingMulticospan.ctorElimType ctorIdx → motive t | false |
Lean.Doc.Block.brecOn_7 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1} →
{motive_5 : List (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_6 : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_7 : List (Lean.Doc.Block i b) → Sort u_1} →
{motive_8 : Lean.Doc.ListItem (Lean.Doc.Block i b) → Sort u_1} →
{motive_9 : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b) → Sort u_1} →
(t : Lean.Doc.ListItem (Lean.Doc.Block i b)) →
((t : Lean.Doc.Block i b) → t.below → motive_1 t) →
((t : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
Lean.Doc.Block.below_1 t → motive_2 t) →
((t : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) →
Lean.Doc.Block.below_2 t → motive_3 t) →
((t : Array (Lean.Doc.Block i b)) → Lean.Doc.Block.below_3 t → motive_4 t) →
((t : List (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
Lean.Doc.Block.below_4 t → motive_5 t) →
((t : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) →
Lean.Doc.Block.below_5 t → motive_6 t) →
((t : List (Lean.Doc.Block i b)) → Lean.Doc.Block.below_6 t → motive_7 t) →
((t : Lean.Doc.ListItem (Lean.Doc.Block i b)) →
Lean.Doc.Block.below_7 t → motive_8 t) →
((t : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) →
Lean.Doc.Block.below_8 t → motive_9 t) →
motive_8 t | false |
AddMonoidAlgebra.single_mem_grade | Mathlib.Algebra.MonoidAlgebra.Grading | ∀ {M : Type u_1} {R : Type u_4} [inst : CommSemiring R] (i : M) (r : R),
AddMonoidAlgebra.single i r ∈ AddMonoidAlgebra.grade R i | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
MeasureTheory.LocallyIntegrable.mono_measure._gcongr_1 | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ ν : MeasureTheory.Measure X},
ν ≤ μ → MeasureTheory.LocallyIntegrable f μ → MeasureTheory.LocallyIntegrable f ν | false |
TopCat.instAbelianPresheaf._proof_4 | Mathlib.Topology.Sheaves.Abelian | ∀ {X : TopCat} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C],
autoParam
(∀ (P Q R : TopCat.Presheaf C X) (f : P ⟶ Q) (g g' : Q ⟶ R),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f g')
CategoryTheory.Preadditive.comp_add._autoParam | false |
Equiv.invFun | Mathlib.Logic.Equiv.Defs | {α : Sort u_1} → {β : Sort u_2} → α ≃ β → β → α | true |
Mathlib.TacticAnalysis.Pass._sizeOf_inst | Mathlib.Tactic.TacticAnalysis | SizeOf Mathlib.TacticAnalysis.Pass | false |
Matrix.vecMul_empty | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {n' : Type uₙ} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype n'] (v : n' → α)
(B : Matrix n' (Fin 0) α), Matrix.vecMul v B = ![] | true |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_24 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} (hl : l ≠ []), l.getLast ⋯ ∈ l | false |
NumberField.basisOfFractionalIdeal._proof_2 | Mathlib.NumberTheory.NumberField.FractionalIdeal | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
LinearMap.CompatibleSMul (↥↑↑I) K ℤ (NumberField.RingOfIntegers K) | false |
AddUnits.leftOfAdd.eq_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (a b : M) (hu : a + b = ↑u) (hc : AddCommute a b),
u.leftOfAdd a b hu hc = { val := a, neg := b + ↑(-u), val_neg := ⋯, neg_val := ⋯ } | true |
Subring.instField._proof_13 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] (x : ℚ≥0) (x_1 : ↥(Subring.center K)), ↑x * x_1 = ↑x * x_1 | false |
List.prod_inv_reverse | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : Group G] (L : List G), L.prod⁻¹ = (List.map (fun x => x⁻¹) L).reverse.prod | true |
Equiv.prodAssoc.match_3 | Mathlib.Logic.Equiv.Prod | ∀ (α : Type u_1) (β : Type u_3) (γ : Type u_2) (motive : α × β × γ → Prop) (x : α × β × γ),
(∀ (fst : α) (fst_1 : β) (snd : γ), motive (fst, fst_1, snd)) → motive x | false |
Ordinal.CNF.rec_pos | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (b : Ordinal.{u_2}) {o : Ordinal.{u_2}} {C : Ordinal.{u_2} → Sort u_1} (ho : o ≠ 0) (H0 : C 0)
(H : (o : Ordinal.{u_2}) → o ≠ 0 → C (o % b ^ Ordinal.log b o) → C o),
Ordinal.CNF.rec b H0 H o = H o ho (Ordinal.CNF.rec b H0 H (o % b ^ Ordinal.log b o)) | true |
Bundle.TotalSpace.toProd._proof_1 | Mathlib.Data.Bundle | ∀ (B : Type u_1) (F : Type u_2), Function.LeftInverse (fun x => ⟨x.1, x.2⟩) fun x => (x.proj, x.snd) | false |
Affine.Simplex.isCompact_closedInterior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_4} {V : Type u_5} {P : Type u_6} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [OrderClosedTopology 𝕜] [CompactIccSpace 𝕜] [ContinuousAdd 𝕜] [inst_7 : AddCommGroup V]
[inst_8 : TopologicalSpace V] [IsTopologicalAddGroup V] [inst_10 : Module 𝕜 V] [ContinuousSMul 𝕜 V]
[inst_12 : AddTorsor V P] [inst_13 : TopologicalSpace P] [IsTopologicalAddTorsor P] {n : ℕ}
(s : Affine.Simplex 𝕜 P n), IsCompact s.closedInterior | true |
_private.Mathlib.Algebra.BigOperators.ModEq.0.Int.prod_modEq_single._simp_1_1 | Mathlib.Algebra.BigOperators.ModEq | ∀ (a b : ℤ) (c : ℕ), (a ≡ b [ZMOD ↑c]) = (↑a = ↑b) | false |
CategoryTheory.Comma.unopFunctor_map | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) {X Y : CategoryTheory.Comma L.op R.op} (f : X ⟶ Y),
(CategoryTheory.Comma.unopFunctor L R).map f = Opposite.op { left := f.right.unop, right := f.left.unop, w := ⋯ } | true |
AddCommMonCat.recOn | Mathlib.Algebra.Category.MonCat.Basic | {motive : AddCommMonCat → Sort u_1} →
(t : AddCommMonCat) →
((carrier : Type u) → [str : AddCommMonoid carrier] → motive { carrier := carrier, str := str }) → motive t | false |
Subfield.sInf_toSubring | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} [inst : DivisionRing K] (s : Set (Subfield K)), (sInf s).toSubring = ⨅ t ∈ s, t.toSubring | true |
WeierstrassCurve.Projective.negDblY_eq' | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} {P : Fin 3 → R},
W'.Equation P →
W'.negDblY P * P 2 ^ 2 =
-(MvPolynomial.eval P) W'.polynomialX *
((MvPolynomial.eval P) W'.polynomialX ^ 2 -
W'.a₁ * (MvPolynomial.eval P) W'.polynomialX * P 2 * (P 1 - W'.negY P) -
W'.a₂ * P 2 ^ 2 * (P 1 - W'.negY P) ^ 2 -
2 * P 0 * P 2 * (P 1 - W'.negY P) ^ 2 -
P 0 * P 2 * (P 1 - W'.negY P) ^ 2) +
P 1 * P 2 ^ 2 * (P 1 - W'.negY P) ^ 3 | true |
himp_iff_imp._simp_1 | Mathlib.Order.Heyting.Basic | ∀ (p q : Prop), p ⇨ q = (p → q) | false |
_private.Mathlib.Probability.Distributions.SetBernoulli.0.ProbabilityTheory.setBernoulli_ae_subset._simp_1_2 | Mathlib.Probability.Distributions.SetBernoulli | ∀ {α : Type u_1} {s t : Set α}, (¬s ⊆ t) = ∃ x ∈ s, x ∉ t | false |
HasFiniteFPowerSeriesOnBall.rec | Mathlib.Analysis.Analytic.CPolynomialDef | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
{f : E → F} →
{p : FormalMultilinearSeries 𝕜 E F} →
{x : E} →
{n : ℕ} →
{r : ENNReal} →
{motive : HasFiniteFPowerSeriesOnBall f p x n r → Sort u} →
((toHasFPowerSeriesOnBall : HasFPowerSeriesOnBall f p x r) →
(finite : ∀ (m : ℕ), n ≤ m → p m = 0) → motive ⋯) →
(t : HasFiniteFPowerSeriesOnBall f p x n r) → motive t | false |
Set.biUnion_diff_biUnion_eq | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {ι : Type u_2} {s t : Set ι} {f : ι → Set α},
(s ∪ t).PairwiseDisjoint f → (⋃ i ∈ s, f i) \ ⋃ i ∈ t, f i = ⋃ i ∈ s \ t, f i | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Images.0.CategoryTheory.Limits.image.map_id._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | false |
_private.Mathlib.Data.Finset.NAry.0.Finset.mem_image₂._simp_1_2 | Mathlib.Data.Finset.NAry | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
Mathlib.Tactic.WLOGResult.reductionGoal | Mathlib.Tactic.WLOG | Mathlib.Tactic.WLOGResult → Lean.MVarId | true |
NumberField.RingOfIntegers.mapAlgEquiv._proof_1 | Mathlib.NumberTheory.NumberField.Basic | ∀ {k : Type u_2} {K : Type u_3} {L : Type u_4} {E : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra k K] [inst_4 : Algebra k L] [inst_5 : EquivLike E K L] [AlgEquivClass E k K L], AlgHomClass E k K L | false |
Std.HashMap.getD_eq_fallback_of_contains_eq_false | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {a : α}
{fallback : β}, m.contains a = false → m.getD a fallback = fallback | true |
_private.Mathlib.Analysis.InnerProductSpace.Dual.0.InnerProductSpace.toDual._simp_5 | Mathlib.Analysis.InnerProductSpace.Dual | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | false |
CategoryTheory.Functor.isoWhiskerRight_twice | Mathlib.CategoryTheory.Whiskering | ∀ {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] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {H K : CategoryTheory.Functor B C} (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) (α : H ≅ K),
CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.Functor.isoWhiskerRight α F) G =
H.associator F G ≪≫ CategoryTheory.Functor.isoWhiskerRight α (F.comp G) ≪≫ (K.associator F G).symm | true |
ContinuousMap.concat | Mathlib.Topology.ContinuousMap.Interval | {α : Type u_1} →
[inst : LinearOrder α] →
[inst_1 : TopologicalSpace α] →
[OrderTopology α] →
{a b c : α} →
[Fact (a ≤ b)] →
[Fact (b ≤ c)] →
{E : Type u_2} →
[inst_5 : TopologicalSpace E] → C(↑(Set.Icc a b), E) → C(↑(Set.Icc b c), E) → C(↑(Set.Icc a c), E) | true |
Tactic.mkComp._sunfold | Mathlib.Tactic.HigherOrder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | false |
GaussianInt.abs_natCast_norm | Mathlib.NumberTheory.Zsqrtd.GaussianInt | ∀ (x : GaussianInt), ↑(Zsqrtd.norm x).natAbs = Zsqrtd.norm x | true |
StarAlgEquiv.trans_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} {C : Type u_5} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A]
[inst_3 : Mul B] [inst_4 : SMul R A] [inst_5 : SMul R B] [inst_6 : Star A] [inst_7 : Star B] [inst_8 : Add C]
[inst_9 : Mul C] [inst_10 : SMul R C] [inst_11 : Star C] (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) (x : A),
(e₁.trans e₂) x = e₂ (e₁ x) | true |
NNRat.instIsScalarTowerRight | Mathlib.Algebra.Ring.Action.Rat | ∀ {R : Type u_1} [inst : DivisionSemiring R], IsScalarTower ℚ≥0 R R | true |
Id.instLawfulMonadLiftTOfLawfulMonad | Init.Control.Lawful.MonadLift.Instances | ∀ {m : Type u → Type v} [inst : Monad m] [LawfulMonad m], LawfulMonadLiftT Id m | true |
DistribLattice.ctorIdx | Mathlib.Order.Lattice | {α : Type u_1} → DistribLattice α → ℕ | false |
RelIso.instGroup._proof_2 | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (n : ℕ) (x : r ≃r r), npowRecAuto (n + 1) x = npowRecAuto n x * x | false |
Std.Tactic.BVDecide.BVExpr.replicate.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w w' : ℕ} (n : ℕ) (expr : Std.Tactic.BVDecide.BVExpr w) (h : w' = w * n) (w_1 n_1 : ℕ)
(expr_1 : Std.Tactic.BVDecide.BVExpr w_1) (h_1 : w' = w_1 * n_1),
(Std.Tactic.BVDecide.BVExpr.replicate n expr h = Std.Tactic.BVDecide.BVExpr.replicate n_1 expr_1 h_1) =
(w = w_1 ∧ n = n_1 ∧ expr ≍ expr_1) | true |
Prod.map_iterate | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → α) (g : β → β) (n : ℕ), (Prod.map f g)^[n] = Prod.map f^[n] g^[n] | true |
String.Legacy.Iterator.s | Init.Data.String.Iterator | String.Legacy.Iterator → String | true |
WeierstrassCurve.Projective.addXYZ_Z | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (P Q : Fin 3 → R), W'.addXYZ P Q 2 = W'.addZ P Q | true |
PseudoMetric.coe_le_coe | Mathlib.Topology.MetricSpace.BundledFun | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero R] [inst_1 : Add R] [inst_2 : LE R] {d d' : PseudoMetric X R},
⇑d ≤ ⇑d' ↔ d ≤ d' | true |
AlgebraicGeometry.morphismRestrictStalkMap._proof_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opens) (x : ↥↑((TopologicalSpace.Opens.map f.base).obj U)),
Inseparable (↑((f ∣_ U) x)) (f ↑x) | false |
CategoryTheory.NatTrans.naturality | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (self : CategoryTheory.NatTrans F G) ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (self.app Y) = CategoryTheory.CategoryStruct.comp (self.app X) (G.map f) | true |
_private.Mathlib.Data.Finset.Union.0.Finset.bind_toFinset._simp_1_2 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type v} {b : β} {s : Multiset α} {f : α → Multiset β}, (b ∈ s.bind f) = ∃ a ∈ s, b ∈ f a | false |
FreeSimplexQuiver.homRel.recOn | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {motive : ⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ → (a a_1 : X ⟶ Y) → FreeSimplexQuiver.homRel a a_1 → Prop}
⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ {a a_1 : X ⟶ Y} (t : FreeSimplexQuiver.homRel a a_1),
(∀ {n : ℕ} {i j : Fin (n + 2)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ j.castSucc),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : j.castSucc < i),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.castSucc)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i)))
⋯) →
(∀ {n : ℕ} {i j : Fin (n + 1)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
⋯) →
motive a a_1 t | false |
conditionallyCompleteLatticeOfsInf.eq_1 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (x : Type u_5) [x_1 : PartialOrder x] [x_2 : InfSet x] (x_3 : ∀ (a b : x), BddAbove {a, b})
(x_4 : ∀ (a b : x), BddBelow {a, b}) (isLUB_sSup : ∀ (s : Set x), BddBelow s → s.Nonempty → IsGLB s (sInf s)),
conditionallyCompleteLatticeOfsInf x x_3 x_4 isLUB_sSup =
{ toLattice := Lattice.ofIsLUBofIsGLB (fun a b => sInf (upperBounds {a, b})) (fun a b => sInf {a, b}) ⋯ ⋯,
sSup := fun s => sInf (upperBounds s), toInfSet := x_2, isLUB_csSup := ⋯, isGLB_csInf := ⋯ } | true |
GrpCat.toAddGrp._proof_1 | Mathlib.Algebra.Category.Grp.EquivalenceGroupAddGroup | ∀ (X : GrpCat),
AddGrpCat.ofHom (MonoidHom.toAdditive (GrpCat.Hom.hom (CategoryTheory.CategoryStruct.id X))) =
CategoryTheory.CategoryStruct.id (AddGrpCat.of (Additive ↑X)) | false |
CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalFin | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | (l : ℕ) →
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore (Fin (l + 1))
(fun r => ComplexShape.spectralSequenceFin l (r, 1 - r)) 2 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.