1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: mem_perms_of_finset_iff
File: Mathlib/Data/Fintype/Perm.lean

tactic: rintro ⟨⟨l⟩, hs⟩ f
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∀ {s : Finset α} {f : Equiv.Perm α}, f ∈ permsOfFinset s ↔ ∀ {x : α}, f x ≠ x → x ∈ s
state_after: case mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
val✝ : Multiset α
l : List α
hs : Multiset.Nodup (Quot.mk Setoid.r l)
f : Equiv.Perm α
⊢ f ∈ permsOfFinset { val := Quot.mk Setoid.r l, nodup := hs } ↔
    ∀ {x : α}, f x ≠ x → x ∈ { val := Quot.mk Setoid.r l, nodup := hs }

tactic: exact mem_permsOfList_iff
state_before: case mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
val✝ : Multiset α
l : List α
hs : Multiset.Nodup (Quot.mk Setoid.r l)
f : Equiv.Perm α
⊢ f ∈ permsOfFinset { val := Quot.mk Setoid.r l, nodup := hs } ↔
    ∀ {x : α}, f x ≠ x → x ∈ { val := Quot.mk Setoid.r l, nodup := hs }
state_after: no goals
Theorem: descPochhammer_succ_left
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: rw [descPochhammer]
state_before: R : Type u
inst✝ : Ring R
n : ℕ
⊢ descPochhammer R (n + 1) = X * (descPochhammer R n).comp (X - 1)
state_after: no goals
Theorem: Stream'.Seq.eq_or_mem_of_mem_cons
File: Mathlib/Data/Seq/Seq.lean

tactic: injection h
state_before: α : Type u
β : Type v
γ : Type w
a b : α
f : Stream' (Option α)
al : f.IsSeq
h✝ : a ∈ cons b ⟨f, al⟩
h : some a = some b
⊢ a = b
state_after: no goals
Theorem: PartENat.ne_top_iff_dom
File: Mathlib/Data/Nat/PartENat.lean

tactic: classical exact not_iff_comm.1 Part.eq_none_iff'.symm
state_before: x : PartENat
⊢ x ≠ ⊤ ↔ x.Dom
state_after: no goals

tactic: exact not_iff_comm.1 Part.eq_none_iff'.symm
state_before: x : PartENat
⊢ x ≠ ⊤ ↔ x.Dom
state_after: no goals
Theorem: UniformInducing.equicontinuous_iff
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: congrm ∀ x, ?_
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
u : α → β
hu : UniformInducing u
⊢ Equicontinuous F ↔ Equicontinuous ((fun x => u ∘ x) ∘ F)
state_after: case a
ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
u : α → β
hu : UniformInducing u
x : X
⊢ EquicontinuousAt F x ↔ EquicontinuousAt ((fun x => u ∘ x) ∘ F) x

tactic: rw [hu.equicontinuousAt_iff]
state_before: case a
ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
u : α → β
hu : UniformInducing u
x : X
⊢ EquicontinuousAt F x ↔ EquicontinuousAt ((fun x => u ∘ x) ∘ F) x
state_after: no goals
Theorem: Mathlib.Meta.NormNum.jacobiSymNat.even_odd₁
File: Mathlib/Tactic/NormNum/LegendreSymbol.lean

tactic: simp only [jacobiSymNat, ← hr, ← hc, Int.ofNat_ediv, Nat.cast_ofNat]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSymNat a b = r
state_after: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSym (↑a) b = jacobiSym (↑a / 2) b

tactic: rw [← jacobiSym.even_odd (mod_cast ha), if_neg (by simp [hb])]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSym (↑a) b = jacobiSym (↑a / 2) b
state_after: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ b % 2 = 1

tactic: rw [← Nat.mod_mod_of_dvd, hb]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ b % 2 = 1
state_after: case h
a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ 2 ∣ 8

tactic: norm_num
state_before: case h
a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ 2 ∣ 8
state_after: no goals

