tasksource/leandojo huggingface dataset:
Theorem: Ordinal.IsNormal.bsup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: haveI := type_ne_zero_iff_nonempty.1 h
state_before: α✝ : Type ?u.311394
β : Type ?u.311397
γ : Type ?u.311400
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal → Ordinal
H : IsNormal f
o : Ordinal
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
g : (a : Ordinal) → a < type r → Ordinal
h : type r ≠ 0
⊢ f (Ordinal.bsup (type r) g) = Ordinal.bsup (type r) fun a h => f (g a h)

tactic: rw [← sup_eq_bsup' r, IsNormal.sup.{_, v, w} H, ← sup_eq_bsup' r] <;> rfl
state_before: α✝ : Type ?u.311394
β : Type ?u.311397
γ : Type ?u.311400
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal → Ordinal
H : IsNormal f
o : Ordinal
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
g : (a : Ordinal) → a < type r → Ordinal
h : type r ≠ 0
this : Nonempty α
⊢ f (Ordinal.bsup (type r) g) = Ordinal.bsup (type r) fun a h => f (g a h)
Theorem: Int.ediv_eq_ediv_of_mul_eq_mul
File: Mathlib/Data/Int/Order/Basic.lean

tactic: rw [← Int.mul_ediv_assoc _ H2]
state_before: a✝ b✝ : ℤ
n : ℕ
a b c d : ℤ
H2 : d ∣ c
H3 : b ≠ 0
H4 : d ≠ 0
H5 : a * d = b * c
⊢ a = b * (c / d)

tactic: exact (Int.ediv_eq_of_eq_mul_left H4 H5.symm).symm
state_before: a✝ b✝ : ℤ
n : ℕ
a b c d : ℤ
H2 : d ∣ c
H3 : b ≠ 0
H4 : d ≠ 0
H5 : a * d = b * c
⊢ a = b * c / d
Theorem: vsub_sub_vsub_comm
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [← vsub_vadd_eq_vsub_sub, vsub_vadd_comm, vsub_vadd_eq_vsub_sub]
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
p₁ p₂ p₃ p₄ : P
⊢ p₁ -ᵥ p₂ - (p₃ -ᵥ p₄) = p₁ -ᵥ p₃ - (p₂ -ᵥ p₄)
Theorem: PiLp.nnnorm_equiv_symm_const
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: rcases p.dichotomy with (h | h)
state_before: p : ℝ≥0∞
𝕜 : Type ?u.498893
𝕜' : Type ?u.498896
ι : Type u_2
α : ι → Type ?u.498904
β✝ : ι → Type ?u.498909
inst✝⁹ : Fintype ι
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NormedField 𝕜'
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝⁴ : (i : ι) → NormedSpace 𝕜 (β✝ i)
c : 𝕜
x y : PiLp p β✝
x' y' : (i : ι) → β✝ i
i : ι
ι' : Type ?u.499105
inst✝³ : Fintype ι'
E : Type ?u.499111
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
β : Type u_1
inst✝ : SeminormedAddCommGroup β
hp : p ≠ ⊤
b : β
⊢ ‖↑(PiLp.equiv p fun x => β).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ ENNReal.toReal (1 / p) * ‖b‖₊

tactic: exact False.elim (hp h)
state_before: case inl
p : ℝ≥0∞
𝕜 : Type ?u.498893
𝕜' : Type ?u.498896
ι : Type u_2
α : ι → Type ?u.498904
β✝ : ι → Type ?u.498909
inst✝⁹ : Fintype ι
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NormedField 𝕜'
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝⁴ : (i : ι) → NormedSpace 𝕜 (β✝ i)
c : 𝕜
x y : PiLp p β✝
x' y' : (i : ι) → β✝ i
i : ι
ι' : Type ?u.499105
inst✝³ : Fintype ι'
E : Type ?u.499111
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
β : Type u_1
inst✝ : SeminormedAddCommGroup β
hp : p ≠ ⊤
b : β
h : p = ⊤
⊢ ‖↑(PiLp.equiv p fun x => β).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ ENNReal.toReal (1 / p) * ‖b‖₊

