1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MvPolynomial.C_mul_monomial
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: show AddMonoidAlgebra.single _ _ * AddMonoidAlgebra.single _ _ = AddMonoidAlgebra.single _ _
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ C a * (monomial s) a' = (monomial s) (a * a')
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ AddMonoidAlgebra.single 0 a * AddMonoidAlgebra.single s a' = AddMonoidAlgebra.single s (a * a')

tactic: simp [C_apply, single_mul_single]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ AddMonoidAlgebra.single 0 a * AddMonoidAlgebra.single s a' = AddMonoidAlgebra.single s (a * a')
state_after: no goals
Theorem: List.countP_eq_length
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

tactic: rw [countP_eq_length_filter, filter_length_eq_length]
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ countP p l = l.length ↔ ∀ (a : α), a ∈ l → p a = true
state_after: no goals
Theorem: Bool.exists_bool'
File: Mathlib/Data/Bool/Basic.lean

tactic: cases x <;> cases b <;> first | exact .inl ‹_› | exact .inr ‹_›
state_before: p : Bool → Prop
b : Bool
x✝ : ∃ x, p x
x : Bool
hx : p x
⊢ p b ∨ p !b
state_after: no goals

tactic: exact .inl ‹_›
state_before: case true.true
p : Bool → Prop
x✝ : ∃ x, p x
hx : p true
⊢ p true ∨ p !true
state_after: no goals

tactic: exact .inr ‹_›
state_before: case true.false
p : Bool → Prop
x✝ : ∃ x, p x
hx : p true
⊢ p false ∨ p !false
state_after: no goals

tactic: cases h <;> exact ⟨_, ‹_›⟩
state_before: p : Bool → Prop
b : Bool
h : p b ∨ p !b
⊢ ∃ x, p x
state_after: no goals
Theorem: TopologicalSpace.Closeds.coe_iInf
File: Mathlib/Topology/Sets/Closeds.lean

tactic: ext
state_before: ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
s : ι → Closeds α
⊢ ↑(⨅ i, s i) = ⋂ i, ↑(s i)
state_after: case h
ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
s : ι → Closeds α
x✝ : α
⊢ x✝ ∈ ↑(⨅ i, s i) ↔ x✝ ∈ ⋂ i, ↑(s i)

tactic: simp
state_before: case h
ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
s : ι → Closeds α
x✝ : α
⊢ x✝ ∈ ↑(⨅ i, s i) ↔ x✝ ∈ ⋂ i, ↑(s i)
state_after: no goals
Theorem: Finset.lcm_image
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: classical induction' s using Finset.induction with c s _ ih <;> simp [*]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s✝ s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
g : γ → β
s : Finset γ
⊢ (image g s).lcm f = s.lcm (f ∘ g)
state_after: no goals

tactic: induction' s using Finset.induction with c s _ ih <;> simp [*]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s✝ s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
g : γ → β
s : Finset γ
⊢ (image g s).lcm f = s.lcm (f ∘ g)
state_after: no goals
Theorem: RCLike.norm_nsmul
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: rw [nsmul_eq_smul_cast K, norm_smul, RCLike.norm_natCast, nsmul_eq_mul]
state_before: K : Type u_1
E : Type u_2
inst✝² : RCLike K
z : K
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace K E
n : ℕ
x : E
⊢ ‖n • x‖ = n • ‖x‖
state_after: no goals
Theorem: ZMod.cast_descFactorial
File: Mathlib/Data/ZMod/Factorial.lean

tactic: rw [descFactorial_eq_prod_range, ← prod_range_add_one_eq_factorial]
state_before: n p : ℕ
h : n ≤ p
⊢ ↑((p - 1).descFactorial n) = (-1) ^ n * ↑n !
state_after: n p : ℕ
h : n ≤ p
⊢ ↑(∏ i ∈ range n, (p - 1 - i)) = (-1) ^ n * ↑(∏ x ∈ range n, (x + 1))

tactic: simp only [cast_prod]
state_before: n p : ℕ
h : n ≤ p
⊢ ↑(∏ i ∈ range n, (p - 1 - i)) = (-1) ^ n * ↑(∏ x ∈ range n, (x + 1))
state_after: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = (-1) ^ n * ∏ i ∈ range n, ↑(i + 1)