tactic: simp [hb]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ ¬(b % 8 = 3 ∨ b % 8 = 5)
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.addX_of_Z_eq_zero_left
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [addX, hPz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hPz : P z = 0
⊢ W'.addX P Q = (P x * Q z) ^ 2 * Q x
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hPz : P z = 0
⊢ P x * Q x ^ 2 * 0 ^ 2 - 2 * P y * Q y * 0 * Q z + P x ^ 2 * Q x * Q z ^ 2 - W'.a₁ * P x * Q y * 0 ^ 2 * Q z -
                  W'.a₁ * P y * Q x * 0 * Q z ^ 2 +
                2 * W'.a₂ * P x * Q x * 0 ^ 2 * Q z ^ 2 -
              W'.a₃ * Q y * 0 ^ 4 * Q z -
            W'.a₃ * P y * 0 * Q z ^ 4 +
          W'.a₄ * Q x * 0 ^ 4 * Q z ^ 2 +
        W'.a₄ * P x * 0 ^ 2 * Q z ^ 4 +
      2 * W'.a₆ * 0 ^ 4 * Q z ^ 4 =
    (P x * Q z) ^ 2 * Q x

tactic: ring1
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hPz : P z = 0
⊢ P x * Q x ^ 2 * 0 ^ 2 - 2 * P y * Q y * 0 * Q z + P x ^ 2 * Q x * Q z ^ 2 - W'.a₁ * P x * Q y * 0 ^ 2 * Q z -
                  W'.a₁ * P y * Q x * 0 * Q z ^ 2 +
                2 * W'.a₂ * P x * Q x * 0 ^ 2 * Q z ^ 2 -
              W'.a₃ * Q y * 0 ^ 4 * Q z -
            W'.a₃ * P y * 0 * Q z ^ 4 +
          W'.a₄ * Q x * 0 ^ 4 * Q z ^ 2 +
        W'.a₄ * P x * 0 ^ 2 * Q z ^ 4 +
      2 * W'.a₆ * 0 ^ 4 * Q z ^ 4 =
    (P x * Q z) ^ 2 * Q x
state_after: no goals
Theorem: HomologicalComplex.cylinder.ι₀_desc
File: Mathlib/Algebra/Homology/HomotopyCofiber.lean

tactic: simp [ι₀, desc]
state_before: C : Type u_1
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝³ : HasHomotopyCofiber φ
inst✝² : DecidableRel c.Rel
inst✝¹ : ∀ (i : ι), HasBinaryBiproduct (K.X i) (K.X i)
inst✝ : HasHomotopyCofiber (biprod.lift (𝟙 K) (-𝟙 K))
φ₀ φ₁ : K ⟶ F
h : Homotopy φ₀ φ₁
⊢ ι₀ K ≫ desc φ₀ φ₁ h = φ₀
state_after: no goals
Theorem: Matrix.toBilin'_comp
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: simp only [BilinForm.toMatrix'_comp, BilinForm.toMatrix'_toBilin', toMatrix'_toLin']
state_before: R : Type u_1
M✝ : Type u_2
inst✝¹⁸ : CommSemiring R
inst✝¹⁷ : AddCommMonoid M✝
inst✝¹⁶ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁵ : CommRing R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : DecidableEq n
inst✝ : DecidableEq o
M : Matrix n n R₂
P Q : Matrix n o R₂
⊢ BilinForm.toMatrix' ((toBilin' M).comp (toLin' P) (toLin' Q)) = BilinForm.toMatrix' (toBilin' (Pᵀ * M * Q))
state_after: no goals
Theorem: LinearMap.map_codRestrict
File: Mathlib/Algebra/Module/Submodule/Map.lean

tactic: simp [Subtype.ext_iff_val]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M₁
inst✝³ : Semiring R₂
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R₂ M₂
σ₂₁ : R₂ →+* R
inst✝ : RingHomSurjective σ₂₁
p : Submodule R M
f : M₂ →ₛₗ[σ₂₁] M
h : ∀ (c : M₂), f c ∈ p
p' : Submodule R₂ M₂
x✝ : ↥p
x : M
hx : x ∈ p
⊢ ⟨x, hx⟩ ∈ map (codRestrict p f h) p' ↔ ⟨x, hx⟩ ∈ comap p.subtype (map f p')
state_after: no goals
Theorem: HereditarilyLindelof_LindelofSets
File: Mathlib/Topology/Compactness/Lindelof.lean

tactic: apply HereditarilyLindelofSpace.isHereditarilyLindelof_univ
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s✝ t : Set X
inst✝ : HereditarilyLindelofSpace X
s : Set X
⊢ IsLindelof s
state_after: case a
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s✝ t : Set X
inst✝ : HereditarilyLindelofSpace X
s : Set X
⊢ s ⊆ univ