tactic: have ne_zero : p.toReal ≠ 0 := (zero_lt_one.trans_le h).ne'
state_before: case inr
p : ℝ≥0∞
𝕜 : Type ?u.498893
𝕜' : Type ?u.498896
ι : Type u_2
α : ι → Type ?u.498904
β✝ : ι → Type ?u.498909
inst✝⁹ : Fintype ι
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NormedField 𝕜'
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝⁴ : (i : ι) → NormedSpace 𝕜 (β✝ i)
c : 𝕜
x y : PiLp p β✝
x' y' : (i : ι) → β✝ i
i : ι
ι' : Type ?u.499105
inst✝³ : Fintype ι'
E : Type ?u.499111
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
β : Type u_1
inst✝ : SeminormedAddCommGroup β
hp : p ≠ ⊤
b : β
h : 1 ≤ ENNReal.toReal p
⊢ ‖↑(PiLp.equiv p fun x => β).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ ENNReal.toReal (1 / p) * ‖b‖₊

tactic: simp_rw [nnnorm_eq_sum hp, equiv_symm_apply, Function.const_apply, Finset.sum_const,
  Finset.card_univ, nsmul_eq_mul, NNReal.mul_rpow, ← NNReal.rpow_mul,
  mul_one_div_cancel ne_zero, NNReal.rpow_one, ENNReal.toReal_div, ENNReal.one_toReal]
state_before: case inr
p : ℝ≥0∞
𝕜 : Type ?u.498893
𝕜' : Type ?u.498896
ι : Type u_2
α : ι → Type ?u.498904
β✝ : ι → Type ?u.498909
inst✝⁹ : Fintype ι
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NormedField 𝕜'
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝⁴ : (i : ι) → NormedSpace 𝕜 (β✝ i)
c : 𝕜
x y : PiLp p β✝
x' y' : (i : ι) → β✝ i
i : ι
ι' : Type ?u.499105
inst✝³ : Fintype ι'
E : Type ?u.499111
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
β : Type u_1
inst✝ : SeminormedAddCommGroup β
hp : p ≠ ⊤
b : β
h : 1 ≤ ENNReal.toReal p
ne_zero : ENNReal.toReal p ≠ 0
⊢ ‖↑(PiLp.equiv p fun x => β).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ ENNReal.toReal (1 / p) * ‖b‖₊
Theorem: LieSubalgebra.to_submodule_injective
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: rw [SetLike.ext'_iff] at h
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
L' L₁' L₂' : LieSubalgebra R L
h : L₁'.toSubmodule = L₂'.toSubmodule
⊢ L₁' = L₂'

tactic: rw [← coe_set_eq]
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
L' L₁' L₂' : LieSubalgebra R L
h✝ : L₁'.toSubmodule = L₂'.toSubmodule
h : ↑L₁'.toSubmodule = ↑L₂'.toSubmodule
⊢ L₁' = L₂'

tactic: exact h
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
L' L₁' L₂' : LieSubalgebra R L
h✝ : L₁'.toSubmodule = L₂'.toSubmodule
h : ↑L₁'.toSubmodule = ↑L₂'.toSubmodule
⊢ ↑L₁' = ↑L₂'
Theorem: Polynomial.integralNormalization_coeff
File: Mathlib/Data/Polynomial/IntegralNormalization.lean

tactic: have : f.coeff i = 0 → f.degree ≠ i := fun hc hd => coeff_ne_zero_of_eq_degree hd hc
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
f : R[X]
i : ℕ
⊢ coeff (integralNormalization f) i = if degree f = ↑i then 1 else coeff f i * leadingCoeff f ^ (natDegree f - 1 - i)

tactic: simp (config := { contextual := true }) [integralNormalization, coeff_monomial, this,
  mem_support_iff]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
f : R[X]
i : ℕ
this : coeff f i = 0 → degree f ≠ ↑i
⊢ coeff (integralNormalization f) i = if degree f = ↑i then 1 else coeff f i * leadingCoeff f ^ (natDegree f - 1 - i)
Theorem: aux1
File: Mathlib/Algebra/Jordan/Basic.lean

tactic: rw [add_lie, add_lie]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a + ↑L b + ↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)

