tasksource/leandojo huggingface dataset:
Theorem: Finset.aemeasurable_prod
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [← Finset.prod_apply] using s.aemeasurable_prod' hf
state_before: M : Type u_3
ι : Type u_1
α : Type u_2
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f : ι → α → M
s : Finset ι
hf : ∀ (i : ι), i ∈ s → AEMeasurable (f i)
⊢ AEMeasurable fun a => ∏ i in s, f i a
Theorem: Submodule.map_liftQ
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rintro _ ⟨⟨x⟩, hxq, rfl⟩
state_before: R : Type u_1
M : Type u_3
r : R
x y : M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
p p' : Submodule R M
R₂ : Type u_2
M₂ : Type u_4
inst✝³ : Ring R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
q✝ : Submodule R₂ M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
q : Submodule R (M ⧸ p)
⊢ map (liftQ p f h) q ≤ map f (comap (mkQ p) q)

tactic: exact ⟨x, hxq, rfl⟩
state_before: case intro.mk.intro
R : Type u_1
M : Type u_3
r : R
x✝ y : M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
p p' : Submodule R M
R₂ : Type u_2
M₂ : Type u_4
inst✝³ : Ring R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
q✝ : Submodule R₂ M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
q : Submodule R (M ⧸ p)
w✝ : M ⧸ p
x : M
hxq : Quot.mk Setoid.r x ∈ ↑q
⊢ ↑(liftQ p f h) (Quot.mk Setoid.r x) ∈ map f (comap (mkQ p) q)

tactic: rintro _ ⟨x, hxq, rfl⟩
state_before: R : Type u_1
M : Type u_3
r : R
x y : M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
p p' : Submodule R M
R₂ : Type u_2
M₂ : Type u_4
inst✝³ : Ring R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
q✝ : Submodule R₂ M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
q : Submodule R (M ⧸ p)
⊢ map f (comap (mkQ p) q) ≤ map (liftQ p f h) q

tactic: exact ⟨Quotient.mk x, hxq, rfl⟩
state_before: case intro.intro
R : Type u_1
M : Type u_3
r : R
x✝ y : M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
p p' : Submodule R M
R₂ : Type u_2
M₂ : Type u_4
inst✝³ : Ring R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
q✝ : Submodule R₂ M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
q : Submodule R (M ⧸ p)
x : M
hxq : x ∈ ↑(comap (mkQ p) q)
⊢ ↑f x ∈ map (liftQ p f h) q
Theorem: Polynomial.leadingCoeff_X_pow_add_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: nontriviality R
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
n : ℕ
hn : 0 < n
r : R
⊢ leadingCoeff (X ^ n + ↑C r) = 1

tactic: rw [leadingCoeff, natDegree_X_pow_add_C, coeff_add, coeff_X_pow_self, coeff_C,
  if_neg (pos_iff_ne_zero.mp hn), add_zero]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
n : ℕ
hn : 0 < n
r : R
✝ : Nontrivial R
⊢ leadingCoeff (X ^ n + ↑C r) = 1
Theorem: PreErgodic.prob_eq_zero_or_one
File: Mathlib/Dynamics/Ergodic/Ergodic.lean

tactic: simpa [hs] using hf.measure_self_or_compl_eq_zero hs hs'
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : MeasureTheory.Measure α
inst✝ : IsProbabilityMeasure μ
hf : PreErgodic f
hs : MeasurableSet s
hs' : f ⁻¹' s = s
⊢ ↑↑μ s = 0 ∨ ↑↑μ s = 1
Theorem: Polynomial.iterate_derivative_X_pow_eq_nat_cast_mul
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: induction' k with k ih
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
n k : ℕ
⊢ (↑derivative^[k]) (X ^ n) = ↑(Nat.descFactorial n k) * X ^ (n - k)

tactic: erw [Function.iterate_zero_apply, tsub_zero, Nat.descFactorial_zero, Nat.cast_one, one_mul]
state_before: case zero
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
n : ℕ
⊢ (↑derivative^[Nat.zero]) (X ^ n) = ↑(Nat.descFactorial n Nat.zero) * X ^ (n - Nat.zero)