tactic: exact subset_univ s
state_before: case a
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s✝ t : Set X
inst✝ : HereditarilyLindelofSpace X
s : Set X
⊢ s ⊆ univ
state_after: no goals
Theorem: Real.Angle.sign_coe_neg_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [sign, sin_coe, neg_div, Real.sin_neg, sin_pi_div_two, Left.sign_neg, sign_one]
state_before: ⊢ (↑(-π / 2)).sign = -1
state_after: no goals
Theorem: eventually_nhdsSet_iUnion
File: Mathlib/Topology/NhdsSet.lean

tactic: simp only [nhdsSet_iUnion, eventually_iSup]
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
ι : Sort u_3
s : ι → Set X
P : X → Prop
⊢ (∀ᶠ (x : X) in 𝓝ˢ (⋃ i, s i), P x) ↔ ∀ (i : ι), ∀ᶠ (x : X) in 𝓝ˢ (s i), P x
state_after: no goals
Theorem: WithTop.image_coe_Ioi
File: Mathlib/Order/Interval/Set/WithBotTop.lean

tactic: rw [← preimage_coe_Ioi, image_preimage_eq_inter_range, range_coe, Ioi_inter_Iio]
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some '' Ioi a = Ioo ↑a ⊤
state_after: no goals
Theorem: Batteries.BinomialHeap.Imp.Heap.deleteMin_fst
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Lemmas.lean

tactic: simp only [deleteMin, findMin_val, Option.map, head?]
state_before: α : Type u_1
s✝ : Heap α
le : α → α → Bool
r : Nat
a : α
c : HeapNode α
s : Heap α
⊢ Option.map (fun x => x.fst) (deleteMin le (cons r a c s)) = head? le (cons r a c s)
state_after: no goals
Theorem: PNat.find_comp_succ
File: Mathlib/Data/PNat/Find.lean

tactic: refine (find_eq_iff _).2 ⟨PNat.find_spec h₂, fun n => PNat.recOn n ?_ ?_⟩
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
⊢ PNat.find h = PNat.find h₂ + 1
state_after: case refine_1
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n : ℕ+
⊢ 1 < PNat.find h₂ + 1 → ¬p 1

case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n : ℕ+
⊢ ∀ (n : ℕ+), (n < PNat.find h₂ + 1 → ¬p n) → n + 1 < PNat.find h₂ + 1 → ¬p (n + 1)

tactic: intro m _ hm
state_before: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n : ℕ+
⊢ ∀ (n : ℕ+), (n < PNat.find h₂ + 1 → ¬p n) → n + 1 < PNat.find h₂ + 1 → ¬p (n + 1)
state_after: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : m + 1 < PNat.find h₂ + 1
⊢ ¬p (m + 1)

tactic: simp only [add_lt_add_iff_right, lt_find_iff] at hm
state_before: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : m + 1 < PNat.find h₂ + 1
⊢ ¬p (m + 1)
state_after: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : ∀ m_1 ≤ m, ¬p (m_1 + 1)
⊢ ¬p (m + 1)

tactic: exact hm _ le_rfl
state_before: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : ∀ m_1 ≤ m, ¬p (m_1 + 1)
⊢ ¬p (m + 1)
state_after: no goals

tactic: simp [h1]
state_before: case refine_1
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n : ℕ+
⊢ 1 < PNat.find h₂ + 1 → ¬p 1
state_after: no goals
Theorem: CategoryTheory.InjectiveResolution.ι_f_succ
File: Mathlib/CategoryTheory/Preadditive/InjectiveResolution.lean

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
n : ℕ
⊢ n + 1 ≠ 0
state_after: no goals
Theorem: LieModule.shiftedWeightSpace.toEnd_eq
File: Mathlib/Algebra/Lie/Weights/Linear.lean

tactic: ext
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : LinearWeights R L M
χ : L → R
x : L
⊢ (toEnd R L ↥↑(shiftedWeightSpace R L M χ)) x =
    (shift R L M χ).conj ((toEnd R L ↥↑(weightSpace M χ)) x - χ x • LinearMap.id)