tactic: iterate 15 rw [lie_add]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
        ⁅↑L b, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ +
      ⁅↑L c, ↑L (a * a) + ↑L (b * b) + ↑L (c * c) + 2 • ↑L (a * b) + 2 • ↑L (c * a) + 2 • ↑L (b * c)⁆ =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)

tactic: rw [lie_add]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a) + ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆)
Theorem: ENNReal.rpow_le_one_of_one_le_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases x
state_before: x : ℝ≥0∞
z : ℝ
hx : 1 ≤ x
hz : z < 0
⊢ x ^ z ≤ 1

tactic: simp [top_rpow_of_neg hz, zero_lt_one]
state_before: case none
z : ℝ
hz : z < 0
hx : 1 ≤ none
⊢ none ^ z ≤ 1

tactic: simp only [one_le_coe_iff, some_eq_coe] at hx
state_before: case some
z : ℝ
hz : z < 0
val✝ : ℝ≥0
hx : 1 ≤ Option.some val✝
⊢ Option.some val✝ ^ z ≤ 1

tactic: simp [coe_rpow_of_ne_zero (ne_of_gt (lt_of_lt_of_le zero_lt_one hx)),
  NNReal.rpow_le_one_of_one_le_of_nonpos hx (le_of_lt hz)]
state_before: case some
z : ℝ
hz : z < 0
val✝ : ℝ≥0
hx : 1 ≤ val✝
⊢ Option.some val✝ ^ z ≤ 1
Theorem: denomsClearable_C_mul_X_pow
File: Mathlib/Data/Polynomial/DenomsClearable.lean

tactic: refine' ⟨r * a ^ n * b ^ (N - n), bi, bu, _⟩
state_before: R : Type u_2
K : Type u_1
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a✝ b : R
bi : K
N : ℕ
a : R
bu : bi * ↑i b = 1
n : ℕ
r : R
nN : n ≤ N
⊢ DenomsClearable a b N (↑C r * X ^ n) i

tactic: rw [C_mul_X_pow_eq_monomial, map_monomial, ← C_mul_X_pow_eq_monomial, eval_mul, eval_pow, eval_C]
state_before: R : Type u_2
K : Type u_1
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a✝ b : R
bi : K
N : ℕ
a : R
bu : bi * ↑i b = 1
n : ℕ
r : R
nN : n ≤ N
⊢ ↑i (r * a ^ n * b ^ (N - n)) = ↑i b ^ N * eval (↑i a * bi) (Polynomial.map i (↑C r * X ^ n))

tactic: rw [RingHom.map_mul, RingHom.map_mul, RingHom.map_pow, RingHom.map_pow, eval_X, mul_comm]
state_before: R : Type u_2
K : Type u_1
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a✝ b : R
bi : K
N : ℕ
a : R
bu : bi * ↑i b = 1
n : ℕ
r : R
nN : n ≤ N
⊢ ↑i (r * a ^ n * b ^ (N - n)) = ↑i b ^ N * (↑i r * eval (↑i a * bi) X ^ n)

tactic: rw [← tsub_add_cancel_of_le nN]
state_before: R : Type u_2
K : Type u_1
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a✝ b : R
bi : K
N : ℕ
a : R
bu : bi * ↑i b = 1
n : ℕ
r : R
nN : n ≤ N
⊢ ↑i b ^ (N - n) * (↑i r * ↑i a ^ n) = ↑i b ^ N * (↑i r * (↑i a * bi) ^ n)

tactic: conv_lhs => rw [← mul_one (i a), ← bu]
state_before: R : Type u_2
K : Type u_1
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a✝ b : R
bi : K
N : ℕ
a : R
bu : bi * ↑i b = 1
n : ℕ
r : R
nN : n ≤ N
⊢ ↑i b ^ (N - n + n - n) * (↑i r * ↑i a ^ n) = ↑i b ^ (N - n + n) * (↑i r * (↑i a * bi) ^ n)

