1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Dense.eq_zero_of_inner_right
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [inner_zero_right, h v]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
x y : E
hK : Dense ↑K
h : ∀ (v : ↥K), ⟪↑v, x⟫_𝕜 = 0
v : ↥K
⊢ ⟪↑v, x⟫_𝕜 = ⟪↑v, 0⟫_𝕜
state_after: no goals
Theorem: AList.keys_insert
File: Mathlib/Data/List/AList.lean

tactic: simp [insert, keys, keys_kerase]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : AList β
⊢ (insert a b s).keys = a :: s.keys.erase a
state_after: no goals
Theorem: FdRep.char_iso
File: Mathlib/RepresentationTheory/Character.lean

tactic: ext g
state_before: k : Type u
inst✝¹ : Field k
G : Type u
inst✝ : Monoid G
V W : FdRep k G
i : V ≅ W
⊢ V.character = W.character
state_after: case h
k : Type u
inst✝¹ : Field k
G : Type u
inst✝ : Monoid G
V W : FdRep k G
i : V ≅ W
g : G
⊢ V.character g = W.character g

tactic: simp only [character, FdRep.Iso.conj_ρ i]
state_before: case h
k : Type u
inst✝¹ : Field k
G : Type u
inst✝ : Monoid G
V W : FdRep k G
i : V ≅ W
g : G
⊢ V.character g = W.character g
state_after: case h
k : Type u
inst✝¹ : Field k
G : Type u
inst✝ : Monoid G
V W : FdRep k G
i : V ≅ W
g : G
⊢ (trace k (CoeSort.coe V)) (V.ρ g) = (trace k (CoeSort.coe W)) ((isoToLinearEquiv i).conj (V.ρ g))