tactic: nth_rw 2 [← card_range n]
state_before: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = (-1) ^ n * ∏ i ∈ range n, ↑(i + 1)
state_after: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = (-1) ^ (range n).card * ∏ i ∈ range n, ↑(i + 1)

tactic: rw [pow_card_mul_prod]
state_before: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = (-1) ^ (range n).card * ∏ i ∈ range n, ↑(i + 1)
state_after: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = ∏ a ∈ range n, -1 * ↑(a + 1)

tactic: refine prod_congr rfl ?_
state_before: n p : ℕ
h : n ≤ p
⊢ ∏ i ∈ range n, ↑(p - 1 - i) = ∏ a ∈ range n, -1 * ↑(a + 1)
state_after: n p : ℕ
h : n ≤ p
⊢ ∀ x ∈ range n, ↑(p - 1 - x) = -1 * ↑(x + 1)

tactic: intro x hx
state_before: n p : ℕ
h : n ≤ p
⊢ ∀ x ∈ range n, ↑(p - 1 - x) = -1 * ↑(x + 1)
state_after: n p : ℕ
h : n ≤ p
x : ℕ
hx : x ∈ range n
⊢ ↑(p - 1 - x) = -1 * ↑(x + 1)

tactic: rw [← tsub_add_eq_tsub_tsub_swap,
  Nat.cast_sub <| Nat.le_trans (Nat.add_one_le_iff.mpr (List.mem_range.mp hx)) h,
  CharP.cast_eq_zero, zero_sub, cast_succ, neg_add_rev, mul_add, neg_mul, one_mul,
  mul_one, add_comm]
state_before: n p : ℕ
h : n ≤ p
x : ℕ
hx : x ∈ range n
⊢ ↑(p - 1 - x) = -1 * ↑(x + 1)
state_after: no goals
Theorem: Multiset.mem_lists_iff
File: Mathlib/Data/Fintype/List.lean

tactic: induction s using Quotient.inductionOn
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Multiset α
l : List α
⊢ l ∈ s.lists ↔ s = ⟦l⟧
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
l a✝ : List α
⊢ l ∈ lists ⟦a✝⟧ ↔ ⟦a✝⟧ = ⟦l⟧

tactic: simpa using perm_comm
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
l a✝ : List α
⊢ l ∈ lists ⟦a✝⟧ ↔ ⟦a✝⟧ = ⟦l⟧
state_after: no goals
Theorem: quadratic_eq_zero_iff_of_discrim_eq_zero
File: Mathlib/Algebra/QuadraticDiscriminant.lean

tactic: have : discrim a b c = 0 * 0 := by rw [h, mul_zero]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
⊢ a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
this : discrim a b c = 0 * 0
⊢ a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)

tactic: rw [quadratic_eq_zero_iff ha this, add_zero, sub_zero, or_self_iff]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
this : discrim a b c = 0 * 0
⊢ a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)
state_after: no goals

tactic: rw [h, mul_zero]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
⊢ discrim a b c = 0 * 0
state_after: no goals
Theorem: MeasureTheory.snorm_exponent_top
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: simp [snorm]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
⊢ snorm f ⊤ μ = snormEssSup f μ
state_after: no goals
Theorem: Batteries.RBNode.memP_reverse
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: simp [MemP]
state_before: α : Type u_1
cut : α → Ordering
t : RBNode α
⊢ MemP cut t.reverse ↔ MemP (fun x => (cut x).swap) t
state_after: α : Type u_1
cut : α → Ordering
t : RBNode α
⊢ Any (fun x => cut x = Ordering.eq) t ↔ Any (fun x => (cut x).swap = Ordering.eq) t

tactic: apply Iff.of_eq
state_before: α : Type u_1
cut : α → Ordering
t : RBNode α
⊢ Any (fun x => cut x = Ordering.eq) t ↔ Any (fun x => (cut x).swap = Ordering.eq) t
state_after: case h
α : Type u_1
cut : α → Ordering
t : RBNode α
⊢ Any (fun x => cut x = Ordering.eq) t = Any (fun x => (cut x).swap = Ordering.eq) t