tactic: rw [Function.iterate_succ_apply', ih, derivative_nat_cast_mul, derivative_X_pow, C_eq_nat_cast,
  Nat.succ_eq_add_one, Nat.descFactorial_succ, Nat.sub_sub, Nat.cast_mul]
state_before: case succ
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
n k : ℕ
ih : (↑derivative^[k]) (X ^ n) = ↑(Nat.descFactorial n k) * X ^ (n - k)
⊢ (↑derivative^[Nat.succ k]) (X ^ n) = ↑(Nat.descFactorial n (Nat.succ k)) * X ^ (n - Nat.succ k)

tactic: simp [mul_comm, mul_assoc, mul_left_comm]
state_before: case succ
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
n k : ℕ
ih : (↑derivative^[k]) (X ^ n) = ↑(Nat.descFactorial n k) * X ^ (n - k)
⊢ ↑(Nat.descFactorial n k) * (↑(n - k) * X ^ (n - (k + 1))) = ↑(n - k) * ↑(Nat.descFactorial n k) * X ^ (n - (k + 1))
Theorem: AffineSubspace.Parallel.direction_eq
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rcases h with ⟨v, rfl⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s₁ s₂ : AffineSubspace k P
h : s₁ ∥ s₂
⊢ direction s₁ = direction s₂

tactic: simp
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s₁ : AffineSubspace k P
v : V
⊢ direction s₁ = direction (map (↑(constVAdd k P v)) s₁)
Theorem: Order.Ideal.PrimePair.I_isPrime
File: Mathlib/Order/PrimeIdeal.lean

tactic: rw [IF.compl_I_eq_F]
state_before: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
src✝ : IsProper IF.I := I_isProper IF
⊢ IsPFilter (↑IF.Iᶜ)

tactic: exact IF.F.isPFilter
state_before: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
src✝ : IsProper IF.I := I_isProper IF
⊢ IsPFilter ↑IF.F
Theorem: RelHomClass.acc
File: Mathlib/Order/RelIso/Basic.lean

tactic: generalize h : f a = b
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.9632
δ : Type ?u.9635
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_1
inst✝ : RelHomClass F r s
f : F
a : α
⊢ Acc s (↑f a) → Acc r a

tactic: intro ac
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.9632
δ : Type ?u.9635
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_1
inst✝ : RelHomClass F r s
f : F
a : α
b : β
h : ↑f a = b
⊢ Acc s b → Acc r a

tactic: induction' ac with _ H IH generalizing a
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.9632
δ : Type ?u.9635
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_1
inst✝ : RelHomClass F r s
f : F
a : α
b : β
h : ↑f a = b
ac : Acc s b
⊢ Acc r a

tactic: subst h
state_before: case intro
α : Type u_2
β : Type u_3
γ : Type ?u.9632
δ : Type ?u.9635
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_1
inst✝ : RelHomClass F r s
f : F
a✝ : α
b : β
h✝ : ↑f a✝ = b
x✝ : β
H : ∀ (y : β), s y x✝ → Acc s y
IH : ∀ (y : β), s y x✝ → ∀ (a : α), ↑f a = y → Acc r a
a : α
h : ↑f a = x✝
⊢ Acc r a