tactic: simp [mul_assoc, mul_comm, mul_left_comm, pow_add, mul_pow]
state_before: R : Type u_2
K : Type u_1
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a✝ b : R
bi : K
N : ℕ
a : R
bu : bi * ↑i b = 1
n : ℕ
r : R
nN : n ≤ N
⊢ ↑i b ^ (N - n + n - n) * (↑i r * (↑i a * (bi * ↑i b)) ^ n) = ↑i b ^ (N - n + n) * (↑i r * (↑i a * bi) ^ n)
Theorem: Finsupp.embDomain_single
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext b
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.255631
ι : Type ?u.255634
M : Type u_3
M' : Type ?u.255640
N : Type ?u.255643
P : Type ?u.255646
G : Type ?u.255649
H : Type ?u.255652
R : Type ?u.255655
S : Type ?u.255658
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
a : α
m : M
⊢ embDomain f (single a m) = single (↑f a) m

tactic: by_cases h : b ∈ Set.range f
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.255631
ι : Type ?u.255634
M : Type u_3
M' : Type ?u.255640
N : Type ?u.255643
P : Type ?u.255646
G : Type ?u.255649
H : Type ?u.255652
R : Type ?u.255655
S : Type ?u.255658
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
a : α
m : M
b : β
⊢ ↑(embDomain f (single a m)) b = ↑(single (↑f a) m) b

tactic: rcases h with ⟨a', rfl⟩
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.255631
ι : Type ?u.255634
M : Type u_3
M' : Type ?u.255640
N : Type ?u.255643
P : Type ?u.255646
G : Type ?u.255649
H : Type ?u.255652
R : Type ?u.255655
S : Type ?u.255658
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
a : α
m : M
b : β
h : b ∈ Set.range ↑f
⊢ ↑(embDomain f (single a m)) b = ↑(single (↑f a) m) b

tactic: simp [single_apply]
state_before: case pos.intro
α : Type u_1
β : Type u_2
γ : Type ?u.255631
ι : Type ?u.255634
M : Type u_3
M' : Type ?u.255640
N : Type ?u.255643
P : Type ?u.255646
G : Type ?u.255649
H : Type ?u.255652
R : Type ?u.255655
S : Type ?u.255658
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
a : α
m : M
a' : α
⊢ ↑(embDomain f (single a m)) (↑f a') = ↑(single (↑f a) m) (↑f a')

tactic: simp only [embDomain_notin_range, h, single_apply, not_false_iff]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.255631
ι : Type ?u.255634
M : Type u_3
M' : Type ?u.255640
N : Type ?u.255643
P : Type ?u.255646
G : Type ?u.255649
H : Type ?u.255652
R : Type ?u.255655
S : Type ?u.255658
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
a : α
m : M
b : β
h : ¬b ∈ Set.range ↑f
⊢ ↑(embDomain f (single a m)) b = ↑(single (↑f a) m) b

tactic: rw [if_neg]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.255631
ι : Type ?u.255634
M : Type u_3
M' : Type ?u.255640
N : Type ?u.255643
P : Type ?u.255646
G : Type ?u.255649
H : Type ?u.255652
R : Type ?u.255655
S : Type ?u.255658
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
a : α
m : M
b : β
h : ¬b ∈ Set.range ↑f
⊢ 0 = if ↑f a = b then m else 0

tactic: rintro rfl
state_before: case neg.hnc
α : Type u_1
β : Type u_2
γ : Type ?u.255631
ι : Type ?u.255634
M : Type u_3
M' : Type ?u.255640
N : Type ?u.255643
P : Type ?u.255646
G : Type ?u.255649
H : Type ?u.255652
R : Type ?u.255655
S : Type ?u.255658
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
a : α
m : M
b : β
h : ¬b ∈ Set.range ↑f
⊢ ¬↑f a = b

tactic: simp at h
state_before: case neg.hnc
α : Type u_1
β : Type u_2
γ : Type ?u.255631
ι : Type ?u.255634
M : Type u_3
M' : Type ?u.255640
N : Type ?u.255643
P : Type ?u.255646
G : Type ?u.255649
H : Type ?u.255652
R : Type ?u.255655
S : Type ?u.255658
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
a : α
m : M
h : ¬↑f a ∈ Set.range ↑f
⊢ False
Theorem: ContinuousMap.inf_eq
File: Mathlib/Topology/ContinuousFunction/Algebra.lean

