1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: disjointed_eq_inf_compl
File: Mathlib/Order/Disjointed.lean

tactic: cases n
state_before: α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n : ℕ
⊢ disjointed f n = f n ⊓ ⨅ i, ⨅ (_ : i < n), (f i)ᶜ
state_after: case zero
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
⊢ disjointed f 0 = f 0 ⊓ ⨅ i, ⨅ (_ : i < 0), (f i)ᶜ

case succ
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ disjointed f (n✝ + 1) = f (n✝ + 1) ⊓ ⨅ i, ⨅ (_ : i < n✝ + 1), (f i)ᶜ

tactic: simp_rw [disjointed_succ, partialSups_eq_biSup, sdiff_eq, compl_iSup]
state_before: case succ
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ disjointed f (n✝ + 1) = f (n✝ + 1) ⊓ ⨅ i, ⨅ (_ : i < n✝ + 1), (f i)ᶜ
state_after: case succ
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ f (n✝ + 1) ⊓ ⨅ i, ⨅ (_ : i ≤ n✝), (f i)ᶜ = f (n✝ + 1) ⊓ ⨅ i, ⨅ (_ : i < n✝ + 1), (f i)ᶜ

tactic: congr
state_before: case succ
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ f (n✝ + 1) ⊓ ⨅ i, ⨅ (_ : i ≤ n✝), (f i)ᶜ = f (n✝ + 1) ⊓ ⨅ i, ⨅ (_ : i < n✝ + 1), (f i)ᶜ
state_after: case succ.e_a.e_s
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ (fun i => ⨅ (_ : i ≤ n✝), (f i)ᶜ) = fun i => ⨅ (_ : i < n✝ + 1), (f i)ᶜ

tactic: ext i
state_before: case succ.e_a.e_s
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ (fun i => ⨅ (_ : i ≤ n✝), (f i)ᶜ) = fun i => ⨅ (_ : i < n✝ + 1), (f i)ᶜ
state_after: case succ.e_a.e_s.h
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ i : ℕ
⊢ ⨅ (_ : i ≤ n✝), (f i)ᶜ = ⨅ (_ : i < n✝ + 1), (f i)ᶜ

tactic: rw [Nat.lt_succ_iff]
state_before: case succ.e_a.e_s.h
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ i : ℕ
⊢ ⨅ (_ : i ≤ n✝), (f i)ᶜ = ⨅ (_ : i < n✝ + 1), (f i)ᶜ
state_after: no goals

tactic: rw [disjointed_zero, eq_comm, inf_eq_left]
state_before: case zero
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
⊢ disjointed f 0 = f 0 ⊓ ⨅ i, ⨅ (_ : i < 0), (f i)ᶜ
state_after: case zero
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
⊢ f 0 ≤ ⨅ i, ⨅ (_ : i < 0), (f i)ᶜ

tactic: simp_rw [le_iInf_iff]
state_before: case zero
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
⊢ f 0 ≤ ⨅ i, ⨅ (_ : i < 0), (f i)ᶜ
state_after: case zero
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
⊢ ∀ i < 0, f 0 ≤ (f i)ᶜ

tactic: exact fun i hi => (i.not_lt_zero hi).elim
state_before: case zero
α : Type u_1
β : Type u_2
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
⊢ ∀ i < 0, f 0 ≤ (f i)ᶜ
state_after: no goals
Theorem: Option.map₂_map_right
File: Mathlib/Data/Option/NAry.lean

tactic: cases b <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
f : α → γ → δ
g : β → γ
⊢ map₂ f a (Option.map g b) = map₂ (fun a b => f a (g b)) a b
state_after: no goals
Theorem: Matrix.blockDiagonal_add
File: Mathlib/Data/Matrix/Block.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝¹ : DecidableEq o
inst✝ : AddZeroClass α
M N : o → Matrix m n α
⊢ blockDiagonal (M + N) = blockDiagonal M + blockDiagonal N
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝¹ : DecidableEq o
inst✝ : AddZeroClass α
M N : o → Matrix m n α
i✝ : m × o
j✝ : n × o
⊢ blockDiagonal (M + N) i✝ j✝ = (blockDiagonal M + blockDiagonal N) i✝ j✝