tactic: exact ⟨_, fun a' h => IH (f a') (map_rel f h) _ rfl⟩
state_before: case intro
α : Type u_2
β : Type u_3
γ : Type ?u.9632
δ : Type ?u.9635
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
F : Type u_1
inst✝ : RelHomClass F r s
f : F
a✝ : α
b : β
h : ↑f a✝ = b
a : α
H : ∀ (y : β), s y (↑f a) → Acc s y
IH : ∀ (y : β), s y (↑f a) → ∀ (a : α), ↑f a = y → Acc r a
⊢ Acc r a
Theorem: RatFunc.mk_eq_localization_mk
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [mk_def_of_ne, Localization.mk_eq_mk'] <;> exact hq
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p q : K[X]
hq : q ≠ 0
⊢ RatFunc.mk p q = { toFractionRing := Localization.mk p { val := q, property := (_ : q ∈ K[X]⁰) } }
Theorem: orthogonalProjection_eq_linear_proj
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: have : IsCompl K Kᗮ := Submodule.isCompl_orthogonal_of_completeSpace
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.822903
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
x : E
⊢ ↑(orthogonalProjection K) x = ↑(Submodule.linearProjOfIsCompl K Kᗮ (_ : IsCompl K Kᗮ)) x

tactic: conv_lhs => rw [← Submodule.linear_proj_add_linearProjOfIsCompl_eq_self this x]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.822903
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
x : E
this : IsCompl K Kᗮ
⊢ ↑(orthogonalProjection K) x = ↑(Submodule.linearProjOfIsCompl K Kᗮ (_ : IsCompl K Kᗮ)) x

tactic: rw [map_add, orthogonalProjection_mem_subspace_eq_self,
  orthogonalProjection_mem_subspace_orthogonalComplement_eq_zero (Submodule.coe_mem _), add_zero]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.822903
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
x : E
this : IsCompl K Kᗮ
⊢ ↑(orthogonalProjection K)
      (↑(↑(Submodule.linearProjOfIsCompl K Kᗮ this) x) +
        ↑(↑(Submodule.linearProjOfIsCompl Kᗮ K (_ : IsCompl Kᗮ K)) x)) =
    ↑(Submodule.linearProjOfIsCompl K Kᗮ (_ : IsCompl K Kᗮ)) x
Theorem: Asymptotics.isLittleO_neg_left
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsLittleO_def]
state_before: α : Type u_1
β : Type ?u.135719
E : Type ?u.135722
F : Type u_3
G : Type ?u.135728
E' : Type u_2
F' : Type ?u.135734
G' : Type ?u.135737
E'' : Type ?u.135740
F'' : Type ?u.135743
G'' : Type ?u.135746
R : Type ?u.135749
R' : Type ?u.135752
𝕜 : Type ?u.135755
𝕜' : Type ?u.135758
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ (fun x => -f' x) =o[l] g ↔ f' =o[l] g

tactic: exact forall₂_congr fun _ _ => isBigOWith_neg_left
state_before: α : Type u_1
β : Type ?u.135719
E : Type ?u.135722
F : Type u_3
G : Type ?u.135728
E' : Type u_2
F' : Type ?u.135734
G' : Type ?u.135737
E'' : Type ?u.135740
F'' : Type ?u.135743
G'' : Type ?u.135746
R : Type ?u.135749
R' : Type ?u.135752
𝕜 : Type ?u.135755
𝕜' : Type ?u.135758
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l (fun x => -f' x) g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f' g
Theorem: String.csize_eq
File: Std/Data/Char.lean

tactic: simp only [csize, Char.utf8Size]
state_before: c : Char
⊢ csize c = 1 ∨ csize c = 2 ∨ csize c = 3 ∨ csize c = 4

tactic: repeat (first | split | (solve | simp))
state_before: c : Char
⊢ UInt32.toNat
        (if c.val ≤ UInt32.ofNatCore 127 Char.utf8Size.proof_1 then UInt32.ofNatCore 1 Char.utf8Size.proof_2
        else
          if c.val ≤ UInt32.ofNatCore 2047 Char.utf8Size.proof_3 then UInt32.ofNatCore 2 Char.utf8Size.proof_4
          else
            if c.val ≤ UInt32.ofNatCore 65535 Char.utf8Size.proof_5 then UInt32.ofNatCore 3 Char.utf8Size.proof_6
            else UInt32.ofNatCore 4 Char.utf8Size.proof_7) =
      1 ∨
    UInt32.toNat
          (if c.val ≤ UInt32.ofNatCore 127 Char.utf8Size.proof_1 then UInt32.ofNatCore 1 Char.utf8Size.proof_2
          else
            if c.val ≤ UInt32.ofNatCore 2047 Char.utf8Size.proof_3 then UInt32.ofNatCore 2 Char.utf8Size.proof_4
            else
              if c.val ≤ UInt32.ofNatCore 65535 Char.utf8Size.proof_5 then UInt32.ofNatCore 3 Char.utf8Size.proof_6
              else UInt32.ofNatCore 4 Char.utf8Size.proof_7) =
        2 ∨
      UInt32.toNat
            (if c.val ≤ UInt32.ofNatCore 127 Char.utf8Size.proof_1 then UInt32.ofNatCore 1 Char.utf8Size.proof_2
            else
              if c.val ≤ UInt32.ofNatCore 2047 Char.utf8Size.proof_3 then UInt32.ofNatCore 2 Char.utf8Size.proof_4
              else
                if c.val ≤ UInt32.ofNatCore 65535 Char.utf8Size.proof_5 then UInt32.ofNatCore 3 Char.utf8Size.proof_6
                else UInt32.ofNatCore 4 Char.utf8Size.proof_7) =
          3 ∨
        UInt32.toNat
            (if c.val ≤ UInt32.ofNatCore 127 Char.utf8Size.proof_1 then UInt32.ofNatCore 1 Char.utf8Size.proof_2
            else
              if c.val ≤ UInt32.ofNatCore 2047 Char.utf8Size.proof_3 then UInt32.ofNatCore 2 Char.utf8Size.proof_4
              else
                if c.val ≤ UInt32.ofNatCore 65535 Char.utf8Size.proof_5 then UInt32.ofNatCore 3 Char.utf8Size.proof_6
                else UInt32.ofNatCore 4 Char.utf8Size.proof_7) =
          4

tactic: simp
state_before: case inr.inr.inr
c : Char
h✝² : ¬c.val ≤ UInt32.ofNatCore 127 Char.utf8Size.proof_1
h✝¹ : ¬c.val ≤ UInt32.ofNatCore 2047 Char.utf8Size.proof_3
h✝ : ¬c.val ≤ UInt32.ofNatCore 65535 Char.utf8Size.proof_5
⊢ UInt32.toNat (UInt32.ofNatCore 4 Char.utf8Size.proof_7) = 1 ∨
    UInt32.toNat (UInt32.ofNatCore 4 Char.utf8Size.proof_7) = 2 ∨
      UInt32.toNat (UInt32.ofNatCore 4 Char.utf8Size.proof_7) = 3 ∨
        UInt32.toNat (UInt32.ofNatCore 4 Char.utf8Size.proof_7) = 4
Theorem: Polynomial.ofFinsupp_sub
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [sub_eq_add_neg, ofFinsupp_add, ofFinsupp_neg]
state_before: R✝ : Type u
a✝ b✝ : R✝
m n : ℕ
inst✝¹ : Semiring R✝
p q : R✝[X]
R : Type u
inst✝ : Ring R
a b : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := a - b } = { toFinsupp := a } - { toFinsupp := b }

tactic: rfl
state_before: R✝ : Type u
a✝ b✝ : R✝
m n : ℕ
inst✝¹ : Semiring R✝
p q : R✝[X]
R : Type u
inst✝ : Ring R
a b : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := a } + -{ toFinsupp := b } = { toFinsupp := a } - { toFinsupp := b }
Theorem: Partrec.cond
File: Mathlib/Computability/Halting.lean

