1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.range_rec
File: Mathlib/Data/Nat/Set.lean

tactic: convert (range_of_succ (fun n => Nat.rec x f n : ℕ → α)).symm using 4
state_before: α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
⊢ (range fun n => rec x f n) = {x} ∪ range fun n => rec (f 0 x) (f ∘ succ) n
state_after: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
x✝ : ℕ
⊢ rec (f 0 x) (f ∘ succ) x✝ = ((fun n => rec x f n) ∘ succ) x✝

tactic: dsimp
state_before: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
x✝ : ℕ
⊢ rec (f 0 x) (f ∘ succ) x✝ = ((fun n => rec x f n) ∘ succ) x✝
state_after: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
x✝ : ℕ
⊢ rec (f 0 x) (f ∘ succ) x✝ = f x✝ (rec x f x✝)

tactic: rename_i n
state_before: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
x✝ : ℕ
⊢ rec (f 0 x) (f ∘ succ) x✝ = f x✝ (rec x f x✝)
state_after: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
n : ℕ
⊢ rec (f 0 x) (f ∘ succ) n = f n (rec x f n)

tactic: induction' n with n ihn
state_before: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
n : ℕ
⊢ rec (f 0 x) (f ∘ succ) n = f n (rec x f n)
state_after: case h.e'_3.h.e'_4.h.e'_3.h.zero
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
⊢ rec (f 0 x) (f ∘ succ) 0 = f 0 (rec x f 0)

case h.e'_3.h.e'_4.h.e'_3.h.succ
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
n : ℕ
ihn : rec (f 0 x) (f ∘ succ) n = f n (rec x f n)
⊢ rec (f 0 x) (f ∘ succ) (n + 1) = f (n + 1) (rec x f (n + 1))

tactic: rfl
state_before: case h.e'_3.h.e'_4.h.e'_3.h.zero
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
⊢ rec (f 0 x) (f ∘ succ) 0 = f 0 (rec x f 0)
state_after: no goals

tactic: dsimp at ihn ⊢
state_before: case h.e'_3.h.e'_4.h.e'_3.h.succ
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
n : ℕ
ihn : rec (f 0 x) (f ∘ succ) n = f n (rec x f n)
⊢ rec (f 0 x) (f ∘ succ) (n + 1) = f (n + 1) (rec x f (n + 1))
state_after: case h.e'_3.h.e'_4.h.e'_3.h.succ
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
n : ℕ
ihn : rec (f 0 x) (f ∘ succ) n = f n (rec x f n)
⊢ f (n + 1) (rec (f 0 x) (f ∘ succ) n) = f (n + 1) (f n (rec x f n))

tactic: rw [ihn]
state_before: case h.e'_3.h.e'_4.h.e'_3.h.succ
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
n : ℕ
ihn : rec (f 0 x) (f ∘ succ) n = f n (rec x f n)
⊢ f (n + 1) (rec (f 0 x) (f ∘ succ) n) = f (n + 1) (f n (rec x f n))
state_after: no goals
Theorem: ByteArray.size_append
File: .lake/packages/batteries/Batteries/Data/ByteArray.lean

tactic: simp only [size, append_eq, append_data]
state_before: a b : ByteArray
⊢ (a ++ b).size = a.size + b.size
state_after: a b : ByteArray
⊢ (a.data ++ b.data).size = a.data.size + b.data.size

tactic: exact Array.size_append ..
state_before: a b : ByteArray
⊢ (a.data ++ b.data).size = a.data.size + b.data.size
state_after: no goals
Theorem: Caratheodory.minCardFinsetOfMemConvexHull_nonempty
File: Mathlib/Analysis/Convex/Caratheodory.lean

tactic: rw [← Finset.coe_nonempty, ← @convexHull_nonempty_iff 𝕜]
state_before: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
⊢ (minCardFinsetOfMemConvexHull hx).Nonempty
state_after: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
⊢ ((convexHull 𝕜) ↑(minCardFinsetOfMemConvexHull hx)).Nonempty

tactic: exact ⟨x, mem_minCardFinsetOfMemConvexHull hx⟩
state_before: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
⊢ ((convexHull 𝕜) ↑(minCardFinsetOfMemConvexHull hx)).Nonempty
state_after: no goals
Theorem: Filter.EventuallyLE.sup
File: Mathlib/Order/Filter/Basic.lean