state_after: case h.a
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : LinearWeights R L M
χ : L → R
x : L
x✝ : ↥↑(shiftedWeightSpace R L M χ)
⊢ ↑(((toEnd R L ↥↑(shiftedWeightSpace R L M χ)) x) x✝) =
    ↑(((shift R L M χ).conj ((toEnd R L ↥↑(weightSpace M χ)) x - χ x • LinearMap.id)) x✝)

tactic: simp [LinearEquiv.conj_apply]
state_before: case h.a
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : LinearWeights R L M
χ : L → R
x : L
x✝ : ↥↑(shiftedWeightSpace R L M χ)
⊢ ↑(((toEnd R L ↥↑(shiftedWeightSpace R L M χ)) x) x✝) =
    ↑(((shift R L M χ).conj ((toEnd R L ↥↑(weightSpace M χ)) x - χ x • LinearMap.id)) x✝)
state_after: no goals
Theorem: iUnion_Ico_intCast
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [zero_add] using iUnion_Ico_add_intCast (0 : α)
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
a : α
⊢ ⋃ n, Ico (↑n) (↑n + 1) = univ
state_after: no goals
Theorem: div_nonpos_of_nonneg_of_nonpos
File: Mathlib/Algebra/Order/Field/Defs.lean

tactic: rw [div_eq_mul_inv]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 ≤ a
hb : b ≤ 0
⊢ a / b ≤ 0
state_after: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 ≤ a
hb : b ≤ 0
⊢ a * b⁻¹ ≤ 0

tactic: exact mul_nonpos_of_nonneg_of_nonpos ha (inv_nonpos.2 hb)
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : 0 ≤ a
hb : b ≤ 0
⊢ a * b⁻¹ ≤ 0
state_after: no goals
Theorem: inner_eq_sum_norm_sq_div_four
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← re_add_im ⟪x, y⟫, re_inner_eq_norm_add_mul_self_sub_norm_sub_mul_self_div_four,
  im_inner_eq_norm_sub_i_smul_mul_self_sub_norm_add_i_smul_mul_self_div_four]
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 y : E
⊢ ⟪x, y⟫_𝕜 = (↑‖x + y‖ ^ 2 - ↑‖x - y‖ ^ 2 + (↑‖x - I • y‖ ^ 2 - ↑‖x + I • y‖ ^ 2) * I) / 4
state_after: 𝕜 : 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 y : E
⊢ ↑((‖x + y‖ * ‖x + y‖ - ‖x - y‖ * ‖x - y‖) / 4) + ↑((‖x - I • y‖ * ‖x - I • y‖ - ‖x + I • y‖ * ‖x + I • y‖) / 4) * I =
    (↑‖x + y‖ ^ 2 - ↑‖x - y‖ ^ 2 + (↑‖x - I • y‖ ^ 2 - ↑‖x + I • y‖ ^ 2) * I) / 4

tactic: push_cast
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 y : E
⊢ ↑((‖x + y‖ * ‖x + y‖ - ‖x - y‖ * ‖x - y‖) / 4) + ↑((‖x - I • y‖ * ‖x - I • y‖ - ‖x + I • y‖ * ‖x + I • y‖) / 4) * I =
    (↑‖x + y‖ ^ 2 - ↑‖x - y‖ ^ 2 + (↑‖x - I • y‖ ^ 2 - ↑‖x + I • y‖ ^ 2) * I) / 4
state_after: 𝕜 : 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 y : E
⊢ (↑‖x + y‖ * ↑‖x + y‖ - ↑‖x - y‖ * ↑‖x - y‖) / 4 +
      (↑‖x - I • y‖ * ↑‖x - I • y‖ - ↑‖x + I • y‖ * ↑‖x + I • y‖) / 4 * I =
    (↑‖x + y‖ ^ 2 - ↑‖x - y‖ ^ 2 + (↑‖x - I • y‖ ^ 2 - ↑‖x + I • y‖ ^ 2) * I) / 4

tactic: simp only [sq, ← mul_div_right_comm, ← add_div]
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 y : E
⊢ (↑‖x + y‖ * ↑‖x + y‖ - ↑‖x - y‖ * ↑‖x - y‖) / 4 +
      (↑‖x - I • y‖ * ↑‖x - I • y‖ - ↑‖x + I • y‖ * ↑‖x + I • y‖) / 4 * I =
    (↑‖x + y‖ ^ 2 - ↑‖x - y‖ ^ 2 + (↑‖x - I • y‖ ^ 2 - ↑‖x + I • y‖ ^ 2) * I) / 4