tactic: cases c a <;> simp [ef, eg, encodek]
state_before: α : Type u_1
β : Type ?u.259014
γ : Type ?u.259017
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
c : α → Bool
f g : α →. σ
hc : Computable c
hf : Partrec f
hg : Partrec g
cf : Code
ef : eval cf = fun n => Part.bind ↑(decode n) fun a => Part.map encode (f a)
cg : Code
eg : eval cg = fun n => Part.bind ↑(decode n) fun a => Part.map encode (g a)
a : α
⊢ (Part.bind (eval (bif c a then cf else cg) (encode a)) fun b => ↑(decode (a, b).snd)) = bif c a then f a else g a
Theorem: Finset.filter_filter
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_filter, and_assoc, Bool.decide_and, Bool.decide_coe, Bool.and_eq_true]
state_before: α : Type u_1
β : Type ?u.320195
γ : Type ?u.320198
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s : Finset α
a : α
⊢ a ∈ filter q (filter p s) ↔ a ∈ filter (fun a => p a ∧ q a) s
Theorem: Convex.add_smul
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rintro _ ⟨_, _, ⟨v₁, h₁, rfl⟩, ⟨v₂, h₂, rfl⟩, rfl⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.270732
β : Type ?u.270735
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h_conv : Convex 𝕜 s
p q : 𝕜
hp : 0 ≤ p
hq : 0 ≤ q
⊢ p • s + q • s ⊆ (p + q) • s

