1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Fermat42.comm
File: Mathlib/NumberTheory/FLT/Four.lean

tactic: delta Fermat42
state_before: a b c : ℤ
⊢ Fermat42 a b c ↔ Fermat42 b a c
state_after: a b c : ℤ
⊢ a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2

tactic: rw [add_comm]
state_before: a b c : ℤ
⊢ a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2
state_after: a b c : ℤ
⊢ a ≠ 0 ∧ b ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2

tactic: tauto
state_before: a b c : ℤ
⊢ a ≠ 0 ∧ b ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2
state_after: no goals
Theorem: QuotientGroup.card_preimage_mk
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [← Fintype.card_prod, Fintype.card_congr (preimageMkEquivSubgroupProdSet _ _)]
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
s : Subgroup G
t : Set (G ⧸ s)
⊢ Fintype.card ↑(mk ⁻¹' t) = Fintype.card ↥s * Fintype.card ↑t
state_after: no goals
Theorem: IsIntegral.mem_intermediateField_of_minpoly_splits
File: Mathlib/FieldTheory/SplittingField/IsSplittingField.lean

tactic: rw [← F.fieldRange_val]
state_before: F✝¹ : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
p : K[X]
F✝ : IntermediateField K L
x : L
int : IsIntegral K x
F : IntermediateField K L
h : Splits (algebraMap K ↥F) (minpoly K x)
⊢ x ∈ F
state_after: F✝¹ : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
p : K[X]
F✝ : IntermediateField K L
x : L
int : IsIntegral K x
F : IntermediateField K L
h : Splits (algebraMap K ↥F) (minpoly K x)
⊢ x ∈ F.val.fieldRange

tactic: exact int.mem_range_algebraMap_of_minpoly_splits h
state_before: F✝¹ : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
p : K[X]
F✝ : IntermediateField K L
x : L
int : IsIntegral K x
F : IntermediateField K L
h : Splits (algebraMap K ↥F) (minpoly K x)
⊢ x ∈ F.val.fieldRange
state_after: no goals
Theorem: zpow_negSucc
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [← zpow_natCast]
state_before: G : Type u_1
inst✝ : DivInvMonoid G
a✝ b a : G
n : ℕ
⊢ a ^ Int.negSucc n = (a ^ (n + 1))⁻¹
state_after: G : Type u_1
inst✝ : DivInvMonoid G
a✝ b a : G
n : ℕ
⊢ a ^ Int.negSucc n = (a ^ ↑(n + 1))⁻¹

tactic: exact DivInvMonoid.zpow_neg' n a
state_before: G : Type u_1
inst✝ : DivInvMonoid G
a✝ b a : G
n : ℕ
⊢ a ^ Int.negSucc n = (a ^ ↑(n + 1))⁻¹
state_after: no goals
Theorem: SetTheory.PGame.neg_star
File: Mathlib/SetTheory/Game/PGame.lean

tactic: simp [star]
state_before: xl xr : Type u
⊢ -star = star
state_after: no goals
Theorem: List.pairwise_sublists
File: Mathlib/Data/List/Sublists.lean

tactic: have := (pairwise_reverse.2 H).sublists'
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
l : List α
H : Pairwise R l
⊢ Pairwise (fun l₁ l₂ => Lex R l₁.reverse l₂.reverse) l.sublists
state_after: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
l : List α
H : Pairwise R l
this : Pairwise (Lex (swap fun b a => R a b)) l.reverse.sublists'
⊢ Pairwise (fun l₁ l₂ => Lex R l₁.reverse l₂.reverse) l.sublists

tactic: rwa [sublists'_reverse, pairwise_map] at this
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
l : List α
H : Pairwise R l
this : Pairwise (Lex (swap fun b a => R a b)) l.reverse.sublists'
⊢ Pairwise (fun l₁ l₂ => Lex R l₁.reverse l₂.reverse) l.sublists
state_after: no goals
Theorem: Finset.image₂_inter_subset_right
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq β
⊢ ↑(image₂ f s (t ∩ t')) ⊆ ↑(image₂ f s t ∩ image₂ f s t')
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq β
⊢ image2 f (↑s) (↑t ∩ ↑t') ⊆ image2 f ↑s ↑t ∩ image2 f ↑s ↑t'

tactic: exact image2_inter_subset_right
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq β
⊢ image2 f (↑s) (↑t ∩ ↑t') ⊆ image2 f ↑s ↑t ∩ image2 f ↑s ↑t'
state_after: no goals
Theorem: FreeAlgebra.hom_ext
File: Mathlib/Algebra/FreeAlgebra.lean

tactic: rw [← lift_symm_apply, ← lift_symm_apply] at w
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : FreeAlgebra R X →ₐ[R] A
w : ⇑f ∘ ι R = ⇑g ∘ ι R
⊢ f = g
state_after: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : FreeAlgebra R X →ₐ[R] A
w : (lift R).symm f = (lift R).symm g
⊢ f = g

tactic: exact (lift R).symm.injective w
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : FreeAlgebra R X →ₐ[R] A
w : (lift R).symm f = (lift R).symm g
⊢ f = g
state_after: no goals
Theorem: Real.toNNReal_eq_nnnorm_of_nonneg
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [Real.toNNReal_of_nonneg hr]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ r.toNNReal = ‖r‖₊
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ ⟨r, hr⟩ = ‖r‖₊

tactic: ext
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ ⟨r, hr⟩ = ‖r‖₊
state_after: case a
𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ ↑⟨r, hr⟩ = ↑‖r‖₊

tactic: rw [coe_mk, coe_nnnorm r, Real.norm_eq_abs r, abs_of_nonneg hr]
state_before: case a
𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ ↑⟨r, hr⟩ = ↑‖r‖₊
state_after: no goals
Theorem: UpperSet.prod_eq_top
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [SetLike.ext'_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : UpperSet α
t t₁ t₂ : UpperSet β
x : α × β
⊢ s ×ˢ t = ⊤ ↔ s = ⊤ ∨ t = ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : UpperSet α
t t₁ t₂ : UpperSet β
x : α × β
⊢ ↑(s ×ˢ t) = ↑⊤ ↔ ↑s = ↑⊤ ∨ ↑t = ↑⊤

tactic: exact prod_eq_empty_iff
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : UpperSet α
t t₁ t₂ : UpperSet β
x : α × β
⊢ ↑(s ×ˢ t) = ↑⊤ ↔ ↑s = ↑⊤ ∨ ↑t = ↑⊤
state_after: no goals
Theorem: Function.extend_smul
File: Mathlib/GroupTheory/GroupAction/Pi.lean

tactic: haveI : Decidable (∃ a : α, f a = x) := Classical.propDecidable _
state_before: I : Type u
f✝ : I → Type v
x✝ y : (i : I) → f✝ i
i : I
R : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : SMul R γ
r : R
f : α → β
g : α → γ
e : β → γ
x : β
⊢ extend f (r • g) (r • e) x = (r • extend f g e) x
state_after: I : Type u
f✝ : I → Type v
x✝ y : (i : I) → f✝ i
i : I
R : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : SMul R γ
r : R
f : α → β
g : α → γ
e : β → γ
x : β
this : Decidable (∃ a, f a = x)
⊢ extend f (r • g) (r • e) x = (r • extend f g e) x

tactic: simp only [extend_def, Pi.smul_apply]
state_before: I : Type u
f✝ : I → Type v
x✝ y : (i : I) → f✝ i
i : I
R : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : SMul R γ
r : R
f : α → β
g : α → γ
e : β → γ
x : β
this : Decidable (∃ a, f a = x)
⊢ extend f (r • g) (r • e) x = (r • extend f g e) x
state_after: I : Type u
f✝ : I → Type v
x✝ y : (i : I) → f✝ i
i : I
R : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : SMul R γ
r : R
f : α → β
g : α → γ
e : β → γ
x : β
this : Decidable (∃ a, f a = x)
⊢ (if h : ∃ a, f a = x then r • g (Classical.choose ⋯) else r • e x) =
    r • if h : ∃ a, f a = x then g (Classical.choose h) else e x

tactic: split_ifs <;>
rfl
state_before: I : Type u
f✝ : I → Type v
x✝ y : (i : I) → f✝ i
i : I
R : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : SMul R γ
r : R
f : α → β
g : α → γ
e : β → γ
x : β
this : Decidable (∃ a, f a = x)
⊢ (if h : ∃ a, f a = x then r • g (Classical.choose ⋯) else r • e x) =
    r • if h : ∃ a, f a = x then g (Classical.choose h) else e x
state_after: no goals
Theorem: MulAction.mem_orbit_smul
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: simp only [orbit_smul, mem_orbit_self]
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
g : G
a : α
⊢ a ∈ orbit G (g • a)
state_after: no goals
Theorem: FiniteField.trace_to_zmod_nondegenerate
File: Mathlib/FieldTheory/Finite/Trace.lean

tactic: haveI : Fact (ringChar F).Prime := ⟨CharP.char_is_prime F _⟩
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
⊢ ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
⊢ ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0

tactic: have htr := traceForm_nondegenerate (ZMod (ringChar F)) F a
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
⊢ ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
htr : (∀ (n : F), ((Algebra.traceForm (ZMod (ringChar F)) F) a) n = 0) → a = 0
⊢ ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0

tactic: simp_rw [Algebra.traceForm_apply] at htr
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
htr : (∀ (n : F), ((Algebra.traceForm (ZMod (ringChar F)) F) a) n = 0) → a = 0
⊢ ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
htr : (∀ (n : F), (Algebra.trace (ZMod (ringChar F)) F) (a * n) = 0) → a = 0
⊢ ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0

tactic: by_contra! hf
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
htr : (∀ (n : F), (Algebra.trace (ZMod (ringChar F)) F) (a * n) = 0) → a = 0
⊢ ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
htr : (∀ (n : F), (Algebra.trace (ZMod (ringChar F)) F) (a * n) = 0) → a = 0
hf : ∀ (b : F), (Algebra.trace (ZMod (ringChar F)) F) (a * b) = 0
⊢ False

tactic: exact ha (htr hf)
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : Algebra (ZMod (ringChar F)) F
a : F
ha : a ≠ 0
this : Fact (Nat.Prime (ringChar F))
htr : (∀ (n : F), (Algebra.trace (ZMod (ringChar F)) F) (a * n) = 0) → a = 0
hf : ∀ (b : F), (Algebra.trace (ZMod (ringChar F)) F) (a * b) = 0
⊢ False
state_after: no goals
Theorem: LocallyFinite.nhdsWithin_iUnion
File: Mathlib/Topology/LocallyFinite.lean

tactic: rcases hf a with ⟨U, haU, hfin⟩
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
a : X
⊢ 𝓝[⋃ i, f i] a = ⨆ i, 𝓝[f i] a
state_after: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
a : X
U : Set X
haU : U ∈ 𝓝 a
hfin : {i | (f i ∩ U).Nonempty}.Finite
⊢ 𝓝[⋃ i, f i] a = ⨆ i, 𝓝[f i] a

tactic: refine le_antisymm ?_ (Monotone.le_map_iSup fun _ _ ↦ nhdsWithin_mono _)
state_before: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
a : X
U : Set X
haU : U ∈ 𝓝 a
hfin : {i | (f i ∩ U).Nonempty}.Finite
⊢ 𝓝[⋃ i, f i] a = ⨆ i, 𝓝[f i] a
state_after: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
a : X
U : Set X
haU : U ∈ 𝓝 a
hfin : {i | (f i ∩ U).Nonempty}.Finite
⊢ 𝓝[⋃ i, f i] a ≤ ⨆ i, 𝓝[f i] a

tactic: calc
  𝓝[⋃ i, f i] a = 𝓝[⋃ i, f i ∩ U] a := by
    rw [← iUnion_inter, ← nhdsWithin_inter_of_mem' (nhdsWithin_le_nhds haU)]
  _ = 𝓝[⋃ i ∈ {j | (f j ∩ U).Nonempty}, (f i ∩ U)] a := by
    simp only [mem_setOf_eq, iUnion_nonempty_self]
  _ = ⨆ i ∈ {j | (f j ∩ U).Nonempty}, 𝓝[f i ∩ U] a := nhdsWithin_biUnion hfin _ _
  _ ≤ ⨆ i, 𝓝[f i ∩ U] a := iSup₂_le_iSup _ _
  _ ≤ ⨆ i, 𝓝[f i] a := iSup_mono fun i ↦ nhdsWithin_mono _ inter_subset_left
state_before: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
a : X
U : Set X
haU : U ∈ 𝓝 a
hfin : {i | (f i ∩ U).Nonempty}.Finite
⊢ 𝓝[⋃ i, f i] a ≤ ⨆ i, 𝓝[f i] a
state_after: no goals

tactic: rw [← iUnion_inter, ← nhdsWithin_inter_of_mem' (nhdsWithin_le_nhds haU)]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
a : X
U : Set X
haU : U ∈ 𝓝 a
hfin : {i | (f i ∩ U).Nonempty}.Finite
⊢ 𝓝[⋃ i, f i] a = 𝓝[⋃ i, f i ∩ U] a
state_after: no goals

tactic: simp only [mem_setOf_eq, iUnion_nonempty_self]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
a : X
U : Set X
haU : U ∈ 𝓝 a
hfin : {i | (f i ∩ U).Nonempty}.Finite
⊢ 𝓝[⋃ i, f i ∩ U] a = 𝓝[⋃ i ∈ {j | (f j ∩ U).Nonempty}, f i ∩ U] a
state_after: no goals
Theorem: CategoryTheory.Presieve.isSheafFor_subsieve
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

tactic: simpa using trans (𝟙 _)
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S✝ : Sieve X
R✝ : Presieve X
P : Cᵒᵖ ⥤ Type w
S : Sieve X
R : Presieve X
h : S.arrows ≤ R
trans : ∀ ⦃Y : C⦄ (f : Y ⟶ X), IsSheafFor P (Sieve.pullback f S).arrows
⊢ IsSheafFor P S.arrows
state_after: no goals
Theorem: Set.definable_finset_biInter
File: Mathlib/ModelTheory/Definability.lean

tactic: rw [← Finset.inf_set_eq_iInter]
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s : Finset ι
⊢ A.Definable L (⋂ i ∈ s, f i)
state_after: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s : Finset ι
⊢ A.Definable L (s.inf f)

tactic: exact definable_finset_inf hf s
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s✝ : Set (α → M)
ι : Type u_2
f : ι → Set (α → M)
hf : ∀ (i : ι), A.Definable L (f i)
s : Finset ι
⊢ A.Definable L (s.inf f)
state_after: no goals
Theorem: charP_of_injective_ringHom
File: Mathlib/Algebra/CharP/Algebra.lean

tactic: rw [← CharP.cast_eq_zero_iff R p x, ← map_natCast f x, map_eq_zero_iff f h]
state_before: R : Type u_1
A : Type u_2
inst✝² : NonAssocSemiring R
inst✝¹ : NonAssocSemiring A
f : R →+* A
h : Function.Injective ⇑f
p : ℕ
inst✝ : CharP R p
x : ℕ
⊢ ↑x = 0 ↔ p ∣ x
state_after: no goals
Theorem: Complex.coe_realPart
File: Mathlib/Data/Complex/Module.lean

tactic: congrm (ℜ $((re_add_im z).symm))
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
z : ℂ
⊢ ↑(ℜ z) = ?m.418209
state_after: no goals

tactic: rw [map_add, AddSubmonoid.coe_add, mul_comm, ← smul_eq_mul, realPart_I_smul]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
z : ℂ
⊢ ↑(ℜ (↑z.re + ↑z.im * I)) = ↑z.re
state_after: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
z : ℂ
⊢ ↑(ℜ ↑z.re) + ↑(-ℑ ↑z.im) = ↑z.re

tactic: simp [conj_ofReal, ← two_mul]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
z : ℂ
⊢ ↑(ℜ ↑z.re) + ↑(-ℑ ↑z.im) = ↑z.re
state_after: no goals
Theorem: rank_fun_eq_lift_mul
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: rw [rank_pi, Cardinal.sum_const, Cardinal.mk_fintype, Cardinal.lift_natCast]
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✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module R (φ i)
inst✝¹ : ∀ (i : η), Module.Free R (φ i)
inst✝ : Fintype η
⊢ Module.rank R (η → M) = ↑(Fintype.card η) * lift.{u₁', v} (Module.rank R M)
state_after: no goals
Theorem: absorbs_zero_iff
File: Mathlib/Topology/Bornology/Absorbs.lean

tactic: simp only [absorbs_iff_eventually_cobounded_mapsTo, ← singleton_zero,
  mapsTo_singleton, smul_zero, eventually_const]
state_before: G₀ : Type u_1
α : Type u_2
inst✝⁵ : GroupWithZero G₀
inst✝⁴ : Bornology G₀
inst✝³ : MulAction G₀ α
s✝ t u : Set α
S : Set (Set α)
inst✝² : (cobounded G₀).NeBot
E : Type u_3
inst✝¹ : AddMonoid E
inst✝ : DistribMulAction G₀ E
s : Set E
⊢ Absorbs G₀ s 0 ↔ 0 ∈ s
state_after: no goals
Theorem: ProbabilityTheory.kernel.iIndep_comap_mem_iff
File: Mathlib/Probability/Independence/Kernel.lean

tactic: simp_rw [← generateFrom_singleton, iIndepSet]
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
f : ι → Set Ω
_mΩ : MeasurableSpace Ω
κ : ↥(kernel α Ω)
μ : Measure α
⊢ iIndep (fun i => MeasurableSpace.comap (fun x => x ∈ f i) ⊤) κ μ ↔ iIndepSet f κ μ
state_after: no goals
Theorem: Nat.fib_two_mul
File: Mathlib/Data/Nat/Fib/Basic.lean

tactic: cases n
state_before: n : ℕ
⊢ fib (2 * n) = fib n * (2 * fib (n + 1) - fib n)
state_after: case zero

⊢ fib (2 * 0) = fib 0 * (2 * fib (0 + 1) - fib 0)

case succ
n✝ : ℕ
⊢ fib (2 * (n✝ + 1)) = fib (n✝ + 1) * (2 * fib (n✝ + 1 + 1) - fib (n✝ + 1))

tactic: simp
state_before: case zero

⊢ fib (2 * 0) = fib 0 * (2 * fib (0 + 1) - fib 0)
state_after: no goals

tactic: rw [two_mul, ← add_assoc, fib_add, fib_add_two, two_mul]
state_before: case succ
n✝ : ℕ
⊢ fib (2 * (n✝ + 1)) = fib (n✝ + 1) * (2 * fib (n✝ + 1 + 1) - fib (n✝ + 1))
state_after: case succ
n✝ : ℕ
⊢ fib (n✝ + 1) * fib n✝ + (fib n✝ + fib (n✝ + 1)) * fib (n✝ + 1) =
    fib (n✝ + 1) * (fib n✝ + fib (n✝ + 1) + (fib n✝ + fib (n✝ + 1)) - fib (n✝ + 1))

tactic: simp only [← add_assoc, add_tsub_cancel_right]
state_before: case succ
n✝ : ℕ
⊢ fib (n✝ + 1) * fib n✝ + (fib n✝ + fib (n✝ + 1)) * fib (n✝ + 1) =
    fib (n✝ + 1) * (fib n✝ + fib (n✝ + 1) + (fib n✝ + fib (n✝ + 1)) - fib (n✝ + 1))
state_after: case succ
n✝ : ℕ
⊢ fib (n✝ + 1) * fib n✝ + (fib n✝ + fib (n✝ + 1)) * fib (n✝ + 1) = fib (n✝ + 1) * (fib n✝ + fib (n✝ + 1) + fib n✝)

tactic: ring
state_before: case succ
n✝ : ℕ
⊢ fib (n✝ + 1) * fib n✝ + (fib n✝ + fib (n✝ + 1)) * fib (n✝ + 1) = fib (n✝ + 1) * (fib n✝ + fib (n✝ + 1) + fib n✝)
state_after: no goals
Theorem: Polynomial.smeval_mul
File: Mathlib/Algebra/Polynomial/Smeval.lean

tactic: induction p using Polynomial.induction_on' with
| h_add r s hr hs =>
  simp only [add_comp, hr, hs, smeval_add, add_mul]
| h_monomial n a =>
  simp only [smeval_monomial, smeval_C_mul, smeval_mul_X_pow, smeval_monomial_mul, smul_mul_assoc]
state_before: R : Type u_1
inst✝⁶ : Semiring R
p✝ : R[X]
r : R
p q : R[X]
S : Type u_2
inst✝⁵ : NonAssocSemiring S
inst✝⁴ : Module R S
inst✝³ : IsScalarTower R S S
inst✝² : SMulCommClass R S S
inst✝¹ : Pow S ℕ
inst✝ : NatPowAssoc S
x : S
⊢ (p * q).smeval x = p.smeval x * q.smeval x
state_after: no goals

tactic: simp only [add_comp, hr, hs, smeval_add, add_mul]
state_before: case h_add
R : Type u_1
inst✝⁶ : Semiring R
p✝ : R[X]
r✝ : R
p q : R[X]
S : Type u_2
inst✝⁵ : NonAssocSemiring S
inst✝⁴ : Module R S
inst✝³ : IsScalarTower R S S
inst✝² : SMulCommClass R S S
inst✝¹ : Pow S ℕ
inst✝ : NatPowAssoc S
x : S
r s : R[X]
hr : (r * q).smeval x = r.smeval x * q.smeval x
hs : (s * q).smeval x = s.smeval x * q.smeval x
⊢ ((r + s) * q).smeval x = (r + s).smeval x * q.smeval x
state_after: no goals

tactic: simp only [smeval_monomial, smeval_C_mul, smeval_mul_X_pow, smeval_monomial_mul, smul_mul_assoc]
state_before: case h_monomial
R : Type u_1
inst✝⁶ : Semiring R
p✝ : R[X]
r : R
p q : R[X]
S : Type u_2
inst✝⁵ : NonAssocSemiring S
inst✝⁴ : Module R S
inst✝³ : IsScalarTower R S S
inst✝² : SMulCommClass R S S
inst✝¹ : Pow S ℕ
inst✝ : NatPowAssoc S
x : S
n : ℕ
a : R
⊢ ((monomial n) a * q).smeval x = ((monomial n) a).smeval x * q.smeval x
state_after: no goals
Theorem: Equiv.apply_eq_iff_eq_symm_apply
File: Mathlib/Logic/Equiv/Defs.lean

tactic: conv_lhs => rw [← apply_symm_apply f y]
state_before: α : Sort u
β : Sort v
γ : Sort w
x : α
y : β
f : α ≃ β
⊢ f x = y ↔ x = f.symm y
state_after: α : Sort u
β : Sort v
γ : Sort w
x : α
y : β
f : α ≃ β
⊢ f x = f (f.symm y) ↔ x = f.symm y

tactic: rw [apply_eq_iff_eq]
state_before: α : Sort u
β : Sort v
γ : Sort w
x : α
y : β
f : α ≃ β
⊢ f x = f (f.symm y) ↔ x = f.symm y
state_after: no goals
Theorem: EquivFunctor.mapEquiv_trans
File: Mathlib/Control/EquivFunctor.lean

tactic: simp [mapEquiv, map_trans']
state_before: f : Type u₀ → Type u₁
inst✝ : EquivFunctor f
α β : Type u₀
e : α ≃ β
γ : Type u₀
ab : α ≃ β
bc : β ≃ γ
x : f α
⊢ ((mapEquiv f ab).trans (mapEquiv f bc)) x = (mapEquiv f (ab.trans bc)) x
state_after: no goals