tactic: congr
state_before: case h
α : Type u_1
cut : α → Ordering
t : RBNode α
⊢ Any (fun x => cut x = Ordering.eq) t = Any (fun x => (cut x).swap = Ordering.eq) t
state_after: case h.e_p
α : Type u_1
cut : α → Ordering
t : RBNode α
⊢ (fun x => cut x = Ordering.eq) = fun x => (cut x).swap = Ordering.eq

tactic: funext x
state_before: case h.e_p
α : Type u_1
cut : α → Ordering
t : RBNode α
⊢ (fun x => cut x = Ordering.eq) = fun x => (cut x).swap = Ordering.eq
state_after: case h.e_p.h
α : Type u_1
cut : α → Ordering
t : RBNode α
x : α
⊢ (cut x = Ordering.eq) = ((cut x).swap = Ordering.eq)

tactic: rw [← Ordering.swap_inj]
state_before: case h.e_p.h
α : Type u_1
cut : α → Ordering
t : RBNode α
x : α
⊢ (cut x = Ordering.eq) = ((cut x).swap = Ordering.eq)
state_after: case h.e_p.h
α : Type u_1
cut : α → Ordering
t : RBNode α
x : α
⊢ ((cut x).swap = Ordering.eq.swap) = ((cut x).swap = Ordering.eq)

tactic: rfl
state_before: case h.e_p.h
α : Type u_1
cut : α → Ordering
t : RBNode α
x : α
⊢ ((cut x).swap = Ordering.eq.swap) = ((cut x).swap = Ordering.eq)
state_after: no goals
Theorem: Finset.offDiag_singleton
File: Mathlib/Data/Finset/Prod.lean

tactic: simp [← Finset.card_eq_zero]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
a : α
⊢ {a}.offDiag = ∅
state_after: no goals
Theorem: TensorPower.mul_algebraMap₀
File: Mathlib/LinearAlgebra/TensorPower.lean

tactic: rw [gMul_eq_coe_linearMap, algebraMap₀_eq_smul_one, LinearMap.map_smul,
  LinearEquiv.map_smul, ← gMul_eq_coe_linearMap, mul_one]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
r : R
a : ⨂[R]^n M
⊢ (cast R M ⋯) (GradedMonoid.GMul.mul a (algebraMap₀ r)) = r • a
state_after: no goals
Theorem: Equiv.swapCore_swapCore
File: Mathlib/Logic/Equiv/Basic.lean

tactic: unfold swapCore
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a b : α
⊢ swapCore a b (swapCore a b r) = r
state_after: α : Sort u_1
inst✝ : DecidableEq α
r a b : α
⊢ (if (if r = a then b else if r = b then a else r) = a then b
    else if (if r = a then b else if r = b then a else r) = b then a else if r = a then b else if r = b then a else r) =
    r

tactic: split_ifs <;> cc
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a b : α
⊢ (if (if r = a then b else if r = b then a else r) = a then b
    else if (if r = a then b else if r = b then a else r) = b then a else if r = a then b else if r = b then a else r) =
    r
state_after: no goals
Theorem: Finsupp.support_update_subset
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [support_update]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
⊢ (f.update a b).support ⊆ insert a f.support
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
⊢ (if b = 0 then f.support.erase a else insert a f.support) ⊆ insert a f.support

tactic: split_ifs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
⊢ (if b = 0 then f.support.erase a else insert a f.support) ⊆ insert a f.support
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
h✝ : b = 0
⊢ f.support.erase a ⊆ insert a f.support

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
h✝ : ¬b = 0
⊢ insert a f.support ⊆ insert a f.support

tactic: exact (erase_subset _ _).trans (subset_insert _ _)
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
h✝ : b = 0
⊢ f.support.erase a ⊆ insert a f.support
state_after: no goals

tactic: rfl
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
h✝ : ¬b = 0
⊢ insert a f.support ⊆ insert a f.support
state_after: no goals
Theorem: Finset.mulDysonETransform.smul_finset_snd_subset_fst
File: Mathlib/Combinatorics/Additive/ETransform.lean

tactic: dsimp
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ e • (mulDysonETransform e x).2 ⊆ (mulDysonETransform e x).1
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ e • (x.2 ∩ e⁻¹ • x.1) ⊆ x.1 ∪ e • x.2