tactic: exact h_conv.exists_mem_add_smul_eq h₁ h₂ hp hq
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.270732
β : Type ?u.270735
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h_conv : Convex 𝕜 s
p q : 𝕜
hp : 0 ≤ p
hq : 0 ≤ q
v₁ : E
h₁ : v₁ ∈ s
v₂ : E
h₂ : v₂ ∈ s
⊢ (fun x x_1 => x + x_1) ((fun x => p • x) v₁) ((fun x => q • x) v₂) ∈ (p + q) • s
Theorem: Real.isConjugateExponent_iff
File: Mathlib/Data/Real/ConjugateExponents.lean

tactic: field_simp [H, ne_of_gt (lt_trans zero_lt_one h)]
state_before: p q : ℝ
h : 1 < p
H : q = p / (p - 1)
⊢ 1 / p + 1 / q = 1
Theorem: Nat.add_le_pair
File: Mathlib/Data/Nat/Pairing.lean

tactic: rw [sq, ← min_add_max, add_comm, add_le_add_iff_right]
state_before: m n : ℕ
⊢ m + n ≤ max m n ^ 2 + min m n

tactic: exact le_mul_self _
state_before: m n : ℕ
⊢ max m n ≤ max m n * max m n
Theorem: EReal.tendsto_nhds_bot_iff_real
File: Mathlib/Topology/Instances/EReal.lean

