1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.ofFn_congr
File: Mathlib/Data/List/OfFn.lean

tactic: subst h
state_before: α : Type u
m n : ℕ
h : m = n
f : Fin m → α
⊢ ofFn f = ofFn fun i => f (Fin.cast ⋯ i)
state_after: α : Type u
m : ℕ
f : Fin m → α
⊢ ofFn f = ofFn fun i => f (Fin.cast ⋯ i)

tactic: simp_rw [Fin.cast_refl, id]
state_before: α : Type u
m : ℕ
f : Fin m → α
⊢ ofFn f = ofFn fun i => f (Fin.cast ⋯ i)
state_after: no goals
Theorem: MvPolynomial.degrees_monomial
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: classical
  refine (supDegree_single s a).trans_le ?_
  split_ifs
  exacts [bot_le, le_rfl]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
⊢ ((monomial s) a).degrees ≤ toMultiset s
state_after: no goals

tactic: refine (supDegree_single s a).trans_le ?_
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
⊢ ((monomial s) a).degrees ≤ toMultiset s
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
⊢ (if a = 0 then ⊥ else toMultiset s) ≤ toMultiset s

tactic: split_ifs
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
⊢ (if a = 0 then ⊥ else toMultiset s) ≤ toMultiset s
state_after: case pos
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
h✝ : a = 0
⊢ ⊥ ≤ toMultiset s

case neg
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
h✝ : ¬a = 0
⊢ toMultiset s ≤ toMultiset s

tactic: exacts [bot_le, le_rfl]
state_before: case pos
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
h✝ : a = 0
⊢ ⊥ ≤ toMultiset s

case neg
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
h✝ : ¬a = 0
⊢ toMultiset s ≤ toMultiset s
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.negY_smul
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: simp only [negY, smul_fin3_ext]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ W'.negY (u • P) = u ^ 3 * W'.negY P
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ -(u ^ 3 * P y) - W'.a₁ * (u ^ 2 * P x) * (u * P z) - W'.a₃ * (u * P z) ^ 3 =
    u ^ 3 * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3)

tactic: ring1
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ -(u ^ 3 * P y) - W'.a₁ * (u ^ 2 * P x) * (u * P z) - W'.a₃ * (u * P z) ^ 3 =
    u ^ 3 * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3)