tactic: rw [smul_finset_inter, smul_inv_smul, inter_comm]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ e • (x.2 ∩ e⁻¹ • x.1) ⊆ x.1 ∪ e • x.2
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ x.1 ∩ e • x.2 ⊆ x.1 ∪ e • x.2

tactic: exact inter_subset_union
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ x.1 ∩ e • x.2 ⊆ x.1 ∪ e • x.2
state_after: no goals
Theorem: Zsqrtd.nonneg_muld
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp only [muld_val, mul_neg]
state_before: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := ↑x, im := -↑y }.Nonneg
⊢ (sqrtd * { re := ↑x, im := -↑y }).Nonneg
state_after: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := ↑x, im := -↑y }.Nonneg
⊢ { re := -(↑d * ↑y), im := ↑x }.Nonneg

tactic: apply nonnegg_neg_pos.2
state_before: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := ↑x, im := -↑y }.Nonneg
⊢ { re := -(↑d * ↑y), im := ↑x }.Nonneg
state_after: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := ↑x, im := -↑y }.Nonneg
⊢ SqLe (d * y) 1 x d

tactic: simpa [SqLe, mul_comm, mul_left_comm] using Nat.mul_le_mul_left d (nonnegg_pos_neg.1 ha)
state_before: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := ↑x, im := -↑y }.Nonneg
⊢ SqLe (d * y) 1 x d
state_after: no goals

tactic: simp only [muld_val]
state_before: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := -↑x, im := ↑y }.Nonneg
⊢ (sqrtd * { re := -↑x, im := ↑y }).Nonneg
state_after: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := -↑x, im := ↑y }.Nonneg
⊢ { re := ↑d * ↑y, im := -↑x }.Nonneg

tactic: apply nonnegg_pos_neg.2
state_before: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := -↑x, im := ↑y }.Nonneg
⊢ { re := ↑d * ↑y, im := -↑x }.Nonneg
state_after: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := -↑x, im := ↑y }.Nonneg
⊢ SqLe x d (d * y) 1

tactic: simpa [SqLe, mul_comm, mul_left_comm] using Nat.mul_le_mul_left d (nonnegg_neg_pos.1 ha)
state_before: d : ℕ
a : ℤ√↑d
ha✝ : a.Nonneg
x y : ℕ
ha : { re := -↑x, im := ↑y }.Nonneg
⊢ SqLe x d (d * y) 1
state_after: no goals
Theorem: Submodule.toLinearPMap_range
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: rwa [← LinearPMap.graph_map_snd_eq_range, toLinearPMap_graph_eq]
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ x ∈ g, x.1 = 0 → x.2 = 0
⊢ LinearMap.range g.toLinearPMap.toFun = map (LinearMap.snd R E F) g
state_after: no goals
Theorem: Set.Icc_prod_Icc
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
a₁ a₂ : α
b₁ b₂ : β
⊢ Icc a₁ a₂ ×ˢ Icc b₁ b₂ = Icc (a₁, b₁) (a₂, b₂)
state_after: case h.mk
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
a₁ a₂ : α
b₁ b₂ : β
x : α
y : β
⊢ (x, y) ∈ Icc a₁ a₂ ×ˢ Icc b₁ b₂ ↔ (x, y) ∈ Icc (a₁, b₁) (a₂, b₂)

tactic: simp [and_assoc, and_comm, and_left_comm]
state_before: case h.mk
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
a₁ a₂ : α
b₁ b₂ : β
x : α
y : β
⊢ (x, y) ∈ Icc a₁ a₂ ×ˢ Icc b₁ b₂ ↔ (x, y) ∈ Icc (a₁, b₁) (a₂, b₂)
state_after: no goals
Theorem: Rat.zero_iff_num_zero
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [*]
state_before: q✝ a b c q : ℚ
x✝ : q = 0
⊢ q.num = 0
state_after: no goals
Theorem: ProbabilityTheory.kernel.map_id
File: Mathlib/Probability/Kernel/Composition.lean

tactic: ext a
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : ↥(kernel α β)
⊢ map κ id ⋯ = κ
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : ↥(kernel α β)
a : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((map κ id ⋯) a) s✝ = (κ a) s✝