tactic: exact (trace_conj' (V.ρ g) _).symm
state_before: case h
k : Type u
inst✝¹ : Field k
G : Type u
inst✝ : Monoid G
V W : FdRep k G
i : V ≅ W
g : G
⊢ (trace k (CoeSort.coe V)) (V.ρ g) = (trace k (CoeSort.coe W)) ((isoToLinearEquiv i).conj (V.ρ g))
state_after: no goals
Theorem: Real.Angle.two_zsmul_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: simp_rw [two_zsmul, ← two_nsmul, two_nsmul_eq_zero_iff]
state_before: θ : Angle
⊢ 2 • θ = 0 ↔ θ = 0 ∨ θ = ↑π
state_after: no goals
Theorem: Units.neg_divp
File: Mathlib/Algebra/Ring/Units.lean

tactic: simp only [divp, neg_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Monoid α
inst✝ : HasDistribNeg α
a✝ b a : α
u : αˣ
⊢ -(a /ₚ u) = -a /ₚ u
state_after: no goals
Theorem: Set.iUnion_iUnion_eq_or_left
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [iUnion_or, iUnion_union_distrib, iUnion_iUnion_eq_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
b : β
p : β → Prop
s : (x : β) → x = b ∨ p x → Set α
⊢ ⋃ x, ⋃ (h : x = b ∨ p x), s x h = s b ⋯ ∪ ⋃ x, ⋃ (h : p x), s x ⋯
state_after: no goals
Theorem: PerfectClosure.mul_aux_right
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: rw [← iterate_succ_apply, iterate_succ_apply', iterate_succ_apply', ← frobenius_mul]
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y1 y2 : ℕ × K
H : R K p y1 y2
n : ℕ
y : K
⊢ R K p (x.1 + (n, y).1, (⇑(frobenius K p))^[(n, y).1] x.2 * (⇑(frobenius K p))^[x.1] (n, y).2)
    (x.1 + (n + 1, (frobenius K p) y).1,
      (⇑(frobenius K p))^[(n + 1, (frobenius K p) y).1] x.2 * (⇑(frobenius K p))^[x.1] (n + 1, (frobenius K p) y).2)
state_after: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y1 y2 : ℕ × K
H : R K p y1 y2
n : ℕ
y : K
⊢ R K p (x.1 + (n, y).1, (⇑(frobenius K p))^[(n, y).1] x.2 * (⇑(frobenius K p))^[x.1] (n, y).2)
    (x.1 + (n + 1, (frobenius K p) y).1, (frobenius K p) ((⇑(frobenius K p))^[n] x.2 * (⇑(frobenius K p))^[x.1] y))

tactic: apply R.intro
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y1 y2 : ℕ × K
H : R K p y1 y2
n : ℕ
y : K
⊢ R K p (x.1 + (n, y).1, (⇑(frobenius K p))^[(n, y).1] x.2 * (⇑(frobenius K p))^[x.1] (n, y).2)
    (x.1 + (n + 1, (frobenius K p) y).1, (frobenius K p) ((⇑(frobenius K p))^[n] x.2 * (⇑(frobenius K p))^[x.1] y))
state_after: no goals
Theorem: Units.map_neg_one
File: Mathlib/Algebra/Ring/Units.lean

tactic: simp only [Units.map_neg, map_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝³ : Ring α
a b : α
F : Type u_1
inst✝² : Ring β
inst✝¹ : FunLike F α β
inst✝ : RingHomClass F α β
f : F
⊢ (map ↑f) (-1) = -1
state_after: no goals
Theorem: differentiableOn_neg_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [neg_neg] using h.neg
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_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
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 : DifferentiableOn 𝕜 (fun y => -f y) s
⊢ DifferentiableOn 𝕜 f s
state_after: no goals
Theorem: SimpleGraph.Walk.map_eq_of_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f✝ : G →g G'
f'✝ : G' →g G''
u v u' v' : V
p : G.Walk u v
f f' : G →g G'
h : f = f'
⊢ Walk.map f p = (Walk.map f' p).copy ⋯ ⋯
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f'✝ : G' →g G''
u v u' v' : V
p : G.Walk u v
f' : G →g G'
⊢ Walk.map f' p = (Walk.map f' p).copy ⋯ ⋯

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f'✝ : G' →g G''
u v u' v' : V
p : G.Walk u v
f' : G →g G'
⊢ Walk.map f' p = (Walk.map f' p).copy ⋯ ⋯
state_after: no goals
Theorem: Ring.isField_iff_isSimpleOrder_ideal
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: cases subsingleton_or_nontrivial R
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
⊢ IsField R ↔ IsSimpleOrder (Ideal R)
state_after: case inl
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Subsingleton R
⊢ IsField R ↔ IsSimpleOrder (Ideal R)

case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ IsField R ↔ IsSimpleOrder (Ideal R)

tactic: rw [← not_iff_not, Ring.not_isField_iff_exists_ideal_bot_lt_and_lt_top, ← not_iff_not]
state_before: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ IsField R ↔ IsSimpleOrder (Ideal R)
state_after: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (¬∃ I, ⊥ < I ∧ I < ⊤) ↔ ¬¬IsSimpleOrder (Ideal R)

tactic: push_neg
state_before: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (¬∃ I, ⊥ < I ∧ I < ⊤) ↔ ¬¬IsSimpleOrder (Ideal R)
state_after: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (∀ (I : Ideal R), ⊥ < I → ¬I < ⊤) ↔ IsSimpleOrder (Ideal R)

tactic: simp_rw [lt_top_iff_ne_top, bot_lt_iff_ne_bot, ← or_iff_not_imp_left, not_ne_iff]
state_before: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (∀ (I : Ideal R), ⊥ < I → ¬I < ⊤) ↔ IsSimpleOrder (Ideal R)
state_after: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (∀ (I : Ideal R), I = ⊥ ∨ I = ⊤) ↔ IsSimpleOrder (Ideal R)

tactic: exact ⟨fun h => ⟨h⟩, fun h => h.2⟩
state_before: case inr
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (∀ (I : Ideal R), I = ⊥ ∨ I = ⊤) ↔ IsSimpleOrder (Ideal R)
state_after: no goals

tactic: exact
  ⟨fun h => (not_isField_of_subsingleton _ h).elim, fun h =>
    (false_of_nontrivial_of_subsingleton <| Ideal R).elim⟩
state_before: case inl
α : Type u
β : Type v
R : Type u_1
inst✝ : CommSemiring R
h✝ : Subsingleton R
⊢ IsField R ↔ IsSimpleOrder (Ideal R)
state_after: no goals
Theorem: ENNReal.sSup_add
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [sSup_eq_iSup, biSup_add hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ s : Set ℝ≥0∞
hs : s.Nonempty
⊢ sSup s + a = ⨆ b ∈ s, b + a
state_after: no goals
Theorem: Matrix.nonsing_inv_nonsing_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [Matrix.one_mul]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit A.det
⊢ A⁻¹⁻¹ = 1 * A⁻¹⁻¹
state_after: no goals

tactic: rw [A.mul_nonsing_inv h]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit A.det
⊢ 1 * A⁻¹⁻¹ = A * A⁻¹ * A⁻¹⁻¹
state_after: no goals

tactic: rw [Matrix.mul_assoc, A⁻¹.mul_nonsing_inv (A.isUnit_nonsing_inv_det h), Matrix.mul_one]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit A.det
⊢ A * A⁻¹ * A⁻¹⁻¹ = A
state_after: no goals
Theorem: Class.sUnion_apply
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: constructor
state_before: x : Class
y : ZFSet
⊢ (⋃₀ x) y ↔ ∃ z, x z ∧ y ∈ z
state_after: case mp
x : Class
y : ZFSet
⊢ (⋃₀ x) y → ∃ z, x z ∧ y ∈ z

case mpr
x : Class
y : ZFSet
⊢ (∃ z, x z ∧ y ∈ z) → (⋃₀ x) y

tactic: rintro ⟨-, ⟨z, rfl, hxz⟩, hyz⟩
state_before: case mp
x : Class
y : ZFSet
⊢ (⋃₀ x) y → ∃ z, x z ∧ y ∈ z
state_after: case mp.intro.intro.intro.intro
x : Class
y z : ZFSet
hxz : x z
hyz : y ∈ ↑z
⊢ ∃ z, x z ∧ y ∈ z

tactic: exact ⟨z, hxz, hyz⟩
state_before: case mp.intro.intro.intro.intro
x : Class
y z : ZFSet
hxz : x z
hyz : y ∈ ↑z
⊢ ∃ z, x z ∧ y ∈ z
state_after: no goals

tactic: exact fun ⟨z, hxz, hyz⟩ => ⟨_, coe_mem.2 hxz, hyz⟩
state_before: case mpr
x : Class
y : ZFSet
⊢ (∃ z, x z ∧ y ∈ z) → (⋃₀ x) y
state_after: no goals
Theorem: Polynomial.restriction_one
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: rw [coeff_restriction', coeff_one, coeff_one]
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
i : ℕ
⊢ ↑((restriction 1).coeff i) = ↑(coeff 1 i)
state_after: R : Type u
S : Type u_1
inst✝ : Ring R
i : ℕ
⊢ (if i = 0 then 1 else 0) = ↑(if i = 0 then 1 else 0)

tactic: split_ifs <;> rfl
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
i : ℕ
⊢ (if i = 0 then 1 else 0) = ↑(if i = 0 then 1 else 0)
state_after: no goals
Theorem: List.modifyLast_append
File: Mathlib/Data/List/Basic.lean

tactic: cases l₂ with
| nil => contradiction
| cons hd tl =>
  cases tl with
  | nil => exact modifyLast_append_one _ hd _
  | cons hd' tl' =>
    rw [append_cons, ← nil_append (hd :: hd' :: tl'), append_cons [], nil_append,
      modifyLast_append _ (l₁ ++ [hd]) (hd' :: tl') _, modifyLast_append _ [hd] (hd' :: tl') _,
      append_assoc]
    all_goals { exact cons_ne_nil _ _ }
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
f : α → α
l₁ l₂ : List α
x✝ : l₂ ≠ []
⊢ modifyLast f (l₁ ++ l₂) = l₁ ++ modifyLast f l₂
state_after: no goals

tactic: contradiction
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ : List α
f : α → α
l₁ : List α
x✝ : [] ≠ []
⊢ modifyLast f (l₁ ++ []) = l₁ ++ modifyLast f []
state_after: no goals

tactic: cases tl with
| nil => exact modifyLast_append_one _ hd _
| cons hd' tl' =>
  rw [append_cons, ← nil_append (hd :: hd' :: tl'), append_cons [], nil_append,
    modifyLast_append _ (l₁ ++ [hd]) (hd' :: tl') _, modifyLast_append _ [hd] (hd' :: tl') _,
    append_assoc]
  all_goals { exact cons_ne_nil _ _ }
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ : List α
f : α → α
l₁ : List α
hd : α
tl : List α
x✝ : hd :: tl ≠ []
⊢ modifyLast f (l₁ ++ hd :: tl) = l₁ ++ modifyLast f (hd :: tl)
state_after: no goals

tactic: exact modifyLast_append_one _ hd _
state_before: case cons.nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ : List α
f : α → α
l₁ : List α
hd : α
x✝ : [hd] ≠ []
⊢ modifyLast f (l₁ ++ [hd]) = l₁ ++ modifyLast f [hd]
state_after: no goals

tactic: rw [append_cons, ← nil_append (hd :: hd' :: tl'), append_cons [], nil_append,
  modifyLast_append _ (l₁ ++ [hd]) (hd' :: tl') _, modifyLast_append _ [hd] (hd' :: tl') _,
  append_assoc]
state_before: case cons.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ : List α
f : α → α
l₁ : List α
hd hd' : α
tl' : List α
x✝ : hd :: hd' :: tl' ≠ []
⊢ modifyLast f (l₁ ++ hd :: hd' :: tl') = l₁ ++ modifyLast f (hd :: hd' :: tl')
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ : List α
f : α → α
l₁ : List α
hd hd' : α
tl' : List α
x✝ : hd :: hd' :: tl' ≠ []
⊢ hd' :: tl' ≠ []

ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ : List α
f : α → α
l₁ : List α
hd hd' : α
tl' : List α
x✝ : hd :: hd' :: tl' ≠ []
⊢ hd' :: tl' ≠ []

tactic: all_goals { exact cons_ne_nil _ _ }
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ : List α
f : α → α
l₁ : List α
hd hd' : α
tl' : List α
x✝ : hd :: hd' :: tl' ≠ []
⊢ hd' :: tl' ≠ []

ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ : List α
f : α → α
l₁ : List α
hd hd' : α
tl' : List α
x✝ : hd :: hd' :: tl' ≠ []
⊢ hd' :: tl' ≠ []
state_after: no goals

tactic: exact cons_ne_nil _ _
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂ : List α
f : α → α
l₁ : List α
hd hd' : α
tl' : List α
x✝ : hd :: hd' :: tl' ≠ []
⊢ hd' :: tl' ≠ []
state_after: no goals
Theorem: Action.ρ_one
File: Mathlib/RepresentationTheory/Action/Basic.lean

tactic: rw [MonoidHom.map_one]
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
A : Action V G
⊢ A.ρ 1 = 𝟙 A.V
state_after: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
A : Action V G
⊢ 1 = 𝟙 A.V

tactic: rfl
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
A : Action V G
⊢ 1 = 𝟙 A.V
state_after: no goals
Theorem: MulChar.pow_card_eq_one
File: Mathlib/NumberTheory/MulChar/Basic.lean

tactic: ext1
state_before: M : Type u_1
inst✝² : CommMonoid M
R : Type u_2
inst✝¹ : CommMonoidWithZero R
inst✝ : Fintype Mˣ
χ : MulChar M R
⊢ χ ^ Fintype.card Mˣ = 1
state_after: case h
M : Type u_1
inst✝² : CommMonoid M
R : Type u_2
inst✝¹ : CommMonoidWithZero R
inst✝ : Fintype Mˣ
χ : MulChar M R
a✝ : Mˣ
⊢ (χ ^ Fintype.card Mˣ) ↑a✝ = 1 ↑a✝

tactic: rw [pow_apply_coe, ← map_pow, one_apply_coe, ← Units.val_pow_eq_pow_val, pow_card_eq_one,
  Units.val_eq_one.mpr rfl, map_one]
state_before: case h
M : Type u_1
inst✝² : CommMonoid M
R : Type u_2
inst✝¹ : CommMonoidWithZero R
inst✝ : Fintype Mˣ
χ : MulChar M R
a✝ : Mˣ
⊢ (χ ^ Fintype.card Mˣ) ↑a✝ = 1 ↑a✝
state_after: no goals
Theorem: Monoid.PushoutI.NormalWord.prod_summand_smul
File: Mathlib/GroupTheory/PushoutI.lean

tactic: simp only [prod, summand_smul_def', equivPair, rcons, Word.equivPair_symm,
  Equiv.coe_fn_mk, Equiv.coe_fn_symm_mk, Word.equivPair_smul_same,
  Word.equivPair_tail_eq_inv_smul, Word.rcons_eq_smul, ← of_apply_eq_base φ i,
  MonoidHom.apply_ofInjective_symm, equiv_fst_eq_mul_inv, mul_assoc, map_mul, map_inv,
  Word.prod_smul, ofCoprodI_of, inv_mul_cancel_left, mul_inv_cancel_left]
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
i : ι
g : G i
w : NormalWord d
⊢ (g • w).prod = (of i) g * w.prod
state_after: no goals
Theorem: Turing.Tape.mk'_nth_nat
File: Mathlib/Computability/TuringMachine.lean

tactic: rw [← Tape.right₀_nth, Tape.mk'_right₀]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
L R : ListBlank Γ
n : ℕ
⊢ (mk' L R).nth ↑n = R.nth n
state_after: no goals
Theorem: MulAction.pow_mod_period_smul
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: conv_rhs => rw [← Nat.mod_add_div n (period m a), pow_add, mul_smul,
  pow_smul_eq_iff_period_dvd.mpr (dvd_mul_right _ _)]
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
n : ℕ
m : M
a : α
⊢ m ^ (n % period m a) • a = m ^ n • a
state_after: no goals
Theorem: CategoryTheory.ShortComplex.epi_homologyMap_of_epi_cyclesMap'
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: have : Epi (S₁.homologyπ ≫ homologyMap φ) := by
  rw [homologyπ_naturality φ]
  apply epi_comp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
h : Epi (cyclesMap φ)
⊢ Epi (homologyMap φ)
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
h : Epi (cyclesMap φ)
this : Epi (S₁.homologyπ ≫ homologyMap φ)
⊢ Epi (homologyMap φ)

tactic: exact epi_of_epi S₁.homologyπ (homologyMap φ)
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
h : Epi (cyclesMap φ)
this : Epi (S₁.homologyπ ≫ homologyMap φ)
⊢ Epi (homologyMap φ)
state_after: no goals

tactic: rw [homologyπ_naturality φ]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
h : Epi (cyclesMap φ)
⊢ Epi (S₁.homologyπ ≫ homologyMap φ)
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
h : Epi (cyclesMap φ)
⊢ Epi (cyclesMap φ ≫ S₂.homologyπ)

tactic: apply epi_comp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
h : Epi (cyclesMap φ)
⊢ Epi (cyclesMap φ ≫ S₂.homologyπ)
state_after: no goals
Theorem: AddLECancellable.tsub_le_tsub_iff_left
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: refine ⟨?_, fun h => tsub_le_tsub_left h a⟩
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
hc : AddLECancellable c
h : c ≤ a
⊢ a - b ≤ a - c ↔ c ≤ b
state_after: α : Type u_1
inst✝² : CanonicallyOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
hc : AddLECancellable c
h : c ≤ a
⊢ a - b ≤ a - c → c ≤ b

tactic: rw [tsub_le_iff_left, ← hc.add_tsub_assoc_of_le h, hc.le_tsub_iff_right (h.trans le_add_self),
  add_comm b]
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
hc : AddLECancellable c
h : c ≤ a
⊢ a - b ≤ a - c → c ≤ b
state_after: α : Type u_1
inst✝² : CanonicallyOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
hc : AddLECancellable c
h : c ≤ a
⊢ a + c ≤ a + b → c ≤ b

tactic: apply ha
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
hc : AddLECancellable c
h : c ≤ a
⊢ a + c ≤ a + b → c ≤ b
state_after: no goals
Theorem: nhdsSet_union
File: Mathlib/Topology/NhdsSet.lean

tactic: simp only [nhdsSet, image_union, sSup_union]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s✝ t✝ s₁ s₂ t₁ t₂ : Set X
x : X
s t : Set X
⊢ 𝓝ˢ (s ∪ t) = 𝓝ˢ s ⊔ 𝓝ˢ t
state_after: no goals
Theorem: Ideal.isMaximal_of_isMaximal_disjoint
File: Mathlib/RingTheory/Jacobson.lean

tactic: rw [isMaximal_iff_isMaximal_disjoint S y,
  comap_map_of_isPrime_disjoint (powers y) S I (IsMaximal.isPrime hI)
    ((disjoint_powers_iff_not_mem y hI.isPrime.isRadical).2 hy)]
state_before: R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
I✝ : Ideal R
y : R
inst✝² : Algebra R S
inst✝¹ : Away y S
inst✝ : IsJacobson R
I : Ideal R
hI : I.IsMaximal
hy : y ∉ I
⊢ (map (algebraMap R S) I).IsMaximal
state_after: R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
I✝ : Ideal R
y : R
inst✝² : Algebra R S
inst✝¹ : Away y S
inst✝ : IsJacobson R
I : Ideal R
hI : I.IsMaximal
hy : y ∉ I
⊢ I.IsMaximal ∧ y ∉ I

tactic: exact ⟨hI, hy⟩
state_before: R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
I✝ : Ideal R
y : R
inst✝² : Algebra R S
inst✝¹ : Away y S
inst✝ : IsJacobson R
I : Ideal R
hI : I.IsMaximal
hy : y ∉ I
⊢ I.IsMaximal ∧ y ∉ I
state_after: no goals
Theorem: CategoryTheory.NatTrans.app_units_zsmul
File: Mathlib/CategoryTheory/Preadditive/FunctorCategory.lean

tactic: apply app_zsmul
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{u_3, u_2} D
inst✝ : Preadditive D
F G : C ⥤ D
X : C
α : F ⟶ G
n : ℤˣ
⊢ (n • α).app X = n • α.app X
state_after: no goals
Theorem: Ordinal.toPGame_lf
File: Mathlib/SetTheory/Game/Ordinal.lean

tactic: convert moveLeft_lf (toLeftMovesToPGame ⟨a, h⟩)
state_before: a b : Ordinal.{u_1}
h : a < b
⊢ a.toPGame ⧏ b.toPGame
state_after: case h.e'_1
a b : Ordinal.{u_1}
h : a < b
⊢ a.toPGame = b.toPGame.moveLeft (toLeftMovesToPGame ⟨a, h⟩)

tactic: rw [toPGame_moveLeft]
state_before: case h.e'_1
a b : Ordinal.{u_1}
h : a < b
⊢ a.toPGame = b.toPGame.moveLeft (toLeftMovesToPGame ⟨a, h⟩)
state_after: no goals
Theorem: PerfectPairing.toDualRight_symm_comp_toDualLeft
File: Mathlib/LinearAlgebra/PerfectPairing.lean

tactic: ext1 x
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
⊢ ↑p.toDualRight.symm.dualMap ∘ₗ ↑p.toDualLeft = Dual.eval R M
state_after: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
⊢ (↑p.toDualRight.symm.dualMap ∘ₗ ↑p.toDualLeft) x = (Dual.eval R M) x

tactic: exact p.toDualRight_symm_toDualLeft x
state_before: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
⊢ (↑p.toDualRight.symm.dualMap ∘ₗ ↑p.toDualLeft) x = (Dual.eval R M) x
state_after: no goals
Theorem: Real.hasDerivWithinAt_arcsin_Ici
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean

tactic: rcases eq_or_ne x 1 with (rfl | h')
state_before: x : ℝ
h : x ≠ -1
⊢ HasDerivWithinAt arcsin (1 / √(1 - x ^ 2)) (Ici x) x
state_after: case inl
h : 1 ≠ -1
⊢ HasDerivWithinAt arcsin (1 / √(1 - 1 ^ 2)) (Ici 1) 1

case inr
x : ℝ
h : x ≠ -1
h' : x ≠ 1
⊢ HasDerivWithinAt arcsin (1 / √(1 - x ^ 2)) (Ici x) x

tactic: convert (hasDerivWithinAt_const (1 : ℝ) _ (π / 2)).congr _ _ <;>
  simp (config := { contextual := true }) [arcsin_of_one_le]
state_before: case inl
h : 1 ≠ -1
⊢ HasDerivWithinAt arcsin (1 / √(1 - 1 ^ 2)) (Ici 1) 1
state_after: no goals

tactic: exact (hasDerivAt_arcsin h h').hasDerivWithinAt
state_before: case inr
x : ℝ
h : x ≠ -1
h' : x ≠ 1
⊢ HasDerivWithinAt arcsin (1 / √(1 - x ^ 2)) (Ici x) x
state_after: no goals