tactic: simpa using min_eq_half_add_sub_abs_sub
state_before: α : Type u_1
inst✝⁴ : TopologicalSpace α
β : Type u_2
inst✝³ : LinearOrderedField β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : TopologicalRing β
f g : C(α, β)
x : α
⊢ ↑(f ⊓ g) x = ↑(2⁻¹ • (f + g - Abs.abs (f - g))) x
Theorem: Subspace.dualCoannihilator_top
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [dualCoannihilator, dualAnnihilator_top, comap_bot, Module.eval_ker]
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
⊢ dualCoannihilator ⊤ = ⊥
Theorem: MeasureTheory.lintegral_add_left'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral_congr_ae hf.ae_eq_mk, ← lintegral_add_left hf.measurable_mk,
  lintegral_congr_ae (hf.ae_eq_mk.add (ae_eq_refl g))]
state_before: α : Type u_1
β : Type ?u.902053
γ : Type ?u.902056
δ : Type ?u.902059
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f
g : α → ℝ≥0∞
⊢ (∫⁻ (a : α), f a + g a ∂μ) = (∫⁻ (a : α), f a ∂μ) + ∫⁻ (a : α), g a ∂μ
Theorem: Computation.map_id
File: Mathlib/Data/Seq/Computation.lean

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ map id { val := f, property := al } = { val := f, property := al }

tactic: simp [map, Function.comp]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ ↑(map id { val := f, property := al }) = ↑{ val := f, property := al }

tactic: have e : @Option.rec α (fun _ => Option α) none some = id := by ext ⟨⟩ <;> rfl
state_before: case a
α : Type u
β : Type v
γ : Type w
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ Stream'.map (fun o => Option.rec none (fun val => some val) o) f = f

tactic: have h : ((fun x: Option α => x) = id) := by rfl
state_before: case a
α : Type u
β : Type v
γ : Type w
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
e : Option.rec none some = id
⊢ Stream'.map (fun o => Option.rec none (fun val => some val) o) f = f