tactic: simp only [blockDiagonal_apply, Pi.add_apply, add_apply]
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝¹ : DecidableEq o
inst✝ : AddZeroClass α
M N : o → Matrix m n α
i✝ : m × o
j✝ : n × o
⊢ blockDiagonal (M + N) i✝ j✝ = (blockDiagonal M + blockDiagonal N) i✝ j✝
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝¹ : DecidableEq o
inst✝ : AddZeroClass α
M N : o → Matrix m n α
i✝ : m × o
j✝ : n × o
⊢ (if i✝.2 = j✝.2 then M i✝.2 i✝.1 j✝.1 + N i✝.2 i✝.1 j✝.1 else 0) =
    (if i✝.2 = j✝.2 then M i✝.2 i✝.1 j✝.1 else 0) + if i✝.2 = j✝.2 then N i✝.2 i✝.1 j✝.1 else 0

tactic: split_ifs <;> simp
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝¹ : DecidableEq o
inst✝ : AddZeroClass α
M N : o → Matrix m n α
i✝ : m × o
j✝ : n × o
⊢ (if i✝.2 = j✝.2 then M i✝.2 i✝.1 j✝.1 + N i✝.2 i✝.1 j✝.1 else 0) =
    (if i✝.2 = j✝.2 then M i✝.2 i✝.1 j✝.1 else 0) + if i✝.2 = j✝.2 then N i✝.2 i✝.1 j✝.1 else 0
state_after: no goals
Theorem: List.maximum_ne_bot_of_length_pos
File: Mathlib/Data/List/MinMax.lean

tactic: simp [maximum_cons]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
h : 0 < l.length
head✝ : α
tail✝ : List α
x✝ : 0 < (head✝ :: tail✝).length
⊢ (head✝ :: tail✝).maximum ≠ ⊥
state_after: no goals
Theorem: ZMod.val_add_of_lt
File: Mathlib/Data/ZMod/Basic.lean

tactic: have : NeZero n := by constructor; rintro rfl; simp at h
state_before: n : ℕ
a b : ZMod n
h : a.val + b.val < n
⊢ (a + b).val = a.val + b.val
state_after: n : ℕ
a b : ZMod n
h : a.val + b.val < n
this : NeZero n
⊢ (a + b).val = a.val + b.val

tactic: rw [ZMod.val_add, Nat.mod_eq_of_lt h]
state_before: n : ℕ
a b : ZMod n
h : a.val + b.val < n
this : NeZero n
⊢ (a + b).val = a.val + b.val
state_after: no goals

tactic: constructor
state_before: n : ℕ
a b : ZMod n
h : a.val + b.val < n
⊢ NeZero n
state_after: case out
n : ℕ
a b : ZMod n
h : a.val + b.val < n
⊢ n ≠ 0

tactic: rintro rfl
state_before: case out
n : ℕ
a b : ZMod n
h : a.val + b.val < n
⊢ n ≠ 0
state_after: case out
a b : ZMod 0
h : a.val + b.val < 0
⊢ False

tactic: simp at h
state_before: case out
a b : ZMod 0
h : a.val + b.val < 0
⊢ False
state_after: no goals
Theorem: continuousAt_zpow₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: cases' m with m m
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℤ
h : x ≠ 0 ∨ 0 ≤ m
⊢ ContinuousAt (fun x => x ^ m) x
state_after: case ofNat
α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.ofNat m
⊢ ContinuousAt (fun x => x ^ Int.ofNat m) x

case negSucc
α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.negSucc m
⊢ ContinuousAt (fun x => x ^ Int.negSucc m) x

tactic: simpa only [Int.ofNat_eq_coe, zpow_natCast] using continuousAt_pow x m
state_before: case ofNat
α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.ofNat m
⊢ ContinuousAt (fun x => x ^ Int.ofNat m) x
state_after: no goals

tactic: simp only [zpow_negSucc]
state_before: case negSucc
α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.negSucc m
⊢ ContinuousAt (fun x => x ^ Int.negSucc m) x
state_after: case negSucc
α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.negSucc m
⊢ ContinuousAt (fun x => (x ^ (m + 1))⁻¹) x

tactic: have hx : x ≠ 0 := h.resolve_right (Int.negSucc_lt_zero m).not_le
state_before: case negSucc
α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.negSucc m
⊢ ContinuousAt (fun x => (x ^ (m + 1))⁻¹) x
state_after: case negSucc
α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.negSucc m
hx : x ≠ 0
⊢ ContinuousAt (fun x => (x ^ (m + 1))⁻¹) x

tactic: exact (continuousAt_pow x (m + 1)).inv₀ (pow_ne_zero _ hx)
state_before: case negSucc
α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.negSucc m
hx : x ≠ 0
⊢ ContinuousAt (fun x => (x ^ (m + 1))⁻¹) x
state_after: no goals
Theorem: Nat.choose_symm_half
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: apply choose_symm_of_eq_add
state_before: m : ℕ
⊢ (2 * m + 1).choose (m + 1) = (2 * m + 1).choose m
state_after: case h
m : ℕ
⊢ 2 * m + 1 = m + 1 + m