tactic: simp only [true_implies, mem_Iio]
state_before: α✝ : Type ?u.16686
inst✝ : TopologicalSpace α✝
α : Type u_1
m : α → EReal
f : Filter α
⊢ (∀ (i : ℝ), True → ∀ᶠ (x : α) in f, m x ∈ Iio ↑i) ↔ ∀ (x : ℝ), ∀ᶠ (a : α) in f, m a < ↑x
Theorem: ENNReal.tendsto_tsum_compl_atTop_zero
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: lift f to α → ℝ≥0 using ENNReal.ne_top_of_tsum_ne_top hf
state_before: α✝ : Type ?u.262957
β : Type ?u.262960
γ : Type ?u.262963
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_1
f : α → ℝ≥0∞
hf : (∑' (x : α), f x) ≠ ⊤
⊢ Tendsto (fun s => ∑' (b : { x // ¬x ∈ s }), f ↑b) atTop (𝓝 0)

tactic: convert ENNReal.tendsto_coe.2 (NNReal.tendsto_tsum_compl_atTop_zero f)
state_before: case intro
α✝ : Type ?u.262957
β : Type ?u.262960
γ : Type ?u.262963
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_1
f : α → ℝ≥0
hf : (∑' (x : α), (fun i => ↑(f i)) x) ≠ ⊤
⊢ Tendsto (fun s => ∑' (b : { x // ¬x ∈ s }), (fun i => ↑(f i)) ↑b) atTop (𝓝 0)

tactic: rw [ENNReal.coe_tsum]
state_before: case h.e'_3.h
α✝ : Type ?u.262957
β : Type ?u.262960
γ : Type ?u.262963
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_1
f : α → ℝ≥0
hf : (∑' (x : α), (fun i => ↑(f i)) x) ≠ ⊤
x✝ : Finset α
⊢ (∑' (b : { x // ¬x ∈ x✝ }), (fun i => ↑(f i)) ↑b) = ↑(∑' (b : { x // ¬x ∈ x✝ }), f ↑b)

tactic: exact NNReal.summable_comp_injective (tsum_coe_ne_top_iff_summable.1 hf) Subtype.coe_injective
state_before: case h.e'_3.h
α✝ : Type ?u.262957
β : Type ?u.262960
γ : Type ?u.262963
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_1
f : α → ℝ≥0
hf : (∑' (x : α), (fun i => ↑(f i)) x) ≠ ⊤
x✝ : Finset α
⊢ Summable fun b => f ↑b
Theorem: CauchySeq.totallyBounded_range
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: refine' totallyBounded_iff_subset.2 fun a ha => _
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : ℕ → α
hs : CauchySeq s
⊢ TotallyBounded (range s)

tactic: cases' cauchySeq_iff.1 hs a ha with n hn
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : ℕ → α
hs : CauchySeq s
a : Set (α × α)
ha : a ∈ 𝓤 α
⊢ ∃ t, t ⊆ range s ∧ Set.Finite t ∧ range s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ a}

tactic: refine' ⟨s '' { k | k ≤ n }, image_subset_range _ _, (finite_le_nat _).image _, _⟩
state_before: case intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : ℕ → α
hs : CauchySeq s
a : Set (α × α)
ha : a ∈ 𝓤 α
n : ℕ
hn : ∀ (k : ℕ), k ≥ n → ∀ (l : ℕ), l ≥ n → (s k, s l) ∈ a
⊢ ∃ t, t ⊆ range s ∧ Set.Finite t ∧ range s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ a}

tactic: rw [range_subset_iff, biUnion_image]
state_before: case intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : ℕ → α
hs : CauchySeq s
a : Set (α × α)
ha : a ∈ 𝓤 α
n : ℕ
hn : ∀ (k : ℕ), k ≥ n → ∀ (l : ℕ), l ≥ n → (s k, s l) ∈ a
⊢ range s ⊆ ⋃ (y : α) (_ : y ∈ s '' {k | k ≤ n}), {x | (x, y) ∈ a}

tactic: intro m
state_before: case intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : ℕ → α
hs : CauchySeq s
a : Set (α × α)
ha : a ∈ 𝓤 α
n : ℕ
hn : ∀ (k : ℕ), k ≥ n → ∀ (l : ℕ), l ≥ n → (s k, s l) ∈ a
⊢ ∀ (y : ℕ), s y ∈ ⋃ (y : ℕ) (_ : y ∈ {k | k ≤ n}), {x | (x, s y) ∈ a}

tactic: rw [mem_iUnion₂]
state_before: case intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : ℕ → α
hs : CauchySeq s
a : Set (α × α)
ha : a ∈ 𝓤 α
n : ℕ
hn : ∀ (k : ℕ), k ≥ n → ∀ (l : ℕ), l ≥ n → (s k, s l) ∈ a
m : ℕ
⊢ s m ∈ ⋃ (y : ℕ) (_ : y ∈ {k | k ≤ n}), {x | (x, s y) ∈ a}

tactic: cases' le_total m n with hm hm
state_before: case intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : ℕ → α
hs : CauchySeq s
a : Set (α × α)
ha : a ∈ 𝓤 α
n : ℕ
hn : ∀ (k : ℕ), k ≥ n → ∀ (l : ℕ), l ≥ n → (s k, s l) ∈ a
m : ℕ
⊢ ∃ i j, s m ∈ {x | (x, s i) ∈ a}

tactic: exacts [⟨m, hm, refl_mem_uniformity ha⟩, ⟨n, le_refl n, hn m hm n le_rfl⟩]
state_before: case intro.inl
α : Type u
β : Type v
inst✝ : UniformSpace α
s : ℕ → α
hs : CauchySeq s
a : Set (α × α)
ha : a ∈ 𝓤 α
n : ℕ
hn : ∀ (k : ℕ), k ≥ n → ∀ (l : ℕ), l ≥ n → (s k, s l) ∈ a
m : ℕ
hm : m ≤ n
⊢ ∃ i j, s m ∈ {x | (x, s i) ∈ a}

case intro.inr
α : Type u
β : Type v
inst✝ : UniformSpace α
s : ℕ → α
hs : CauchySeq s
a : Set (α × α)
ha : a ∈ 𝓤 α
n : ℕ
hn : ∀ (k : ℕ), k ≥ n → ∀ (l : ℕ), l ≥ n → (s k, s l) ∈ a
m : ℕ
hm : n ≤ m
⊢ ∃ i j, s m ∈ {x | (x, s i) ∈ a}
Theorem: Quandle.dihedralAct.inv
File: Mathlib/Algebra/Quandle.lean

tactic: intro b
state_before: Q : Type ?u.78946
inst✝ : Quandle Q
n : ℕ
a : ZMod n
⊢ Function.Involutive (dihedralAct n a)

tactic: dsimp only [dihedralAct]
state_before: Q : Type ?u.78946
inst✝ : Quandle Q
n : ℕ
a b : ZMod n
⊢ dihedralAct n a (dihedralAct n a b) = b

tactic: simp
state_before: Q : Type ?u.78946
inst✝ : Quandle Q
n : ℕ
a b : ZMod n
⊢ 2 * a - (2 * a - b) = b
Theorem: Int.eq_mul_div_of_mul_eq_mul_of_dvd_left
File: Mathlib/Data/Int/Div.lean

tactic: cases' hbc with k hk
state_before: a b c d : ℤ
hb : b ≠ 0
hbc : b ∣ c
h : b * a = c * d
⊢ a = c / b * d

tactic: subst hk
state_before: case intro
a b c d : ℤ
hb : b ≠ 0
h : b * a = c * d
k : ℤ
hk : c = b * k
⊢ a = c / b * d

tactic: rw [Int.mul_ediv_cancel_left _ hb]
state_before: case intro
a b d : ℤ
hb : b ≠ 0
k : ℤ
h : b * a = b * k * d
⊢ a = b * k / b * d

tactic: rw [mul_assoc] at h
state_before: case intro
a b d : ℤ
hb : b ≠ 0
k : ℤ
h : b * a = b * k * d
⊢ a = k * d

tactic: apply mul_left_cancel₀ hb h
state_before: case intro
a b d : ℤ
hb : b ≠ 0
k : ℤ
h : b * a = b * (k * d)
⊢ a = k * d
Theorem: Ordinal.opow_one
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rw [← succ_zero, opow_succ]
state_before: a : Ordinal
⊢ a ^ 1 = a

tactic: simp only [opow_zero, one_mul]
state_before: a : Ordinal
⊢ a ^ 0 * a = a
Theorem: BoxIntegral.Integrable.to_subbox_aux
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: refine (cauchy_map_iff_exists_tendsto.1
  (h.cauchy_map_integralSum_toFilteriUnion (.single I J hJ))).imp fun y hy ↦ ⟨?_, hy⟩
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
inst✝ : CompleteSpace F
h : Integrable I l f vol
hJ : J ≤ I
⊢ ∃ y, HasIntegral J l f vol y ∧ Tendsto (integralSum f vol) (toFilteriUnion l I (Prepartition.single I J hJ)) (𝓝 y)

tactic: convert hy.comp (l.tendsto_embedBox_toFilteriUnion_top hJ)
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y✝ y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
inst✝ : CompleteSpace F
h : Integrable I l f vol
hJ : J ≤ I
y : F
hy : Tendsto (integralSum f vol) (toFilteriUnion l I (Prepartition.single I J hJ)) (𝓝 y)
⊢ HasIntegral J l f vol y