tactic: simp [e, h, Stream'.map_id]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
e : Option.rec none some = id
h : (fun x => x) = id
⊢ Stream'.map (fun o => Option.rec none (fun val => some val) o) f = f

tactic: ext ⟨⟩ <;> rfl
state_before: α : Type u
β : Type v
γ : Type w
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ Option.rec none some = id

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
e : Option.rec none some = id
⊢ (fun x => x) = id
Theorem: ProbabilityTheory.kernel.set_lintegral_deterministic
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [kernel.deterministic_apply, set_lintegral_dirac f s]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.399403
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
f : β → ℝ≥0∞
g : α → β
a : α
hg : Measurable g
inst✝¹ : MeasurableSingletonClass β
s : Set β
inst✝ : Decidable (g a ∈ s)
⊢ (∫⁻ (x : β) in s, f x ∂↑(deterministic g hg) a) = if g a ∈ s then f (g a) else 0
Theorem: List.tails_eq_tailsTR
File: Std/Data/List/Basic.lean

tactic: funext α
state_before: ⊢ @tails = @tailsTR

tactic: have H (l : List α) : ∀ acc, tailsTR.go l acc = acc.toList ++ tails l := by
  induction l <;> simp [*, tailsTR.go]
state_before: case h
α : Type u_1
⊢ tails = tailsTR

tactic: simp [tailsTR, H]
state_before: case h
α : Type u_1
H : ∀ (l : List α) (acc : Array (List α)), tailsTR.go l acc = Array.toList acc ++ tails l
⊢ tails = tailsTR

tactic: induction l <;> simp [*, tailsTR.go]
state_before: α : Type u_1
l : List α
⊢ ∀ (acc : Array (List α)), tailsTR.go l acc = Array.toList acc ++ tails l
Theorem: CategoryTheory.NatTrans.mapHomologicalComplex_naturality
File: Mathlib/Algebra/Homology/Additive.lean

tactic: aesop_cat
state_before: ι : Type u_1
V : Type u
inst✝⁵ : Category V
inst✝⁴ : Preadditive V
c✝ : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c✝
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
W : Type u_3
inst✝³ : Category W
inst✝² : Preadditive W
c : ComplexShape ι
F G : V ⥤ W
inst✝¹ : Functor.Additive F
inst✝ : Functor.Additive G
α : F ⟶ G
C D : HomologicalComplex V c
f : C ⟶ D
⊢ (Functor.mapHomologicalComplex F c).map f ≫ (mapHomologicalComplex α c).app D =
    (mapHomologicalComplex α c).app C ≫ (Functor.mapHomologicalComplex G c).map f
Theorem: nilpotent_iff_mem_prime
File: Mathlib/RingTheory/Nilpotent.lean

tactic: rw [← mem_nilradical, nilradical_eq_sInf, Submodule.mem_sInf]
state_before: R S : Type u
x y : R
inst✝ : CommSemiring R
⊢ IsNilpotent x ↔ ∀ (J : Ideal R), Ideal.IsPrime J → x ∈ J

tactic: rfl
state_before: R S : Type u
x y : R
inst✝ : CommSemiring R
⊢ (∀ (p : Submodule R R), p ∈ {J | Ideal.IsPrime J} → x ∈ p) ↔ ∀ (J : Ideal R), Ideal.IsPrime J → x ∈ J
Theorem: TendstoUniformlyOn.comp
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter] at h⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g✝ : ι → α
h : TendstoUniformlyOn F f p s
g : γ → α
⊢ TendstoUniformlyOn (fun n => F n ∘ g) (f ∘ g) p (g ⁻¹' s)

tactic: simpa [TendstoUniformlyOn, comap_principal] using TendstoUniformlyOnFilter.comp h g
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g✝ : ι → α
h : TendstoUniformlyOnFilter F f p (𝓟 s)
g : γ → α
⊢ TendstoUniformlyOnFilter (fun n => F n ∘ g) (f ∘ g) p (𝓟 (g ⁻¹' s))
Theorem: CategoryTheory.Limits.factorThruKernelSubobject_comp_kernelSubobjectIso
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
W : C
h : W ⟶ X
w : h ≫ f = 0
⊢ (factorThruKernelSubobject f h w ≫ (kernelSubobjectIso f).hom) ≫ kernel.ι f = kernel.lift f h w ≫ kernel.ι f
Theorem: Polynomial.expand_injective
File: Mathlib/Data/Polynomial/Expand.lean

tactic: rw [← coeff_expand_mul hn, H, coeff_expand_mul hn]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q n : ℕ
hn : 0 < n
g g' : R[X]
H : ↑(expand R n) g = ↑(expand R n) g'
k : ℕ
⊢ coeff g k = coeff g' k
Theorem: MeasureTheory.SimpleFunc.restrict_univ
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp [restrict]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.808029
δ : Type ?u.808032
inst✝¹ : MeasurableSpace α
K : Type ?u.808038
inst✝ : Zero β
f : α →ₛ β
⊢ restrict f univ = f
Theorem: Cubic.monic_of_b_eq_one
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: nontriviality R
state_before: R : Type u_1
S : Type ?u.561206
F : Type ?u.561209
K : Type ?u.561212
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 1
⊢ Monic (toPoly P)

tactic: rw [Monic, leadingCoeff_of_b_ne_zero ha (hb ▸ one_ne_zero), hb]
state_before: R : Type u_1
S : Type ?u.561206
F : Type ?u.561209
K : Type ?u.561212
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 1
✝ : Nontrivial R
⊢ Monic (toPoly P)
Theorem: RingHom.kerLift_injective
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: rw [mem_ker, map_sub, h, sub_self]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f✝ f : R →+* S
a✝ b✝ : R ⧸ ker f
a b : R
h : ↑f a = ↑f b
⊢ a - b ∈ ker f
Theorem: Mathlib.Tactic.Abel.term_atom_pfg
File: Mathlib/Tactic/Abel.lean

tactic: simp [termg, h]
state_before: α : Type u_1
inst✝ : AddCommGroup α
x x' : α
h : x = x'
⊢ x = termg 1 x' 0