state_after: no goals
Theorem: Stream'.WSeq.toSeq_ofSeq
File: Mathlib/Data/Seq/WSeq.lean

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ (↑s).toSeq = s
state_after: case a
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ ↑(↑s).toSeq = ↑s

tactic: funext n
state_before: case a
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ ↑(↑s).toSeq = ↑s
state_after: case a.h
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ↑(↑s).toSeq n = ↑s n

tactic: dsimp [toSeq]
state_before: case a.h
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ↑(↑s).toSeq n = ↑s n
state_after: case a.h
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ((↑s).get? n).get = ↑s n

tactic: apply get_eq_of_mem
state_before: case a.h
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ((↑s).get? n).get = ↑s n
state_after: case a.h.a
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ↑s n ∈ (↑s).get? n

tactic: rw [get?_ofSeq]
state_before: case a.h.a
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ↑s n ∈ (↑s).get? n
state_after: case a.h.a
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ↑s n ∈ Computation.pure (s.get? n)

tactic: apply ret_mem
state_before: case a.h.a
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ↑s n ∈ Computation.pure (s.get? n)
state_after: no goals
Theorem: mul_bit0
File: Mathlib/Algebra/Order/Ring/Int.lean

tactic: rw [bit0, mul_add, ← one_add_one_eq_two, add_zsmul, one_zsmul]
state_before: R : Type u_1
inst✝ : NonUnitalNonAssocRing R
n r : R
⊢ r * bit0 n = 2 • (r * n)
state_after: no goals
Theorem: Polynomial.not_isRoot_C
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: simpa using hr
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q r✝ : R[X]
x r a : R
hr : r ≠ 0
⊢ ¬(C r).IsRoot a
state_after: no goals
Theorem: MeasureTheory.inter_ae_eq_empty_of_ae_eq_empty_left
File: Mathlib/MeasureTheory/OuterMeasure/AE.lean

tactic: convert ae_eq_set_inter h (ae_eq_refl t)
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
h : s =ᶠ[ae μ] ∅
⊢ s ∩ t =ᶠ[ae μ] ∅
state_after: case h.e'_5
α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
h : s =ᶠ[ae μ] ∅
⊢ ∅ = ∅ ∩ t

tactic: rw [empty_inter]
state_before: case h.e'_5
α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
h : s =ᶠ[ae μ] ∅
⊢ ∅ = ∅ ∩ t
state_after: no goals
Theorem: Set.left_mem_Ico
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: simp [le_refl]
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Ico a b ↔ a < b
state_after: no goals
Theorem: wellFounded_lift₂_iff
File: Mathlib/Order/RelIso/Basic.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
⊢ WellFounded (Quotient.lift₂ r H) ↔ WellFounded r
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
⊢ WellFounded (Quotient.lift₂ r H) → WellFounded r

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
⊢ WellFounded r → WellFounded (Quotient.lift₂ r H)

tactic: exact RelHomClass.wellFounded (Quotient.mkRelHom H)
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
⊢ WellFounded (Quotient.lift₂ r H) → WellFounded r
state_after: no goals

tactic: refine fun wf => ⟨fun q => ?_⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
⊢ WellFounded r → WellFounded (Quotient.lift₂ r H)
state_after: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
wf : WellFounded r
q : Quotient inst✝
⊢ Acc (Quotient.lift₂ r H) q

tactic: obtain ⟨a, rfl⟩ := q.exists_rep
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
wf : WellFounded r
q : Quotient inst✝
⊢ Acc (Quotient.lift₂ r H) q
state_after: case mpr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
wf : WellFounded r
a : α
⊢ Acc (Quotient.lift₂ r H) ⟦a⟧

tactic: exact acc_lift₂_iff.2 (wf.apply a)
state_before: case mpr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
inst✝ : Setoid α
r : α → α → Prop
H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂
wf : WellFounded r
a : α
⊢ Acc (Quotient.lift₂ r H) ⟦a⟧
state_after: no goals
Theorem: Multiset.add_union_distrib
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [add_comm, union_add_distrib, add_comm s, add_comm s]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
⊢ s + (t ∪ u) = s + t ∪ (s + u)
state_after: no goals
Theorem: Multiset.add_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [bind]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
⊢ (s + t).bind f = s.bind f + t.bind f
state_after: no goals