tactic: filter_upwards [hf, hg] with x hfx hgx using sup_le_sup hfx hgx
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l✝ : Filter α
inst✝ : SemilatticeSup β
l : Filter α
f₁ f₂ g₁ g₂ : α → β
hf : f₁ ≤ᶠ[l] f₂
hg : g₁ ≤ᶠ[l] g₂
⊢ f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂
state_after: no goals
Theorem: div_eq_mul_one_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, one_div]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivInvMonoid G
a✝ b✝ c a b : G
⊢ a / b = a * (1 / b)
state_after: no goals
Theorem: Polynomial.unique_int_coeff_of_cycl
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: obtain ⟨P, hP⟩ := int_coeff_of_cyclotomic' h
state_before: K✝ : Type u_1
inst✝³ : Field K✝
K : Type u_2
inst✝² : CommRing K
inst✝¹ : IsDomain K
inst✝ : CharZero K
ζ : K
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
⊢ ∃! P, map (Int.castRingHom K) P = cyclotomic' (↑n) K
state_after: case intro
K✝ : Type u_1
inst✝³ : Field K✝
K : Type u_2
inst✝² : CommRing K
inst✝¹ : IsDomain K
inst✝ : CharZero K
ζ : K
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
P : ℤ[X]
hP : map (Int.castRingHom K) P = cyclotomic' (↑n) K ∧ P.degree = (cyclotomic' (↑n) K).degree ∧ P.Monic
⊢ ∃! P, map (Int.castRingHom K) P = cyclotomic' (↑n) K

