tasksource/leandojo huggingface dataset:
Theorem: Doset.mem_doset_of_not_disjoint
File: Mathlib/GroupTheory/DoubleCoset.lean

tactic: rw [Set.not_disjoint_iff] at h
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.6410
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : G
h : ¬Disjoint (doset a ↑H ↑K) (doset b ↑H ↑K)
⊢ b ∈ doset a ↑H ↑K

tactic: simp only [mem_doset] at *
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.6410
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : G
h : ∃ x, x ∈ doset a ↑H ↑K ∧ x ∈ doset b ↑H ↑K
⊢ b ∈ doset a ↑H ↑K

tactic: obtain ⟨x, ⟨l, hl, r, hr, hrx⟩, y, hy, ⟨r', hr', rfl⟩⟩ := h
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.6410
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : G
h : ∃ x, (∃ x_1, x_1 ∈ ↑H ∧ ∃ y, y ∈ ↑K ∧ x = x_1 * a * y) ∧ ∃ x_1, x_1 ∈ ↑H ∧ ∃ y, y ∈ ↑K ∧ x = x_1 * b * y
⊢ ∃ x, x ∈ ↑H ∧ ∃ y, y ∈ ↑K ∧ b = x * a * y

tactic: refine' ⟨y⁻¹ * l, H.mul_mem (H.inv_mem hy) hl, r * r'⁻¹, K.mul_mem hr (K.inv_mem hr'), _⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
α : Type ?u.6410
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b l : G
hl : l ∈ ↑H
r : G
hr : r ∈ ↑K
y : G
hy : y ∈ ↑H
r' : G
hr' : r' ∈ ↑K
hrx : y * b * r' = l * a * r
⊢ ∃ x, x ∈ ↑H ∧ ∃ y, y ∈ ↑K ∧ b = x * a * y

tactic: rwa [mul_assoc, mul_assoc, eq_inv_mul_iff_mul_eq, ← mul_assoc, ← mul_assoc, eq_mul_inv_iff_mul_eq]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
α : Type ?u.6410
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b l : G
hl : l ∈ ↑H
r : G
hr : r ∈ ↑K
y : G
hy : y ∈ ↑H
r' : G
hr' : r' ∈ ↑K
hrx : y * b * r' = l * a * r
⊢ b = y⁻¹ * l * a * (r * r'⁻¹)
Theorem: Ordinal.nat_cast_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp only [lt_iff_le_not_le, nat_cast_le]
state_before: m n : ℕ
⊢ ↑m < ↑n ↔ m < n
Theorem: Polynomial.map_restriction
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: rw [coeff_map, Algebra.algebraMap_ofSubring_apply, coeff_restriction]
state_before: R✝ : Type u
S : Type ?u.71352
inst✝¹ : Ring R✝
R : Type u
inst✝ : CommRing R
p : R[X]
n : ℕ
⊢ coeff (map (algebraMap { x // x ∈ Subring.closure ↑(frange p) } R) (restriction p)) n = coeff p n
Theorem: ENNReal.eventually_pow_one_div_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: lift x to ℝ≥0 using hx
state_before: x : ℝ≥0∞
hx : x ≠ ⊤
y : ℝ≥0∞
hy : 1 < y
⊢ ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y

tactic: by_cases y = ∞
state_before: case intro
y : ℝ≥0∞
hy : 1 < y
x : ℝ≥0
⊢ ∀ᶠ (n : ℕ) in atTop, ↑x ^ (1 / ↑n) ≤ y

tactic: exact eventually_of_forall fun n => h.symm ▸ le_top
state_before: case pos
y : ℝ≥0∞
hy : 1 < y
x : ℝ≥0
h : y = ⊤
⊢ ∀ᶠ (n : ℕ) in atTop, ↑x ^ (1 / ↑n) ≤ y

tactic: lift y to ℝ≥0 using h
state_before: case neg
y : ℝ≥0∞
hy : 1 < y
x : ℝ≥0
h : ¬y = ⊤
⊢ ∀ᶠ (n : ℕ) in atTop, ↑x ^ (1 / ↑n) ≤ y

tactic: have := NNReal.eventually_pow_one_div_le x (by exact_mod_cast hy : 1 < y)
state_before: case neg.intro
x y : ℝ≥0
hy : 1 < ↑y
⊢ ∀ᶠ (n : ℕ) in atTop, ↑x ^ (1 / ↑n) ≤ ↑y

tactic: refine' this.congr (eventually_of_forall fun n => _)
state_before: case neg.intro
x y : ℝ≥0
hy : 1 < ↑y
this : ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y
⊢ ∀ᶠ (n : ℕ) in atTop, ↑x ^ (1 / ↑n) ≤ ↑y

tactic: rw [coe_rpow_of_nonneg x (by positivity : 0 ≤ (1 / n : ℝ)), coe_le_coe]
state_before: case neg.intro
x y : ℝ≥0
hy : 1 < ↑y
this : ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y
n : ℕ
⊢ x ^ (1 / ↑n) ≤ y ↔ ↑x ^ (1 / ↑n) ≤ ↑y

tactic: exact_mod_cast hy
state_before: x y : ℝ≥0
hy : 1 < ↑y
⊢ 1 < y

tactic: positivity
state_before: x y : ℝ≥0
hy : 1 < ↑y
this : ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y
n : ℕ
⊢ 0 ≤ 1 / ↑n
Theorem: Real.arcsin_nonneg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [sin_zero]
state_before: x : ℝ
⊢ sin 0 ≤ x ↔ 0 ≤ x
Theorem: PiCountable.dist_le_dist_pi_of_dist_lt
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simpa only [not_le.2 h, false_or_iff] using min_le_iff.1 (min_dist_le_dist_pi x y i)
state_before: E : ℕ → Type ?u.306614
ι : Type u_1
inst✝¹ : Encodable ι
F : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (F i)
x y : (i : ι) → F i
i : ι
h : dist x y < (1 / 2) ^ encode i
⊢ dist (x i) (y i) ≤ dist x y
Theorem: FormalMultilinearSeries.nnnorm_changeOriginSeries_apply_le_tsum
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: rw [NNReal.tsum_mul_right, ← Fin.prod_const]
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.1266934
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
x✝ y : E
r R : ℝ≥0
k l : ℕ
x : E
⊢ ‖↑(changeOriginSeries p k l) fun x_1 => x‖₊ ≤ ∑' (x_1 : { s // Finset.card s = l }), ‖p (k + l)‖₊ * ‖x‖₊ ^ l

tactic: exact (p.changeOriginSeries k l).le_of_op_nnnorm_le _ (p.nnnorm_changeOriginSeries_le_tsum _ _)
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.1266934
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
x✝ y : E
r R : ℝ≥0
k l : ℕ
x : E
⊢ ‖↑(changeOriginSeries p k l) fun x_1 => x‖₊ ≤ (∑' (x : { s // Finset.card s = l }), ‖p (k + l)‖₊) * ∏ _i : Fin l, ‖x‖₊
Theorem: triple_product_eq_det
File: Mathlib/LinearAlgebra/CrossProduct.lean

tactic: rw [vec3_dotProduct, cross_apply, det_fin_three]
state_before: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u ⬝ᵥ ↑(↑crossProduct v) w = det ![u, v, w]

tactic: norm_num
state_before: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u 0 * vecCons (v 1 * w 2 - v 2 * w 1) ![v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 0 +
        u 1 * vecCons (v 1 * w 2 - v 2 * w 1) ![v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 1 +
      u 2 * vecCons (v 1 * w 2 - v 2 * w 1) ![v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 2 =
    vecCons u ![v, w] 0 0 * vecCons u ![v, w] 1 1 * vecCons u ![v, w] 2 2 -
              vecCons u ![v, w] 0 0 * vecCons u ![v, w] 1 2 * vecCons u ![v, w] 2 1 -
            vecCons u ![v, w] 0 1 * vecCons u ![v, w] 1 0 * vecCons u ![v, w] 2 2 +
          vecCons u ![v, w] 0 1 * vecCons u ![v, w] 1 2 * vecCons u ![v, w] 2 0 +
        vecCons u ![v, w] 0 2 * vecCons u ![v, w] 1 0 * vecCons u ![v, w] 2 1 -
      vecCons u ![v, w] 0 2 * vecCons u ![v, w] 1 1 * vecCons u ![v, w] 2 0

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u 0 * (v 1 * w 2 - v 2 * w 1) + u 1 * (v 2 * w 0 - v 0 * w 2) + u 2 * (v 0 * w 1 - v 1 * w 0) =
    u 0 * v 1 * w 2 - u 0 * v 2 * w 1 - u 1 * v 0 * w 2 + u 1 * v 2 * w 0 + u 2 * v 0 * w 1 - u 2 * v 1 * w 0
Theorem: isRegular_mul_iff
File: Mathlib/Algebra/Regular/Basic.lean

tactic: refine' Iff.trans _ isRegular_mul_and_mul_iff
state_before: R : Type u_1
inst✝ : CommSemigroup R
a b : R
⊢ IsRegular (a * b) ↔ IsRegular a ∧ IsRegular b

tactic: refine' ⟨fun ab => ⟨ab, by rwa [mul_comm]⟩, fun rab => rab.1⟩
state_before: R : Type u_1
inst✝ : CommSemigroup R
a b : R
⊢ IsRegular (a * b) ↔ IsRegular (a * b) ∧ IsRegular (b * a)

tactic: rwa [mul_comm]
state_before: R : Type u_1
inst✝ : CommSemigroup R
a b : R
ab : IsRegular (a * b)
⊢ IsRegular (b * a)
Theorem: Nat.ascFactorial_of_sub
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: let t := n - k.succ
state_before: n k : ℕ
h : k < n
⊢ (n - k) * ascFactorial (n - k) k = ascFactorial (n - (k + 1)) (k + 1)

tactic: let ht : t = n - k.succ := rfl
state_before: n k : ℕ
h : k < n
t : ℕ := n - succ k
⊢ (n - k) * ascFactorial (n - k) k = ascFactorial (n - (k + 1)) (k + 1)

tactic: suffices h' : n - k = t.succ
state_before: n k : ℕ
h : k < n
t : ℕ := n - succ k
ht : t = n - succ k := rfl
⊢ (n - k) * ascFactorial (n - k) k = ascFactorial (n - (k + 1)) (k + 1)

tactic: rw [ht, succ_eq_add_one, ← tsub_tsub_assoc (succ_le_of_lt h) (succ_pos _), succ_sub_one]
state_before: case h'
n k : ℕ
h : k < n
t : ℕ := n - succ k
ht : t = n - succ k := rfl
⊢ n - k = succ t

tactic: rw [← ht, h', succ_ascFactorial, ascFactorial_succ]
state_before: n k : ℕ
h : k < n
t : ℕ := n - succ k
ht : t = n - succ k := rfl
h' : n - k = succ t
⊢ (n - k) * ascFactorial (n - k) k = ascFactorial (n - (k + 1)) (k + 1)
Theorem: FractionalIdeal.spanFinset_ne_zero
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simp
state_before: R : Type ?u.1280273
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1280480
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
ι : Type u_1
s : Finset ι
f : ι → K
⊢ spanFinset R₁ s f ≠ 0 ↔ ∃ j, j ∈ s ∧ f j ≠ 0
Theorem: Polynomial.eval₂_mul_noncomm
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rcases p with ⟨p⟩
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
hf : ∀ (k : ℕ), Commute (↑f (coeff q k)) x
⊢ eval₂ f x (p * q) = eval₂ f x p * eval₂ f x q

tactic: rcases q with ⟨q⟩
state_before: case ofFinsupp
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
hf : ∀ (k : ℕ), Commute (↑f (coeff q k)) x
p : AddMonoidAlgebra R ℕ
⊢ eval₂ f x ({ toFinsupp := p } * q) = eval₂ f x { toFinsupp := p } * eval₂ f x q

tactic: simp only [coeff] at hf
state_before: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
p q : AddMonoidAlgebra R ℕ
hf : ∀ (k : ℕ), Commute (↑f (coeff { toFinsupp := q } k)) x
⊢ eval₂ f x ({ toFinsupp := p } * { toFinsupp := q }) = eval₂ f x { toFinsupp := p } * eval₂ f x { toFinsupp := q }

tactic: simp only [← ofFinsupp_mul, eval₂_ofFinsupp]
state_before: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
p q : AddMonoidAlgebra R ℕ
hf : ∀ (k : ℕ), Commute (↑f (↑q k)) x
⊢ eval₂ f x ({ toFinsupp := p } * { toFinsupp := q }) = eval₂ f x { toFinsupp := p } * eval₂ f x { toFinsupp := q }

tactic: exact liftNC_mul _ _ p q fun {k n} _hn => (hf k).pow_right n
state_before: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
p q : AddMonoidAlgebra R ℕ
hf : ∀ (k : ℕ), Commute (↑f (↑q k)) x
⊢ ↑(liftNC ↑f ↑(↑(powersHom S) x)) (p * q) = ↑(liftNC ↑f ↑(↑(powersHom S) x)) p * ↑(liftNC ↑f ↑(↑(powersHom S) x)) q
Theorem: List.rdrop_eq_reverse_drop_reverse
File: Mathlib/Data/List/Rdrop.lean

tactic: rw [rdrop]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rdrop l n = reverse (drop n (reverse l))

tactic: induction' l using List.reverseRecOn with xs x IH generalizing n
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ take (length l - n) l = reverse (drop n (reverse l))

tactic: simp
state_before: case H0
α : Type u_1
p : α → Bool
l : List α
n✝ n : ℕ
⊢ take (length [] - n) [] = reverse (drop n (reverse []))

tactic: cases n
state_before: case H1
α : Type u_1
p : α → Bool
l : List α
n✝ : ℕ
xs : List α
x : α
IH : ∀ (n : ℕ), take (length xs - n) xs = reverse (drop n (reverse xs))
n : ℕ
⊢ take (length (xs ++ [x]) - n) (xs ++ [x]) = reverse (drop n (reverse (xs ++ [x])))

tactic: simp [take_append]
state_before: case H1.zero
α : Type u_1
p : α → Bool
l : List α
n : ℕ
xs : List α
x : α
IH : ∀ (n : ℕ), take (length xs - n) xs = reverse (drop n (reverse xs))
⊢ take (length (xs ++ [x]) - Nat.zero) (xs ++ [x]) = reverse (drop Nat.zero (reverse (xs ++ [x])))

tactic: simp [take_append_eq_append_take, IH]
state_before: case H1.succ
α : Type u_1
p : α → Bool
l : List α
n : ℕ
xs : List α
x : α
IH : ∀ (n : ℕ), take (length xs - n) xs = reverse (drop n (reverse xs))
n✝ : ℕ
⊢ take (length (xs ++ [x]) - Nat.succ n✝) (xs ++ [x]) = reverse (drop (Nat.succ n✝) (reverse (xs ++ [x])))
Theorem: Complex.mul_inv_cancel
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [inv_def, ← mul_assoc, mul_conj, ← ofReal_mul, mul_inv_cancel (mt normSq_eq_zero.1 h),
  ofReal_one]
state_before: z : ℂ
h : z ≠ 0
⊢ z * z⁻¹ = 1
Theorem: Real.pi_pos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: norm_num
state_before: ⊢ 0 < 2
Theorem: ZNum.gcd_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp
state_before: a b : ZNum
⊢ Nat.gcd ↑(abs a) ↑(abs b) = Int.gcd ↑a ↑b

tactic: rfl
state_before: a b : ZNum
⊢ Nat.gcd (natAbs ↑a) (natAbs ↑b) = Int.gcd ↑a ↑b
Theorem: continuousWithinAt_insert_self
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [← singleton_union, continuousWithinAt_union, continuousWithinAt_singleton,
  true_and_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.325537
δ : Type ?u.325540
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
x : α
s : Set α
⊢ ContinuousWithinAt f (insert x s) x ↔ ContinuousWithinAt f s x
Theorem: TypeVec.toSubtype_of_subtype
File: Mathlib/Data/TypeVec.lean

tactic: ext (i x)
state_before: n : ℕ
α : TypeVec n
p : α ⟹ repeat n Prop
⊢ toSubtype p ⊚ ofSubtype p = id

tactic: induction i <;> dsimp only [id, toSubtype, comp, ofSubtype] at *
state_before: case a.h
n : ℕ
α : TypeVec n
p : α ⟹ repeat n Prop
i : Fin2 n
x : Subtype_ p i
⊢ (toSubtype p ⊚ ofSubtype p) i x = id i x

tactic: simp [*]
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α : TypeVec n✝} (p : α ⟹ repeat n✝ Prop) (x : Subtype_ p a✝), toSubtype p a✝ (ofSubtype p a✝ x) = x
α : TypeVec (Nat.succ n✝)
p : α ⟹ repeat (Nat.succ n✝) Prop
x : Subtype_ p (Fin2.fs a✝)
⊢ toSubtype (dropFun p) a✝ (ofSubtype (dropFun p) a✝ x) = x
Theorem: Cardinal.lift_prod
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: lift c to ι → Type v using fun _ => trivial
state_before: α β ι : Type u
c : ι → Cardinal
⊢ lift (prod c) = prod fun i => lift (c i)

tactic: simp only [← mk_pi, ← mk_uLift]
state_before: case intro
α β ι : Type u
c : ι → Type v
⊢ lift (prod fun i => #c i) = prod fun i => lift ((fun i => #c i) i)

tactic: exact mk_congr (Equiv.ulift.trans <| Equiv.piCongrRight fun i => Equiv.ulift.symm)
state_before: case intro
α β ι : Type u
c : ι → Type v
⊢ (#ULift ((i : ι) → c i)) = (#(i : ι) → ULift (c i))
Theorem: List.isInfix.trans
File: Std/Data/List/Lemmas.lean

tactic: simp only [append_assoc]
state_before: α : Type u_1
l l₁ r₁ l₂ r₂ : List α
⊢ l₂ ++ l₁ ++ l ++ (r₁ ++ r₂) = l₂ ++ (l₁ ++ l ++ r₁) ++ r₂
Theorem: Real.tendsto_comp_exp_atBot
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: rw [← map_exp_atBot, tendsto_map'_iff]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : ℝ → α
⊢ Tendsto (fun x => f (exp x)) atBot l ↔ Tendsto f (𝓝[Set.Ioi 0] 0) l

tactic: rfl
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : ℝ → α
⊢ Tendsto (fun x => f (exp x)) atBot l ↔ Tendsto (f ∘ exp) atBot l
Theorem: intervalIntegral.continuousOn_primitive_interval_left
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [uIcc_comm a b] at h_int ⊢
state_before: ι : Type ?u.18752176
𝕜 : Type ?u.18752179
E : Type u_1
F : Type ?u.18752185
A : Type ?u.18752188
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b b₀ b₁ b₂ : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f [[a, b]]
⊢ ContinuousOn (fun x => ∫ (t : ℝ) in x..b, f t ∂μ) [[a, b]]

tactic: simp only [integral_symm b]
state_before: ι : Type ?u.18752176
𝕜 : Type ?u.18752179
E : Type u_1
F : Type ?u.18752185
A : Type ?u.18752188
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b b₀ b₁ b₂ : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f [[b, a]]
⊢ ContinuousOn (fun x => ∫ (t : ℝ) in x..b, f t ∂μ) [[b, a]]

tactic: exact (continuousOn_primitive_interval h_int).neg
state_before: ι : Type ?u.18752176
𝕜 : Type ?u.18752179
E : Type u_1
F : Type ?u.18752185
A : Type ?u.18752188
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b b₀ b₁ b₂ : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f [[b, a]]
⊢ ContinuousOn (fun x => -∫ (x : ℝ) in b..x, f x ∂μ) [[b, a]]
Theorem: List.length_split_lt
File: Mathlib/Data/List/Sort.lean

tactic: cases' e : split l with l₁' l₂'
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l l₁ l₂ : List α
h : split (a :: b :: l) = (l₁, l₂)
⊢ length l₁ < length (a :: b :: l) ∧ length l₂ < length (a :: b :: l)

tactic: injection (split_cons_of_eq _ (split_cons_of_eq _ e)).symm.trans h
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l l₁ l₂ : List α
h : split (a :: b :: l) = (l₁, l₂)
l₁' l₂' : List α
e : split l = (l₁', l₂')
⊢ length l₁ < length (a :: b :: l) ∧ length l₂ < length (a :: b :: l)

tactic: substs l₁ l₂
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l l₁ l₂ : List α
h : split (a :: b :: l) = (l₁, l₂)
l₁' l₂' : List α
e : split l = (l₁', l₂')
fst_eq✝ : a :: l₁' = l₁
snd_eq✝ : b :: l₂' = l₂
⊢ length l₁ < length (a :: b :: l) ∧ length l₂ < length (a :: b :: l)

tactic: cases' length_split_le e with h₁ h₂
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l l₁' l₂' : List α
e : split l = (l₁', l₂')
h : split (a :: b :: l) = (a :: l₁', b :: l₂')
⊢ length (a :: l₁') < length (a :: b :: l) ∧ length (b :: l₂') < length (a :: b :: l)

tactic: exact ⟨Nat.succ_le_succ (Nat.succ_le_succ h₁), Nat.succ_le_succ (Nat.succ_le_succ h₂)⟩
state_before: case mk.intro
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l l₁' l₂' : List α
e : split l = (l₁', l₂')
h : split (a :: b :: l) = (a :: l₁', b :: l₂')
h₁ : length l₁' ≤ length l
h₂ : length l₂' ≤ length l
⊢ length (a :: l₁') < length (a :: b :: l) ∧ length (b :: l₂') < length (a :: b :: l)
Theorem: measurable_const_smul_iff
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [inv_smul_smul] using h.const_smul' c⁻¹
state_before: M : Type ?u.3449887
β : Type u_2
α : Type u_1
inst✝⁹ : MeasurableSpace M
inst✝⁸ : MeasurableSpace β
inst✝⁷ : Monoid M
inst✝⁶ : MulAction M β
inst✝⁵ : MeasurableSMul M β
inst✝⁴ : MeasurableSpace α
f : α → β
μ : MeasureTheory.Measure α
G : Type u_3
inst✝³ : Group G
inst✝² : MeasurableSpace G
inst✝¹ : MulAction G β
inst✝ : MeasurableSMul G β
c : G
h : Measurable fun x => c • f x
⊢ Measurable f
Theorem: mul_invOf_eq_iff_eq_mul_right
File: Mathlib/Algebra/Invertible.lean

tactic: rw [← mul_right_inj_of_invertible (c := c), mul_invOf_mul_self_cancel]
state_before: α : Type u
c a b : α
inst✝¹ : Monoid α
inst✝ : Invertible c
⊢ a * ⅟c = b ↔ a = b * c
Theorem: Subalgebra.mul_self
File: Mathlib/Algebra/Algebra/Subalgebra/Pointwise.lean

tactic: apply le_antisymm
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S : Subalgebra R A
⊢ ↑toSubmodule S * ↑toSubmodule S = ↑toSubmodule S

tactic: refine' (mul_toSubmodule_le _ _).trans_eq _
state_before: case a
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S : Subalgebra R A
⊢ ↑toSubmodule S * ↑toSubmodule S ≤ ↑toSubmodule S

tactic: rw [sup_idem]
state_before: case a
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S : Subalgebra R A
⊢ ↑toSubmodule (S ⊔ S) = ↑toSubmodule S

tactic: intro x hx1
state_before: case a
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S : Subalgebra R A
⊢ ↑toSubmodule S ≤ ↑toSubmodule S * ↑toSubmodule S

tactic: rw [← mul_one x]
state_before: case a
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S : Subalgebra R A
x : A
hx1 : x ∈ ↑toSubmodule S
⊢ x ∈ ↑toSubmodule S * ↑toSubmodule S

tactic: exact Submodule.mul_mem_mul hx1 (show (1 : A) ∈ S from one_mem S)
state_before: case a
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S : Subalgebra R A
x : A
hx1 : x ∈ ↑toSubmodule S
⊢ x * 1 ∈ ↑toSubmodule S * ↑toSubmodule S
Theorem: Complex.tan_ofReal_im
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_tan_ofReal_re, ofReal_im]
state_before: x✝ y : ℂ
x : ℝ
⊢ (tan ↑x).im = 0
Theorem: Multiset.Nodup.mem_erase_iff
File: Mathlib/Data/Multiset/Nodup.lean

tactic: rw [d.erase_eq_filter b, mem_filter, and_comm]
state_before: α : Type u_1
β : Type ?u.8207
γ : Type ?u.8210
r : α → α → Prop
s t : Multiset α
a✝ : α
inst✝ : DecidableEq α
a b : α
l : Multiset α
d : Nodup l
⊢ a ∈ Multiset.erase l b ↔ a ≠ b ∧ a ∈ l
Theorem: Ordinal.fp_unbounded
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: convert fp_family_unbounded fun _ : Unit => H
state_before: f : Ordinal → Ordinal
H : IsNormal f
⊢ Set.Unbounded (fun x x_1 => x < x_1) (fixedPoints f)

tactic: exact (Set.iInter_const _).symm
state_before: case h.e'_3
f : Ordinal → Ordinal
H : IsNormal f
⊢ fixedPoints f = ⋂ (i : Unit), fixedPoints f
Theorem: fderivWithin_zero_of_not_differentiableWithinAt
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: have : ¬∃ f', HasFDerivWithinAt f f' s x := h
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.37783
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.37878
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ¬DifferentiableWithinAt 𝕜 f s x
⊢ fderivWithin 𝕜 f s x = 0

tactic: simp [fderivWithin, this]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.37783
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.37878
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ¬DifferentiableWithinAt 𝕜 f s x
this : ¬∃ f', HasFDerivWithinAt f f' s x
⊢ fderivWithin 𝕜 f s x = 0
Theorem: differentiableOn_sub_const_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp only [sub_eq_add_neg, differentiableOn_add_const_iff]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.509886
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.509981
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
⊢ DifferentiableOn 𝕜 (fun y => f y - c) s ↔ DifferentiableOn 𝕜 f s
Theorem: Metric.Bounded.prod
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [bounded_iff_isBounded] at *
state_before: α : Type u
β : Type v
X : Type ?u.492392
ι : Type ?u.492395
inst✝¹ : PseudoMetricSpace α
x : α
s✝ t✝ : Set α
r : ℝ
inst✝ : PseudoMetricSpace β
s : Set α
t : Set β
hs : Bounded s
ht : Bounded t
⊢ Bounded (s ×ˢ t)

tactic: exact hs.prod ht
state_before: α : Type u
β : Type v
X : Type ?u.492392
ι : Type ?u.492395
inst✝¹ : PseudoMetricSpace α
x : α
s✝ t✝ : Set α
r : ℝ
inst✝ : PseudoMetricSpace β
s : Set α
t : Set β
hs : IsBounded s
ht : IsBounded t
⊢ IsBounded (s ×ˢ t)