tactic: rw [Nat.add_comm m 1, Nat.add_assoc 1 m m, Nat.add_comm (2 * m) 1, Nat.two_mul m]
state_before: case h
m : ℕ
⊢ 2 * m + 1 = m + 1 + m
state_after: no goals
Theorem: Turing.ListBlank.map_cons
File: Mathlib/Computability/TuringMachine.lean

tactic: refine (ListBlank.cons_head_tail _).symm.trans ?_
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l : ListBlank Γ
a : Γ
⊢ map f (cons a l) = cons (f.f a) (map f l)
state_after: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l : ListBlank Γ
a : Γ
⊢ cons (map f (cons a l)).head (map f (cons a l)).tail = cons (f.f a) (map f l)

tactic: simp only [ListBlank.head_map, ListBlank.head_cons, ListBlank.tail_map, ListBlank.tail_cons]
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l : ListBlank Γ
a : Γ
⊢ cons (map f (cons a l)).head (map f (cons a l)).tail = cons (f.f a) (map f l)
state_after: no goals
Theorem: MeasurableSet.image_inclusion'
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: rcases hu with ⟨u, hu, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t : Set α
h : s ⊆ t
u : Set ↑s
hs : MeasurableSet (Subtype.val ⁻¹' s)
hu : MeasurableSet u
⊢ MeasurableSet (inclusion h '' u)
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t : Set α
h : s ⊆ t
hs : MeasurableSet (Subtype.val ⁻¹' s)
u : Set α
hu : MeasurableSet u
⊢ MeasurableSet (inclusion h '' (Subtype.val ⁻¹' u))

tactic: convert (measurable_subtype_coe hu).inter hs
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t : Set α
h : s ⊆ t
hs : MeasurableSet (Subtype.val ⁻¹' s)
u : Set α
hu : MeasurableSet u
⊢ MeasurableSet (inclusion h '' (Subtype.val ⁻¹' u))
state_after: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t : Set α
h : s ⊆ t
hs : MeasurableSet (Subtype.val ⁻¹' s)
u : Set α
hu : MeasurableSet u
⊢ inclusion h '' (Subtype.val ⁻¹' u) = Subtype.val ⁻¹' u ∩ Subtype.val ⁻¹' s

tactic: ext ⟨x, hx⟩
state_before: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t : Set α
h : s ⊆ t
hs : MeasurableSet (Subtype.val ⁻¹' s)
u : Set α
hu : MeasurableSet u
⊢ inclusion h '' (Subtype.val ⁻¹' u) = Subtype.val ⁻¹' u ∩ Subtype.val ⁻¹' s
state_after: case h.e'_3.h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t : Set α
h : s ⊆ t
hs : MeasurableSet (Subtype.val ⁻¹' s)
u : Set α
hu : MeasurableSet u
x : α
hx : x ∈ t
⊢ ⟨x, hx⟩ ∈ inclusion h '' (Subtype.val ⁻¹' u) ↔ ⟨x, hx⟩ ∈ Subtype.val ⁻¹' u ∩ Subtype.val ⁻¹' s

tactic: simpa [@and_comm _ (_ = x)] using and_comm
state_before: case h.e'_3.h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t : Set α
h : s ⊆ t
hs : MeasurableSet (Subtype.val ⁻¹' s)
u : Set α
hu : MeasurableSet u
x : α
hx : x ∈ t
⊢ ⟨x, hx⟩ ∈ inclusion h '' (Subtype.val ⁻¹' u) ↔ ⟨x, hx⟩ ∈ Subtype.val ⁻¹' u ∩ Subtype.val ⁻¹' s
state_after: no goals
Theorem: equivShrink_mul
File: Mathlib/Logic/Small/Group.lean

tactic: rw [Equiv.mul_def]
state_before: α : Type u_1
inst✝¹ : Mul α
inst✝ : Small.{u_2, u_1} α
x y : α
⊢ (equivShrink α) (x * y) = (equivShrink α) x * (equivShrink α) y
state_after: α : Type u_1
inst✝¹ : Mul α
inst✝ : Small.{u_2, u_1} α
x y : α
⊢ (equivShrink α) (x * y) =
    (equivShrink α).symm.symm ((equivShrink α).symm ((equivShrink α) x) * (equivShrink α).symm ((equivShrink α) y))

tactic: simp
state_before: α : Type u_1
inst✝¹ : Mul α
inst✝ : Small.{u_2, u_1} α
x y : α
⊢ (equivShrink α) (x * y) =
    (equivShrink α).symm.symm ((equivShrink α).symm ((equivShrink α) x) * (equivShrink α).symm ((equivShrink α) y))
state_after: no goals
Theorem: Submonoid.eq_bot_iff_forall
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

tactic: simp (config := { contextual := true }) [iff_def, S.one_mem]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ (∀ (x : M), x ∈ S ↔ x ∈ ⊥) ↔ ∀ x ∈ S, x = 1
state_after: no goals
Theorem: Finset.empty_pow
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ', empty_mul]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n : ℕ
hn : n ≠ 0
⊢ ∅ ^ n = ∅
state_after: no goals
Theorem: PreQuasiregular.add_inv_add_mul_eq_zero
File: Mathlib/Algebra/Algebra/Quasispectrum.lean

tactic: simpa [-Units.inv_mul] using congr($(u.inv_mul).val)
state_before: R : Type u_1
inst✝ : NonUnitalSemiring R
u : (PreQuasiregular R)ˣ
⊢ (↑u).val + (↑u⁻¹).val + (↑u⁻¹).val * (↑u).val = 0
state_after: no goals
Theorem: IsRelPrime.of_add_mul_left_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [isRelPrime_comm] at h ⊢
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsRelPrime x (y + x * z)
⊢ IsRelPrime x y
state_after: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsRelPrime (y + x * z) x
⊢ IsRelPrime y x

tactic: exact h.of_add_mul_left_left
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsRelPrime (y + x * z) x
⊢ IsRelPrime y x
state_after: no goals
Theorem: WeierstrassCurve.Ψ_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: erw [Ψ_ofNat, preΨ'_zero, C_0, zero_mul]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.Ψ 0 = 0
state_after: no goals
Theorem: prevD_nat
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: dsimp [prevD]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i✝ : ι
C D : CochainComplex V ℕ
i : ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ (prevD i) f = f i (i - 1) ≫ D.d (i - 1) i
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i✝ : ι
C D : CochainComplex V ℕ
i : ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ f i ((ComplexShape.up ℕ).prev i) ≫ D.d ((ComplexShape.up ℕ).prev i) i = f i (i - 1) ≫ D.d (i - 1) i

tactic: cases i
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i✝ : ι
C D : CochainComplex V ℕ
i : ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ f i ((ComplexShape.up ℕ).prev i) ≫ D.d ((ComplexShape.up ℕ).prev i) i = f i (i - 1) ≫ D.d (i - 1) i
state_after: case zero
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : CochainComplex V ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ f 0 ((ComplexShape.up ℕ).prev 0) ≫ D.d ((ComplexShape.up ℕ).prev 0) 0 = f 0 (0 - 1) ≫ D.d (0 - 1) 0

case succ
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : CochainComplex V ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
n✝ : ℕ
⊢ f (n✝ + 1) ((ComplexShape.up ℕ).prev (n✝ + 1)) ≫ D.d ((ComplexShape.up ℕ).prev (n✝ + 1)) (n✝ + 1) =
    f (n✝ + 1) (n✝ + 1 - 1) ≫ D.d (n✝ + 1 - 1) (n✝ + 1)

tactic: simp only [shape, CochainComplex.prev_nat_zero, ComplexShape.up_Rel, Nat.one_ne_zero,
  not_false_iff, comp_zero]
state_before: case zero
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : CochainComplex V ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
⊢ f 0 ((ComplexShape.up ℕ).prev 0) ≫ D.d ((ComplexShape.up ℕ).prev 0) 0 = f 0 (0 - 1) ≫ D.d (0 - 1) 0
state_after: no goals

tactic: congr <;> simp
state_before: case succ
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C✝ D✝ E : HomologicalComplex V c
f✝ g : C✝ ⟶ D✝
h k : D✝ ⟶ E
i : ι
C D : CochainComplex V ℕ
f : (i j : ℕ) → C.X i ⟶ D.X j
n✝ : ℕ
⊢ f (n✝ + 1) ((ComplexShape.up ℕ).prev (n✝ + 1)) ≫ D.d ((ComplexShape.up ℕ).prev (n✝ + 1)) (n✝ + 1) =
    f (n✝ + 1) (n✝ + 1 - 1) ≫ D.d (n✝ + 1 - 1) (n✝ + 1)
state_after: no goals
Theorem: Matrix.mul_transvection_apply_of_ne
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: simp [transvection, Matrix.mul_add, hb]
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
a b : n
hb : b ≠ j
c : R
M : Matrix n n R
⊢ (M * transvection i j c) a b = M a b
state_after: no goals
Theorem: IntermediateField.finSepDegree_bot
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: rw [finSepDegree_eq_of_equiv _ _ _ (botEquiv F E), finSepDegree_self]
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
⊢ finSepDegree F ↥⊥ = 1
state_after: no goals
Theorem: List.exists_of_replaceF
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [pb]
state_before: α : Type u_1
p : α → Option α
b : α
l : List α
a a' : α
al : a ∈ b :: l
pa : p a = some a'
b' : α
pb : p b = some b'
⊢ b :: l = [] ++ b :: l ∧ replaceF p (b :: l) = [] ++ b' :: l
state_after: no goals

tactic: rw [h₃, cons_append]
state_before: α : Type u_1
p : α → Option α
b✝ : α
l : List α
a a' : α
al✝ : a ∈ b✝ :: l
pa : p a = some a'
b : α
al : Mem a l
pb : p b = none
c c' : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → p b = none
h₂ : p c = some c'
h₃ : l = l₁ ++ c :: l₂
h₄ : replaceF p l = l₁ ++ c' :: l₂
⊢ b :: l = b :: l₁ ++ c :: l₂
state_after: no goals

tactic: simp [pb, h₄]
state_before: α : Type u_1
p : α → Option α
b✝ : α
l : List α
a a' : α
al✝ : a ∈ b✝ :: l
pa : p a = some a'
b : α
al : Mem a l
pb : p b = none
c c' : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → p b = none
h₂ : p c = some c'
h₃ : l = l₁ ++ c :: l₂
h₄ : replaceF p l = l₁ ++ c' :: l₂
⊢ replaceF p (b :: l) = b :: l₁ ++ c' :: l₂
state_after: no goals
Theorem: isSeparatedMap_iff_disjoint_nhds
File: Mathlib/Topology/SeparatedMap.lean

tactic: simp only [(nhds_basis_opens x).disjoint_iff (nhds_basis_opens x'),
exists_prop, ← exists_and_left, and_assoc, and_comm, and_left_comm]
state_before: X : Type u_1
Y : Sort u_2
A : Type ?u.5618
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
x x' : X
x✝ : f x = f x'
⊢ (x ≠ x' → ∃ s₁ s₂, IsOpen s₁ ∧ IsOpen s₂ ∧ x ∈ s₁ ∧ x' ∈ s₂ ∧ Disjoint s₁ s₂) ↔ x ≠ x' → Disjoint (𝓝 x) (𝓝 x')
state_after: no goals
Theorem: Computation.results_thinkN_pure
File: Mathlib/Data/Seq/Computation.lean

tactic: have := results_thinkN n (results_pure a)
state_before: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ((pure a).thinkN n).Results a n
state_after: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
this : ((pure a).thinkN n).Results a (0 + n)
⊢ ((pure a).thinkN n).Results a n

tactic: rwa [Nat.zero_add] at this
state_before: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
this : ((pure a).thinkN n).Results a (0 + n)
⊢ ((pure a).thinkN n).Results a n
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.tendsto_testAgainstNN_filter_of_le_const
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: apply (ENNReal.tendsto_toNNReal (f.lintegral_lt_top_of_nnreal (μ : Measure Ω)).ne).comp
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
inst✝ : L.IsCountablyGenerated
μ : FiniteMeasure Ω
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂↑μ, (fs i) ω ≤ c
f : Ω →ᵇ ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂↑μ, Tendsto (fun i => (fs i) ω) L (𝓝 (f ω))
⊢ Tendsto (fun i => μ.testAgainstNN (fs i)) L (𝓝 (μ.testAgainstNN f))
state_after: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
inst✝ : L.IsCountablyGenerated
μ : FiniteMeasure Ω
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂↑μ, (fs i) ω ≤ c
f : Ω →ᵇ ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂↑μ, Tendsto (fun i => (fs i) ω) L (𝓝 (f ω))
⊢ Tendsto (fun i => ∫⁻ (ω : Ω), ↑((fs i) ω) ∂↑μ) L (𝓝 (∫⁻ (x : Ω), ↑(f x) ∂↑μ))

tactic: exact tendsto_lintegral_nn_filter_of_le_const μ fs_le_const fs_lim
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
inst✝ : L.IsCountablyGenerated
μ : FiniteMeasure Ω
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂↑μ, (fs i) ω ≤ c
f : Ω →ᵇ ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂↑μ, Tendsto (fun i => (fs i) ω) L (𝓝 (f ω))
⊢ Tendsto (fun i => ∫⁻ (ω : Ω), ↑((fs i) ω) ∂↑μ) L (𝓝 (∫⁻ (x : Ω), ↑(f x) ∂↑μ))
state_after: no goals
Theorem: div_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, mul_inv_eq_iff_eq_mul]
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 = c ↔ a = c * b
state_after: no goals