tactic: rw [map_apply]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : ↥(kernel α β)
a : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((map κ id ⋯) a) s✝ = (κ a) s✝
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : ↥(kernel α β)
a : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ (Measure.map id (κ a)) s✝ = (κ a) s✝

tactic: simp
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : ↥(kernel α β)
a : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ (Measure.map id (κ a)) s✝ = (κ a) s✝
state_after: no goals
Theorem: Batteries.RBNode.Stream.forIn_eq_forIn_toList
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: conv => lhs; simp only [forIn, RBNode.forIn]
state_before: m : Type u_1 → Type u_2
α : Type u_3
α✝ : Type u_1
init : α✝
f : α → α✝ → m (ForInStep α✝)
inst✝¹ : Monad m
inst✝ : LawfulMonad m
t : RBNode α
⊢ forIn t init f = forIn t.toList init f
state_after: m : Type u_1 → Type u_2
α : Type u_3
α✝ : Type u_1
init : α✝
f : α → α✝ → m (ForInStep α✝)
inst✝¹ : Monad m
inst✝ : LawfulMonad m
t : RBNode α
⊢ ForInStep.run <$> forIn.visit f t init = forIn t.toList init f

tactic: rw [List.forIn_eq_bindList, forIn_visit_eq_bindList]
state_before: m : Type u_1 → Type u_2
α : Type u_3
α✝ : Type u_1
init : α✝
f : α → α✝ → m (ForInStep α✝)
inst✝¹ : Monad m
inst✝ : LawfulMonad m
t : RBNode α
⊢ ForInStep.run <$> forIn.visit f t init = forIn t.toList init f
state_after: no goals
Theorem: Int.fract_intCast
File: Mathlib/Algebra/Order/Floor.lean

tactic: unfold fract
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a : α
z : ℤ
⊢ fract ↑z = 0
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a : α
z : ℤ
⊢ ↑z - ↑⌊↑z⌋ = 0

tactic: rw [floor_intCast]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a : α
z : ℤ
⊢ ↑z - ↑⌊↑z⌋ = 0
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a : α
z : ℤ
⊢ ↑z - ↑z = 0

tactic: exact sub_self _
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a : α
z : ℤ
⊢ ↑z - ↑z = 0
state_after: no goals
Theorem: SimpleGraph.edgeSet_deleteEdges
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp [deleteEdges]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
H : SimpleGraph V
s✝ s₁ s₂ s : Set (Sym2 V)
⊢ (G.deleteEdges s).edgeSet = G.edgeSet \ s
state_after: no goals
Theorem: Nat.digitsAux_zero
File: Mathlib/Data/Nat/Digits.lean

tactic: rw [digitsAux]
state_before: n b : ℕ
h : 2 ≤ b
⊢ b.digitsAux h 0 = []
state_after: no goals
Theorem: InnerProductGeometry.cos_eq_zero_iff_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [← cos_pi_div_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ cos (angle x y) = 0 ↔ angle x y = π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ cos (angle x y) = cos (π / 2) ↔ angle x y = π / 2

tactic: apply injOn_cos.eq_iff ⟨angle_nonneg x y, angle_le_pi x y⟩
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ cos (angle x y) = cos (π / 2) ↔ angle x y = π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ π / 2 ∈ Icc 0 π

tactic: constructor <;> linarith [pi_pos]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ π / 2 ∈ Icc 0 π
state_after: no goals
Theorem: Complex.range_exp
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: rintro ⟨x, rfl⟩
state_before: x : ℂ
⊢ x ∈ Set.range cexp → x ∈ {0}ᶜ
state_after: case intro
x : ℂ
⊢ cexp x ∈ {0}ᶜ

tactic: exact exp_ne_zero x
state_before: case intro
x : ℂ
⊢ cexp x ∈ {0}ᶜ
state_after: no goals
Theorem: Real.cosh_arsinh
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

tactic: rw [← sqrt_sq (cosh_pos _).le, cosh_sq', sinh_arsinh]
state_before: x✝ y x : ℝ
⊢ cosh (arsinh x) = √(1 + x ^ 2)
state_after: no goals
Theorem: Polynomial.natDegree_C_mul
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

tactic: simp only [natDegree, degree_C_mul a0]
state_before: R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
a0 : a ≠ 0
⊢ (C a * p).natDegree = p.natDegree
state_after: no goals