tactic: refine ⟨P, hP.1, fun Q hQ => ?_⟩
state_before: case intro
K✝ : Type u_1
inst✝³ : Field K✝
K : Type u_2
inst✝² : CommRing K
inst✝¹ : IsDomain K
inst✝ : CharZero K
ζ : K
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
P : ℤ[X]
hP : map (Int.castRingHom K) P = cyclotomic' (↑n) K ∧ P.degree = (cyclotomic' (↑n) K).degree ∧ P.Monic
⊢ ∃! P, map (Int.castRingHom K) P = cyclotomic' (↑n) K
state_after: case intro
K✝ : Type u_1
inst✝³ : Field K✝
K : Type u_2
inst✝² : CommRing K
inst✝¹ : IsDomain K
inst✝ : CharZero K
ζ : K
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
P : ℤ[X]
hP : map (Int.castRingHom K) P = cyclotomic' (↑n) K ∧ P.degree = (cyclotomic' (↑n) K).degree ∧ P.Monic
Q : ℤ[X]
hQ : (fun P => map (Int.castRingHom K) P = cyclotomic' (↑n) K) Q
⊢ Q = P

tactic: apply map_injective (Int.castRingHom K) Int.cast_injective
state_before: case intro
K✝ : Type u_1
inst✝³ : Field K✝
K : Type u_2
inst✝² : CommRing K
inst✝¹ : IsDomain K
inst✝ : CharZero K
ζ : K
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
P : ℤ[X]
hP : map (Int.castRingHom K) P = cyclotomic' (↑n) K ∧ P.degree = (cyclotomic' (↑n) K).degree ∧ P.Monic
Q : ℤ[X]
hQ : (fun P => map (Int.castRingHom K) P = cyclotomic' (↑n) K) Q
⊢ Q = P
state_after: case intro.a
K✝ : Type u_1
inst✝³ : Field K✝
K : Type u_2
inst✝² : CommRing K
inst✝¹ : IsDomain K
inst✝ : CharZero K
ζ : K
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
P : ℤ[X]
hP : map (Int.castRingHom K) P = cyclotomic' (↑n) K ∧ P.degree = (cyclotomic' (↑n) K).degree ∧ P.Monic
Q : ℤ[X]
hQ : (fun P => map (Int.castRingHom K) P = cyclotomic' (↑n) K) Q
⊢ map (Int.castRingHom K) Q = map (Int.castRingHom K) P

tactic: rw [hP.1, hQ]
state_before: case intro.a
K✝ : Type u_1
inst✝³ : Field K✝
K : Type u_2
inst✝² : CommRing K
inst✝¹ : IsDomain K
inst✝ : CharZero K
ζ : K
n : ℕ+
h : IsPrimitiveRoot ζ ↑n
P : ℤ[X]
hP : map (Int.castRingHom K) P = cyclotomic' (↑n) K ∧ P.degree = (cyclotomic' (↑n) K).degree ∧ P.Monic
Q : ℤ[X]
hQ : (fun P => map (Int.castRingHom K) P = cyclotomic' (↑n) K) Q
⊢ map (Int.castRingHom K) Q = map (Int.castRingHom K) P
state_after: no goals
Theorem: Function.extend_one
File: Mathlib/Algebra/Group/Pi/Basic.lean

tactic: apply ite_self
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : One γ
f : α → β
x✝ : β
⊢ extend f 1 1 x✝ = 1 x✝
state_after: no goals
Theorem: Finset.sigma_eq_empty
File: Mathlib/Data/Finset/Sigma.lean

tactic: simp only [← not_nonempty_iff_eq_empty, sigma_nonempty, not_exists, not_and]
state_before: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
⊢ s.sigma t = ∅ ↔ ∀ i ∈ s, t i = ∅
state_after: no goals
Theorem: Mathlib.Meta.Positivity.nz_of_isNegNat
File: Mathlib/Tactic/Positivity/Core.lean

tactic: rw [NormNum.IsInt.neg_to_eq h rfl]
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedRing A
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.ble 1 n = true
⊢ e ≠ 0
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedRing A
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.ble 1 n = true
⊢ -↑n ≠ 0

tactic: simp only [ne_eq, neg_eq_zero]
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedRing A
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.ble 1 n = true
⊢ -↑n ≠ 0
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedRing A
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.ble 1 n = true
⊢ ¬↑n = 0

tactic: apply ne_of_gt
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedRing A
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.ble 1 n = true
⊢ ¬↑n = 0
state_after: case h
u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedRing A
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.ble 1 n = true
⊢ 0 < ↑n

tactic: simpa using w
state_before: case h
u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedRing A
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.ble 1 n = true
⊢ 0 < ↑n
state_after: no goals
Theorem: Int.modEq_neg
File: Mathlib/Data/Int/ModEq.lean

tactic: simp [modEq_iff_dvd]
state_before: m n a b c d : ℤ
⊢ a ≡ b [ZMOD -n] ↔ a ≡ b [ZMOD n]
state_after: no goals
Theorem: congr_eqRec
File: .lake/packages/batteries/Batteries/Logic.lean

tactic: cases h
state_before: α : Sort u_1
γ : Sort u_2
x x' : α
β : α → Sort u_3
f : (x : α) → β x → γ
h : x = x'
y : β x
⊢ f x' (h ▸ y) = f x y
state_after: case refl
α : Sort u_1
γ : Sort u_2
x : α
β : α → Sort u_3
f : (x : α) → β x → γ
y : β x
⊢ f x (⋯ ▸ y) = f x y

tactic: rfl
state_before: case refl
α : Sort u_1
γ : Sort u_2
x : α
β : α → Sort u_3
f : (x : α) → β x → γ
y : β x
⊢ f x (⋯ ▸ y) = f x y
state_after: no goals
Theorem: IsCyclotomicExtension.Rat.discr_prime_pow_eq_unit_mul_pow'
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

tactic: rw [hζ.discr_zeta_eq_discr_zeta_sub_one.symm]
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ ∃ u n, Algebra.discr ℚ ⇑(IsPrimitiveRoot.subOnePowerBasis ℚ hζ).basis = ↑↑u * ↑↑p ^ n
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ ∃ u n, Algebra.discr ℚ ⇑(IsPrimitiveRoot.powerBasis ℚ hζ).basis = ↑↑u * ↑↑p ^ n

tactic: exact discr_prime_pow_eq_unit_mul_pow hζ (cyclotomic.irreducible_rat (p ^ k).pos)
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ ∃ u n, Algebra.discr ℚ ⇑(IsPrimitiveRoot.powerBasis ℚ hζ).basis = ↑↑u * ↑↑p ^ n
state_after: no goals
Theorem: Set.sigma_univ_range_eq
File: Mathlib/Data/Set/Sigma.lean

tactic: simp [range]
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝² : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
β✝¹ : Type u_5
inst✝ : CompleteLattice β✝¹
β✝ : Type u_6
β : ι → Type u_7
f : (i : ι) → α i → β i
⊢ ∀ (x : (i : ι) × β i), (x ∈ univ.sigma fun i => range (f i)) ↔ x ∈ range fun x => ⟨x.fst, f x.fst x.snd⟩
state_after: no goals
Theorem: PartialEquiv.trans_refl
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: simp [trans_source]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
⊢ (e.trans (PartialEquiv.refl β)).source = e.source
state_after: no goals
Theorem: thickening_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [← cthickening_singleton _ hδ, thickening_cthickening hε hδ, thickening_singleton]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ ε : ℝ
hε : 0 < ε
hδ : 0 ≤ δ
x : E
⊢ thickening ε (Metric.closedBall x δ) = Metric.ball x (ε + δ)
state_after: no goals
Theorem: Real.rpow_le_rpow_of_exponent_nonpos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases ne_or_eq z 0 with hz_zero | rfl
state_before: x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : z ≤ 0
⊢ x ^ z ≤ y ^ z
state_after: case inl
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : z ≤ 0
hz_zero : z ≠ 0
⊢ x ^ z ≤ y ^ z

case inr
x✝ y✝ : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : 0 ≤ 0
⊢ x ^ 0 ≤ y ^ 0

tactic: case inl =>
  rcases ne_or_eq x y with hxy' | rfl
  case inl =>
    exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
      (Ne.lt_of_le hz_zero hz)
  case inr => simp
state_before: case inl
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : z ≤ 0
hz_zero : z ≠ 0
⊢ x ^ z ≤ y ^ z

case inr
x✝ y✝ : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : 0 ≤ 0
⊢ x ^ 0 ≤ y ^ 0
state_after: case inr
x✝ y✝ : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : 0 ≤ 0
⊢ x ^ 0 ≤ y ^ 0

tactic: case inr => simp
state_before: case inr
x✝ y✝ : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : 0 ≤ 0
⊢ x ^ 0 ≤ y ^ 0
state_after: no goals

tactic: rcases ne_or_eq x y with hxy' | rfl
state_before: x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : z ≤ 0
hz_zero : z ≠ 0
⊢ x ^ z ≤ y ^ z
state_after: case inl
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : z ≤ 0
hz_zero : z ≠ 0
hxy' : x ≠ y
⊢ x ^ z ≤ y ^ z

case inr
x✝ y z : ℝ
n : ℕ
x : ℝ
hz : z ≤ 0
hz_zero : z ≠ 0
hy : 0 < x
hxy : x ≤ x
⊢ x ^ z ≤ x ^ z

tactic: case inl =>
  exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
    (Ne.lt_of_le hz_zero hz)
state_before: case inl
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : z ≤ 0
hz_zero : z ≠ 0
hxy' : x ≠ y
⊢ x ^ z ≤ y ^ z

case inr
x✝ y z : ℝ
n : ℕ
x : ℝ
hz : z ≤ 0
hz_zero : z ≠ 0
hy : 0 < x
hxy : x ≤ x
⊢ x ^ z ≤ x ^ z
state_after: case inr
x✝ y z : ℝ
n : ℕ
x : ℝ
hz : z ≤ 0
hz_zero : z ≠ 0
hy : 0 < x
hxy : x ≤ x
⊢ x ^ z ≤ x ^ z

tactic: case inr => simp
state_before: case inr
x✝ y z : ℝ
n : ℕ
x : ℝ
hz : z ≤ 0
hz_zero : z ≠ 0
hy : 0 < x
hxy : x ≤ x
⊢ x ^ z ≤ x ^ z
state_after: no goals

tactic: exact le_of_lt <| rpow_lt_rpow_of_exponent_neg hy (Ne.lt_of_le (id (Ne.symm hxy')) hxy)
  (Ne.lt_of_le hz_zero hz)
state_before: x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : z ≤ 0
hz_zero : z ≠ 0
hxy' : x ≠ y
⊢ x ^ z ≤ y ^ z
state_after: no goals

tactic: simp
state_before: x✝ y z : ℝ
n : ℕ
x : ℝ
hz : z ≤ 0
hz_zero : z ≠ 0
hy : 0 < x
hxy : x ≤ x
⊢ x ^ z ≤ x ^ z
state_after: no goals

tactic: simp
state_before: x✝ y✝ : ℝ
n : ℕ
x y : ℝ
hy : 0 < y
hxy : y ≤ x
hz : 0 ≤ 0
⊢ x ^ 0 ≤ y ^ 0
state_after: no goals
Theorem: List.toFinset_finRange
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
⊢ (finRange n).toFinset = univ
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
a✝ : Fin n
⊢ a✝ ∈ (finRange n).toFinset ↔ a✝ ∈ univ

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
a✝ : Fin n
⊢ a✝ ∈ (finRange n).toFinset ↔ a✝ ∈ univ
state_after: no goals
Theorem: List.foldlIdxM_eq_foldlM_enum
File: Mathlib/Data/List/Indexes.lean

tactic: rw [foldlIdxM, foldlM_eq_foldl, foldlIdx_eq_foldl_enum]
state_before: α : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
β : Type u
f : ℕ → β → α → m β
b : β
as : List α
⊢ foldlIdxM f b as = List.foldlM (fun b p => f p.1 b p.2) b as.enum
state_after: no goals
Theorem: List.Perm.kerase
File: Mathlib/Data/List/Sigma.lean

tactic: apply Perm.eraseP
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd : l₁.NodupKeys
⊢ l₁ ~ l₂ → List.kerase a l₁ ~ List.kerase a l₂
state_after: case H
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd : l₁.NodupKeys
⊢ Pairwise (fun a_1 b => decide (a = a_1.fst) = true → decide (a = b.fst) = true → False) l₁

tactic: apply (nodupKeys_iff_pairwise.1 nd).imp
state_before: case H
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd : l₁.NodupKeys
⊢ Pairwise (fun a_1 b => decide (a = a_1.fst) = true → decide (a = b.fst) = true → False) l₁
state_after: case H
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd : l₁.NodupKeys
⊢ ∀ {a_1 b : Sigma β}, a_1.fst ≠ b.fst → decide (a = a_1.fst) = true → decide (a = b.fst) = true → False

tactic: intros
state_before: case H
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd : l₁.NodupKeys
⊢ ∀ {a_1 b : Sigma β}, a_1.fst ≠ b.fst → decide (a = a_1.fst) = true → decide (a = b.fst) = true → False
state_after: case H
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd : l₁.NodupKeys
a✝³ b✝ : Sigma β
a✝² : a✝³.fst ≠ b✝.fst
a✝¹ : decide (a = a✝³.fst) = true
a✝ : decide (a = b✝.fst) = true
⊢ False

tactic: simp_all
state_before: case H
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd : l₁.NodupKeys
a✝³ b✝ : Sigma β
a✝² : a✝³.fst ≠ b✝.fst
a✝¹ : decide (a = a✝³.fst) = true
a✝ : decide (a = b✝.fst) = true
⊢ False
state_after: no goals
Theorem: WithZeroTopology.isClosed_iff
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: simp only [← isOpen_compl_iff, isOpen_iff, mem_compl_iff, not_not, ← compl_Ici,
  compl_subset_compl]
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
s : Set Γ₀
⊢ IsClosed s ↔ 0 ∈ s ∨ ∃ γ, γ ≠ 0 ∧ s ⊆ Ici γ
state_after: no goals
Theorem: IsClosedMap.of_inverse
File: Mathlib/Topology/Maps.lean

tactic: rw [image_eq_preimage_of_inverse r_inv l_inv]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f' : Y → X
h : Continuous f'
l_inv : LeftInverse f f'
r_inv : Function.RightInverse f f'
s : Set X
hs : IsClosed s
⊢ IsClosed (f '' s)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f' : Y → X
h : Continuous f'
l_inv : LeftInverse f f'
r_inv : Function.RightInverse f f'
s : Set X
hs : IsClosed s
⊢ IsClosed (f' ⁻¹' s)

tactic: exact hs.preimage h
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f' : Y → X
h : Continuous f'
l_inv : LeftInverse f f'
r_inv : Function.RightInverse f f'
s : Set X
hs : IsClosed s
⊢ IsClosed (f' ⁻¹' s)
state_after: no goals
Theorem: Finset.prod_partition
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: refine (Finset.prod_image' f fun x _hx => ?_).symm
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
R : Setoid α
inst✝ : DecidableRel Setoid.r
⊢ ∏ x ∈ s, f x = ∏ xbar ∈ image Quotient.mk'' s, ∏ y ∈ filter (fun x => ⟦x⟧ = xbar) s, f y
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
R : Setoid α
inst✝ : DecidableRel Setoid.r
x : α
_hx : x ∈ s
⊢ ∏ y ∈ filter (fun x_1 => ⟦x_1⟧ = Quotient.mk'' x) s, f y =
    ∏ x ∈ filter (fun c' => Quotient.mk'' c' = Quotient.mk'' x) s, f x

tactic: rfl
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
R : Setoid α
inst✝ : DecidableRel Setoid.r
x : α
_hx : x ∈ s
⊢ ∏ y ∈ filter (fun x_1 => ⟦x_1⟧ = Quotient.mk'' x) s, f y =
    ∏ x ∈ filter (fun c' => Quotient.mk'' c' = Quotient.mk'' x) s, f x
state_after: no goals
Theorem: Rep.linearization_μ_inv_hom
File: Mathlib/RepresentationTheory/Rep.lean

tactic: rw [← Action.forget_map, Functor.map_inv]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : Action (Type u) (MonCat.of G)
f : X✝ ⟶ Y✝
X Y : Action (Type u) (MonCat.of G)
⊢ (inv ((linearization k G).μ X Y)).hom = ↑(finsuppTensorFinsupp' k X.V Y.V).symm
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : Action (Type u) (MonCat.of G)
f : X✝ ⟶ Y✝
X Y : Action (Type u) (MonCat.of G)
⊢ inv ((Action.forget (ModuleCat k) (MonCat.of G)).map ((linearization k G).μ X Y)) =
    ↑(finsuppTensorFinsupp' k X.V Y.V).symm

tactic: apply IsIso.inv_eq_of_hom_inv_id
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : Action (Type u) (MonCat.of G)
f : X✝ ⟶ Y✝
X Y : Action (Type u) (MonCat.of G)
⊢ inv ((Action.forget (ModuleCat k) (MonCat.of G)).map ((linearization k G).μ X Y)) =
    ↑(finsuppTensorFinsupp' k X.V Y.V).symm
state_after: case hom_inv_id
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : Action (Type u) (MonCat.of G)
f : X✝ ⟶ Y✝
X Y : Action (Type u) (MonCat.of G)
⊢ (Action.forget (ModuleCat k) (MonCat.of G)).map ((linearization k G).μ X Y) ≫
      ↑(finsuppTensorFinsupp' k X.V Y.V).symm =
    𝟙
      ((Action.forget (ModuleCat k) (MonCat.of G)).obj
        (MonoidalCategory.tensorObj ((linearization k G).obj X) ((linearization k G).obj Y)))

tactic: exact LinearMap.ext fun x => LinearEquiv.symm_apply_apply (finsuppTensorFinsupp' k X.V Y.V) x
state_before: case hom_inv_id
k G : Type u
inst✝¹ : CommRing k
inst✝ : Monoid G
X✝ Y✝ : Action (Type u) (MonCat.of G)
f : X✝ ⟶ Y✝
X Y : Action (Type u) (MonCat.of G)
⊢ (Action.forget (ModuleCat k) (MonCat.of G)).map ((linearization k G).μ X Y) ≫
      ↑(finsuppTensorFinsupp' k X.V Y.V).symm =
    𝟙
      ((Action.forget (ModuleCat k) (MonCat.of G)).obj
        (MonoidalCategory.tensorObj ((linearization k G).obj X) ((linearization k G).obj Y)))
state_after: no goals
Theorem: SemiconjBy.zero_left
File: Mathlib/Algebra/GroupWithZero/Semiconj.lean

tactic: simp only [SemiconjBy, mul_zero, zero_mul]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MulZeroClass G₀
x y : G₀
⊢ SemiconjBy 0 x y
state_after: no goals
Theorem: CategoryTheory.Limits.WidePullback.lift_π
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

tactic: simp only [limit.lift_π, WidePullbackShape.mkCone_pt, WidePullbackShape.mkCone_π_app]
state_before: J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
j : J
⊢ lift f fs w ≫ π arrows j = fs j
state_after: no goals
Theorem: real_inner_smul_self_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [inner_smul_right, ← real_inner_self_eq_norm_mul_norm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
r : ℝ
⊢ ⟪x, r • x⟫_ℝ = r * (‖x‖ * ‖x‖)
state_after: no goals
Theorem: List.modifyNth_eq_set_get?
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
f : α → α
l : List α
⊢ modifyNth f 0 l = ((fun a => l.set 0 (f a)) <$> l.get? 0).getD l
state_after: no goals

tactic: cases h : l[n]? <;> simp [h]
state_before: α : Type u_1
f : α → α
n : Nat
b : α
l : List α
⊢ b :: ((fun a => l.set n (f a)) <$> l.get? n).getD l =
    ((fun a => (b :: l).set (n + 1) (f a)) <$> (b :: l).get? (n + 1)).getD (b :: l)
state_after: no goals