state_after: no goals
Theorem: MeasureTheory.one_le_div_ae
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: refine ⟨fun h ↦ h.mono fun a ha ↦ ?_, fun h ↦ h.mono fun a ha ↦ ?_⟩
state_before: R : Type u_1
α : Type u_2
β✝ : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β✝
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_7
inst✝² : Group β
inst✝¹ : LE β
inst✝ : CovariantClass β β (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
f g : α → β
⊢ 1 ≤ᶠ[ae μ] g / f ↔ f ≤ᶠ[ae μ] g
state_after: case refine_1
R : Type u_1
α : Type u_2
β✝ : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β✝
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_7
inst✝² : Group β
inst✝¹ : LE β
inst✝ : CovariantClass β β (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
f g : α → β
h : 1 ≤ᶠ[ae μ] g / f
a : α
ha : 1 a ≤ (g / f) a
⊢ f a ≤ g a

case refine_2
R : Type u_1
α : Type u_2
β✝ : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β✝
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_7
inst✝² : Group β
inst✝¹ : LE β
inst✝ : CovariantClass β β (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
f g : α → β
h : f ≤ᶠ[ae μ] g
a : α
ha : f a ≤ g a
⊢ 1 a ≤ (g / f) a

tactic: rwa [Pi.one_apply, Pi.div_apply, one_le_div'] at ha
state_before: case refine_1
R : Type u_1
α : Type u_2
β✝ : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β✝
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_7
inst✝² : Group β
inst✝¹ : LE β
inst✝ : CovariantClass β β (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
f g : α → β
h : 1 ≤ᶠ[ae μ] g / f
a : α
ha : 1 a ≤ (g / f) a
⊢ f a ≤ g a
state_after: no goals

tactic: rwa [Pi.one_apply, Pi.div_apply, one_le_div']
state_before: case refine_2
R : Type u_1
α : Type u_2
β✝ : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β✝
inst✝³ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_7
inst✝² : Group β
inst✝¹ : LE β
inst✝ : CovariantClass β β (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
f g : α → β
h : f ≤ᶠ[ae μ] g
a : α
ha : f a ≤ g a
⊢ 1 a ≤ (g / f) a
state_after: no goals
Theorem: div_mul_cancel_right
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← inv_div, mul_div_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b✝ c d : G
n : ℤ
a b : G
⊢ a / (b * a) = b⁻¹
state_after: no goals
Theorem: FiniteDimensional.finrank_finsupp_self
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: rw [finrank, rank_finsupp_self, ← mk_toNat_eq_card, toNat_lift]
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹³ : Ring R
inst✝¹² : CommRing S
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : Module R M
inst✝⁷ : Module R M'
inst✝⁶ : Module R M₁
inst✝⁵ : StrongRankCondition R
inst✝⁴ : Module.Free R M
inst✝³ : Module.Free R M'
inst✝² : Module.Finite R M
inst✝¹ : Module.Finite R M'
ι : Type v
inst✝ : Fintype ι
⊢ finrank R (ι →₀ R) = card ι
state_after: no goals
Theorem: Finset.sup_inf_distrib_left
File: Mathlib/Data/Finset/Lattice.lean

tactic: induction s using Finset.cons_induction with
| empty => simp_rw [Finset.sup_empty, inf_bot_eq]
| cons _ _ _ h => rw [sup_cons, sup_cons, inf_sup_left, h]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
t : Finset κ
f✝ : ι → α
g : κ → α
a✝ : α
s : Finset ι
f : ι → α
a : α
⊢ a ⊓ s.sup f = s.sup fun i => a ⊓ f i
state_after: no goals

tactic: simp_rw [Finset.sup_empty, inf_bot_eq]
state_before: case empty
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s : Finset ι
t : Finset κ
f✝ : ι → α
g : κ → α
a✝ : α
f : ι → α
a : α
⊢ a ⊓ ∅.sup f = ∅.sup fun i => a ⊓ f i
state_after: no goals

tactic: rw [sup_cons, sup_cons, inf_sup_left, h]
state_before: case cons
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s : Finset ι
t : Finset κ
f✝ : ι → α
g : κ → α
a✝¹ : α
f : ι → α
a : α
a✝ : ι
s✝ : Finset ι
h✝ : a✝ ∉ s✝
h : a ⊓ s✝.sup f = s✝.sup fun i => a ⊓ f i
⊢ a ⊓ (cons a✝ s✝ h✝).sup f = (cons a✝ s✝ h✝).sup fun i => a ⊓ f i
state_after: no goals
Theorem: Stream'.WSeq.dropn_think
File: Mathlib/Data/Seq/WSeq.lean

tactic: induction n <;> simp [*, drop]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ s.think.drop n = (s.drop n).think
state_after: no goals
Theorem: MeasureTheory.Lp.eq_zero_iff_ae_eq_zero
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: rw [← (Lp.memℒp f).toLp_eq_toLp_iff zero_memℒp, Memℒp.toLp_zero, toLp_coeFn]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : ↥(Lp E p μ)
⊢ f = 0 ↔ ↑↑f =ᶠ[ae μ] 0
state_after: no goals
Theorem: Subtype.preimage_coe_inter_self
File: Mathlib/Data/Set/Image.lean

tactic: rw [inter_comm, preimage_coe_self_inter]
state_before: α : Type u_1
s t : Set α
⊢ val ⁻¹' (t ∩ s) = val ⁻¹' t
state_after: no goals
Theorem: Con.multiset_prod
File: Mathlib/GroupTheory/Congruence/BigOperators.lean

tactic: rcases s
state_before: ι : Type u_1
M : Type u_2
inst✝ : CommMonoid M
c : Con M
s : Multiset ι
f g : ι → M
h : ∀ x ∈ s, c (f x) (g x)
⊢ c (Multiset.map f s).prod (Multiset.map g s).prod
state_after: case mk
ι : Type u_1
M : Type u_2
inst✝ : CommMonoid M
c : Con M
s : Multiset ι
f g : ι → M
a✝ : List ι
h : ∀ x ∈ Quot.mk Setoid.r a✝, c (f x) (g x)
⊢ c (Multiset.map f (Quot.mk Setoid.r a✝)).prod (Multiset.map g (Quot.mk Setoid.r a✝)).prod

tactic: simpa using c.list_prod h
state_before: case mk
ι : Type u_1
M : Type u_2
inst✝ : CommMonoid M
c : Con M
s : Multiset ι
f g : ι → M
a✝ : List ι
h : ∀ x ∈ Quot.mk Setoid.r a✝, c (f x) (g x)
⊢ c (Multiset.map f (Quot.mk Setoid.r a✝)).prod (Multiset.map g (Quot.mk Setoid.r a✝)).prod
state_after: no goals
Theorem: List.chain_singleton
File: Mathlib/Data/List/Chain.lean

tactic: simp only [chain_cons, Chain.nil, and_true_iff]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a✝ b✝ a b : α
⊢ Chain R a [b] ↔ R a b
state_after: no goals
Theorem: Lagrange.natDegree_basisDivisor_self
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [basisDivisor_self, natDegree_zero]
state_before: F : Type u_1
inst✝ : Field F
x y : F
⊢ (basisDivisor x x).natDegree = 0
state_after: no goals
Theorem: Rat.mul_eq_mkRat
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [mul_def, normalize_eq_mkRat]
state_before: q✝ q r : ℚ
⊢ q * r = mkRat (q.num * r.num) (q.den * r.den)
state_after: no goals
Theorem: TensorProduct.directSumLeft_symm_lof_tmul
File: Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean

tactic: rw [LinearEquiv.symm_apply_eq, directSumLeft_tmul_lof]
state_before: R : Type u
inst✝¹⁴ : CommSemiring R
S : Type ?u.131861
inst✝¹³ : Semiring S
inst✝¹² : Algebra R S
ι₁ : Type v₁
ι₂ : Type v₂
inst✝¹¹ : DecidableEq ι₁
inst✝¹⁰ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁹ : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)
inst✝⁸ : AddCommMonoid M₁'
inst✝⁷ : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)
inst✝⁶ : AddCommMonoid M₂'
inst✝⁵ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝⁴ : Module R M₁'
inst✝³ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝² : Module R M₂'
inst✝¹ : (i₁ : ι₁) → Module S (M₁ i₁)
inst✝ : ∀ (i₁ : ι₁), IsScalarTower R S (M₁ i₁)
i : ι₁
x : M₁ i
y : M₂'
⊢ (directSumLeft R M₁ M₂').symm ((lof R ι₁ (fun i => M₁ i ⊗[R] M₂') i) (x ⊗ₜ[R] y)) = (lof R ι₁ M₁ i) x ⊗ₜ[R] y
state_after: no goals
Theorem: SetTheory.PGame.Impartial.forall_leftMoves_fuzzy_iff_equiv_zero
File: Mathlib/SetTheory/Game/Impartial.lean

tactic: refine ⟨fun hb => ?_, fun hp i => ?_⟩
state_before: G : PGame
inst✝ : G.Impartial
⊢ (∀ (i : G.LeftMoves), G.moveLeft i ‖ 0) ↔ G ≈ 0
state_after: case refine_1
G : PGame
inst✝ : G.Impartial
hb : ∀ (i : G.LeftMoves), G.moveLeft i ‖ 0
⊢ G ≈ 0

case refine_2
G : PGame
inst✝ : G.Impartial
hp : G ≈ 0
i : G.LeftMoves
⊢ G.moveLeft i ‖ 0

tactic: rw [equiv_zero_iff_le G, le_zero_lf]
state_before: case refine_1
G : PGame
inst✝ : G.Impartial
hb : ∀ (i : G.LeftMoves), G.moveLeft i ‖ 0
⊢ G ≈ 0
state_after: case refine_1
G : PGame
inst✝ : G.Impartial
hb : ∀ (i : G.LeftMoves), G.moveLeft i ‖ 0
⊢ ∀ (i : G.LeftMoves), G.moveLeft i ⧏ 0

tactic: exact fun i => (hb i).1
state_before: case refine_1
G : PGame
inst✝ : G.Impartial
hb : ∀ (i : G.LeftMoves), G.moveLeft i ‖ 0
⊢ ∀ (i : G.LeftMoves), G.moveLeft i ⧏ 0
state_after: no goals

tactic: rw [fuzzy_zero_iff_lf]
state_before: case refine_2
G : PGame
inst✝ : G.Impartial
hp : G ≈ 0
i : G.LeftMoves
⊢ G.moveLeft i ‖ 0
state_after: case refine_2
G : PGame
inst✝ : G.Impartial
hp : G ≈ 0
i : G.LeftMoves
⊢ G.moveLeft i ⧏ 0

tactic: exact hp.1.moveLeft_lf i
state_before: case refine_2
G : PGame
inst✝ : G.Impartial
hp : G ≈ 0
i : G.LeftMoves
⊢ G.moveLeft i ⧏ 0
state_after: no goals
Theorem: CauSeq.zero_limZero
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: simpa [abv_zero abv] using ε0
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
ε : α
ε0 : ε > 0
j : ℕ
x✝ : j ≥ 0
⊢ abv (↑0 j) < ε
state_after: no goals
Theorem: Nat.Coprime.coprime_div_left
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

tactic: match eq_zero_or_pos a with
| .inl h0 =>
  rw [h0] at dvd
  rw [Nat.eq_zero_of_zero_dvd dvd] at cmn ⊢
  simp; assumption
| .inr hpos =>
  let ⟨k, hk⟩ := dvd
  rw [hk, Nat.mul_div_cancel_left _ hpos]
  rw [hk] at cmn
  exact cmn.coprime_mul_left
state_before: m n a : Nat
cmn : m.Coprime n
dvd : a ∣ m
⊢ (m / a).Coprime n
state_after: no goals

tactic: rw [h0] at dvd
state_before: m n a : Nat
cmn : m.Coprime n
dvd : a ∣ m
h0 : a = 0
⊢ (m / a).Coprime n
state_after: m n a : Nat
cmn : m.Coprime n
dvd : 0 ∣ m
h0 : a = 0
⊢ (m / a).Coprime n

tactic: rw [Nat.eq_zero_of_zero_dvd dvd] at cmn ⊢
state_before: m n a : Nat
cmn : m.Coprime n
dvd : 0 ∣ m
h0 : a = 0
⊢ (m / a).Coprime n
state_after: m n a : Nat
cmn : Coprime 0 n
dvd : 0 ∣ m
h0 : a = 0
⊢ (0 / a).Coprime n

tactic: simp
state_before: m n a : Nat
cmn : Coprime 0 n
dvd : 0 ∣ m
h0 : a = 0
⊢ (0 / a).Coprime n
state_after: m n a : Nat
cmn : Coprime 0 n
dvd : 0 ∣ m
h0 : a = 0
⊢ Coprime 0 n

tactic: assumption
state_before: m n a : Nat
cmn : Coprime 0 n
dvd : 0 ∣ m
h0 : a = 0
⊢ Coprime 0 n
state_after: no goals

tactic: let ⟨k, hk⟩ := dvd
state_before: m n a : Nat
cmn : m.Coprime n
dvd : a ∣ m
hpos : a > 0
⊢ (m / a).Coprime n
state_after: m n a : Nat
cmn : m.Coprime n
dvd : a ∣ m
hpos : a > 0
k : Nat
hk : m = a * k
⊢ (m / a).Coprime n

tactic: rw [hk, Nat.mul_div_cancel_left _ hpos]
state_before: m n a : Nat
cmn : m.Coprime n
dvd : a ∣ m
hpos : a > 0
k : Nat
hk : m = a * k
⊢ (m / a).Coprime n
state_after: m n a : Nat
cmn : m.Coprime n
dvd : a ∣ m
hpos : a > 0
k : Nat
hk : m = a * k
⊢ k.Coprime n

tactic: rw [hk] at cmn
state_before: m n a : Nat
cmn : m.Coprime n
dvd : a ∣ m
hpos : a > 0
k : Nat
hk : m = a * k
⊢ k.Coprime n
state_after: m n a : Nat
dvd : a ∣ m
hpos : a > 0
k : Nat
cmn : (a * k).Coprime n
hk : m = a * k
⊢ k.Coprime n

tactic: exact cmn.coprime_mul_left
state_before: m n a : Nat
dvd : a ∣ m
hpos : a > 0
k : Nat
cmn : (a * k).Coprime n
hk : m = a * k
⊢ k.Coprime n
state_after: no goals
Theorem: Subgroup.relindex_bot_right
File: Mathlib/GroupTheory/Index.lean

tactic: rw [relindex, subgroupOf_bot_eq_top, index_top]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ H.relindex ⊥ = 1
state_after: no goals
Theorem: Ordinal.blsub_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [o.card.lift_id]
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
c : Ordinal.{u}
ho : o.card < c.cof
hf : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi < c
⊢ Cardinal.lift.{u, u} o.card < c.cof
state_after: no goals
Theorem: Module.End.HasEigenvalue.pow
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: rw [HasEigenvalue, Submodule.ne_bot_iff]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
h : f.HasEigenvalue μ
n : ℕ
⊢ (f ^ n).HasEigenvalue (μ ^ n)
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
h : f.HasEigenvalue μ
n : ℕ
⊢ ∃ x ∈ (f ^ n).eigenspace (μ ^ n), x ≠ 0

tactic: obtain ⟨m : M, hm⟩ := h.exists_hasEigenvector
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
h : f.HasEigenvalue μ
n : ℕ
⊢ ∃ x ∈ (f ^ n).eigenspace (μ ^ n), x ≠ 0
state_after: case intro
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
h : f.HasEigenvalue μ
n : ℕ
m : M
hm : f.HasEigenvector μ m
⊢ ∃ x ∈ (f ^ n).eigenspace (μ ^ n), x ≠ 0

tactic: exact ⟨m, by simpa [mem_eigenspace_iff] using hm.pow_apply n, hm.2⟩
state_before: case intro
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
h : f.HasEigenvalue μ
n : ℕ
m : M
hm : f.HasEigenvector μ m
⊢ ∃ x ∈ (f ^ n).eigenspace (μ ^ n), x ≠ 0
state_after: no goals

tactic: simpa [mem_eigenspace_iff] using hm.pow_apply n
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
h : f.HasEigenvalue μ
n : ℕ
m : M
hm : f.HasEigenvector μ m
⊢ m ∈ (f ^ n).eigenspace (μ ^ n)
state_after: no goals
Theorem: Real.two_mul_arctan_sub_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [two_mul, arctan_add_eq_sub_pi (by nlinarith) (by linarith)]
state_before: x : ℝ
h : x < -1
⊢ 2 * arctan x = arctan (2 * x / (1 - x ^ 2)) - π
state_after: x : ℝ
h : x < -1
⊢ arctan ((x + x) / (1 - x * x)) - π = arctan (2 * x / (1 - x ^ 2)) - π

tactic: congr 2
state_before: x : ℝ
h : x < -1
⊢ arctan ((x + x) / (1 - x * x)) - π = arctan (2 * x / (1 - x ^ 2)) - π
state_after: case e_a.e_x
x : ℝ
h : x < -1
⊢ (x + x) / (1 - x * x) = 2 * x / (1 - x ^ 2)

tactic: ring
state_before: case e_a.e_x
x : ℝ
h : x < -1
⊢ (x + x) / (1 - x * x) = 2 * x / (1 - x ^ 2)
state_after: no goals

tactic: nlinarith
state_before: x : ℝ
h : x < -1
⊢ 1 < x * x
state_after: no goals

tactic: linarith
state_before: x : ℝ
h : x < -1
⊢ x < 0
state_after: no goals
Theorem: CategoryTheory.FreeMonoidalCategory.normalizeIsoApp_eq
File: Mathlib/CategoryTheory/Monoidal/Free/Coherence.lean

tactic: rw [normalizeIsoApp, normalizeIsoApp']
state_before: C : Type u
X Y : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ normalizeIsoApp C (X.tensor Y) n = normalizeIsoApp' C (X.tensor Y) n.as
state_after: C : Type u
X Y : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (α_ (inclusion.obj { as := n.as }) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp C X n) Y ≪≫ normalizeIsoApp C Y { as := X.normalizeObj n.as } =
    (α_ (inclusionObj n.as) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp' C Y (X.normalizeObj n.as)

tactic: rw [normalizeIsoApp_eq X n]
state_before: C : Type u
X Y : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (α_ (inclusion.obj { as := n.as }) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp C X n) Y ≪≫ normalizeIsoApp C Y { as := X.normalizeObj n.as } =
    (α_ (inclusionObj n.as) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp' C Y (X.normalizeObj n.as)
state_after: C : Type u
X Y : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (α_ (inclusion.obj { as := n.as }) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp C Y { as := X.normalizeObj n.as } =
    (α_ (inclusionObj n.as) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp' C Y (X.normalizeObj n.as)

tactic: rw [normalizeIsoApp_eq Y ⟨normalizeObj X n.as⟩]
state_before: C : Type u
X Y : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (α_ (inclusion.obj { as := n.as }) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp C Y { as := X.normalizeObj n.as } =
    (α_ (inclusionObj n.as) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp' C Y (X.normalizeObj n.as)
state_after: C : Type u
X Y : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (α_ (inclusion.obj { as := n.as }) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp' C Y { as := X.normalizeObj n.as }.as =
    (α_ (inclusionObj n.as) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp' C Y (X.normalizeObj n.as)

tactic: rfl
state_before: C : Type u
X Y : F C
n : (Discrete ∘ NormalMonoidalObject) C
⊢ (α_ (inclusion.obj { as := n.as }) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp' C Y { as := X.normalizeObj n.as }.as =
    (α_ (inclusionObj n.as) X Y).symm ≪≫
      whiskerRightIso (normalizeIsoApp' C X n.as) Y ≪≫ normalizeIsoApp' C Y (X.normalizeObj n.as)
state_after: no goals
Theorem: AddLECancellable.tsub_eq_of_eq_add_rev
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [add_comm, h]
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
h : a = b + c
⊢ a = c + b
state_after: no goals
Theorem: AList.insert_singleton_eq
File: Mathlib/Data/List/AList.lean

tactic: simp only [AList.insert_entries, List.kerase_cons_eq, and_self_iff, AList.singleton_entries,
  heq_iff_eq, eq_self_iff_true]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
⊢ (insert a b (singleton a b')).entries = (singleton a b).entries
state_after: no goals
Theorem: RingEquiv.toNonUnitalRingHomm_comp_symm_toNonUnitalRingHom
File: Mathlib/Algebra/Ring/Equiv.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
S' : Type u_6
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring S'
e : R ≃+* S
⊢ e.toNonUnitalRingHom.comp e.symm.toNonUnitalRingHom = NonUnitalRingHom.id S
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
S' : Type u_6
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring S'
e : R ≃+* S
x✝ : S
⊢ (e.toNonUnitalRingHom.comp e.symm.toNonUnitalRingHom) x✝ = (NonUnitalRingHom.id S) x✝

tactic: simp
state_before: case a
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
S' : Type u_6
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring S'
e : R ≃+* S
x✝ : S
⊢ (e.toNonUnitalRingHom.comp e.symm.toNonUnitalRingHom) x✝ = (NonUnitalRingHom.id S) x✝
state_after: no goals
Theorem: PowerSeries.trunc_C
File: Mathlib/RingTheory/PowerSeries/Trunc.lean

tactic: rw [coeff_trunc, coeff_C, Polynomial.coeff_C]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
⊢ (trunc (n + 1) ((C R) a)).coeff m = (Polynomial.C a).coeff m
state_after: R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
⊢ (if m < n + 1 then if m = 0 then a else 0 else 0) = if m = 0 then a else 0

tactic: split_ifs with H <;> first |rfl|try simp_all
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
⊢ (if m < n + 1 then if m = 0 then a else 0 else 0) = if m = 0 then a else 0
state_after: no goals

tactic: rfl
state_before: case neg
R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
H : ¬m < n + 1
h✝ : ¬m = 0
⊢ 0 = 0
state_after: no goals

tactic: try simp_all
state_before: case pos
R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
H : ¬m < n + 1
h✝ : m = 0
⊢ 0 = a
state_after: no goals

tactic: simp_all
state_before: case pos
R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
H : ¬m < n + 1
h✝ : m = 0
⊢ 0 = a
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyMapData.rightHomologyMap_comm
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

tactic: simp only [γ.rightHomologyMap_eq, assoc, Iso.inv_hom_id, comp_id]
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
γ : RightHomologyMapData φ h₁ h₂
inst✝¹ : S₁.HasRightHomology
inst✝ : S₂.HasRightHomology
⊢ rightHomologyMap φ ≫ h₂.rightHomologyIso.hom = h₁.rightHomologyIso.hom ≫ γ.φH
state_after: no goals