1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.prod_disjiUnion
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: refine Eq.trans ?_ (fold_disjiUnion h)
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ ∏ x ∈ s.disjiUnion t h, f x = ∏ i ∈ s, ∏ x ∈ t i, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ ∏ x ∈ s.disjiUnion t h, f x =
    fold (fun x x_1 => x * x_1) (fold (fun x x_1 => x * x_1) 1 (fun i => 1) s) (fun x => f x) (s.disjiUnion t h)

tactic: dsimp [Finset.prod, Multiset.prod, Multiset.fold, Finset.disjUnion, Finset.fold]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ ∏ x ∈ s.disjiUnion t h, f x =
    fold (fun x x_1 => x * x_1) (fold (fun x x_1 => x * x_1) 1 (fun i => 1) s) (fun x => f x) (s.disjiUnion t h)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun x => f x) (s.val.bind fun a => (t a).val)) =
    Multiset.foldr (fun x x_1 => x * x_1) ⋯
      (Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun i => 1) s.val))
      (Multiset.map (fun x => f x) (s.val.bind fun a => (t a).val))

tactic: congr
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun x => f x) (s.val.bind fun a => (t a).val)) =
    Multiset.foldr (fun x x_1 => x * x_1) ⋯
      (Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun i => 1) s.val))
      (Multiset.map (fun x => f x) (s.val.bind fun a => (t a).val))
state_after: case e_b
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ 1 = Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun i => 1) s.val)

tactic: exact prod_const_one.symm
state_before: case e_b
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ 1 = Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun i => 1) s.val)
state_after: no goals
Theorem: LinearMap.toMatrix_id_eq_basis_toMatrix
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: ext i
state_before: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
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₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Finite ι'
⊢ (toMatrix b b') id = b'.toMatrix ⇑b
state_after: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
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₂
e : Basis ι R M
v : ι' → M
i✝ : ι
j : ι'
N : Type u_9
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Finite ι'
i : ι'
j✝ : ι
⊢ (toMatrix b b') id i j✝ = b'.toMatrix (⇑b) i j✝

tactic: apply LinearMap.toMatrix_apply
state_before: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
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₂
e : Basis ι R M
v : ι' → M
i✝ : ι
j : ι'
N : Type u_9
inst✝⁴ : AddCommMonoid N
inst✝³ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Finite ι'
i : ι'
j✝ : ι
⊢ (toMatrix b b') id i j✝ = b'.toMatrix (⇑b) i j✝
state_after: no goals
Theorem: Algebra.embeddingsMatrixReindex_eq_vandermonde
File: Mathlib/RingTheory/Trace.lean

tactic: ext i j
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁸ : CommRing R
inst✝¹⁷ : CommRing S
inst✝¹⁶ : CommRing T
inst✝¹⁵ : Algebra R S
inst✝¹⁴ : Algebra R T
K : Type u_4
L : Type u_5
inst✝¹³ : Field K
inst✝¹² : Field L
inst✝¹¹ : Algebra K L
ι κ : Type w
inst✝¹⁰ : Fintype ι
F : Type u_6
inst✝⁹ : Field F
inst✝⁸ : Algebra R L
inst✝⁷ : Algebra L F
inst✝⁶ : Algebra R F
inst✝⁵ : IsScalarTower R L F
A : Type u
B : Type v
C : Type z
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra A B
inst✝¹ : CommRing C
inst✝ : Algebra A C
pb : PowerBasis A B
e : Fin pb.dim ≃ (B →ₐ[A] C)
⊢ embeddingsMatrixReindex A C (⇑pb.basis) e = (vandermonde fun i => (e i) pb.gen)ᵀ
state_after: case a
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁸ : CommRing R
inst✝¹⁷ : CommRing S
inst✝¹⁶ : CommRing T
inst✝¹⁵ : Algebra R S
inst✝¹⁴ : Algebra R T
K : Type u_4
L : Type u_5
inst✝¹³ : Field K
inst✝¹² : Field L
inst✝¹¹ : Algebra K L
ι κ : Type w
inst✝¹⁰ : Fintype ι
F : Type u_6
inst✝⁹ : Field F
inst✝⁸ : Algebra R L
inst✝⁷ : Algebra L F
inst✝⁶ : Algebra R F
inst✝⁵ : IsScalarTower R L F
A : Type u
B : Type v
C : Type z
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra A B
inst✝¹ : CommRing C
inst✝ : Algebra A C
pb : PowerBasis A B
e : Fin pb.dim ≃ (B →ₐ[A] C)
i j : Fin pb.dim
⊢ embeddingsMatrixReindex A C (⇑pb.basis) e i j = (vandermonde fun i => (e i) pb.gen)ᵀ i j

tactic: simp [embeddingsMatrixReindex, embeddingsMatrix]
state_before: case a
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁸ : CommRing R
inst✝¹⁷ : CommRing S
inst✝¹⁶ : CommRing T
inst✝¹⁵ : Algebra R S
inst✝¹⁴ : Algebra R T
K : Type u_4
L : Type u_5
inst✝¹³ : Field K
inst✝¹² : Field L
inst✝¹¹ : Algebra K L
ι κ : Type w
inst✝¹⁰ : Fintype ι
F : Type u_6
inst✝⁹ : Field F
inst✝⁸ : Algebra R L
inst✝⁷ : Algebra L F
inst✝⁶ : Algebra R F
inst✝⁵ : IsScalarTower R L F
A : Type u
B : Type v
C : Type z
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra A B
inst✝¹ : CommRing C
inst✝ : Algebra A C
pb : PowerBasis A B
e : Fin pb.dim ≃ (B →ₐ[A] C)
i j : Fin pb.dim
⊢ embeddingsMatrixReindex A C (⇑pb.basis) e i j = (vandermonde fun i => (e i) pb.gen)ᵀ i j
state_after: no goals
Theorem: Cardinal.range_ofENat
File: Mathlib/SetTheory/Cardinal/ENat.lean

tactic: refine (range_subset_iff.2 ofENat_le_aleph0).antisymm fun x (hx : x ≤ ℵ₀) ↦ ?_
state_before: ⊢ range ofENat = Iic ℵ₀
state_after: x : Cardinal.{u_1}
hx : x ≤ ℵ₀
⊢ x ∈ range ofENat

tactic: rcases hx.lt_or_eq with hlt | rfl
state_before: x : Cardinal.{u_1}
hx : x ≤ ℵ₀
⊢ x ∈ range ofENat
state_after: case inl
x : Cardinal.{u_1}
hx : x ≤ ℵ₀
hlt : x < ℵ₀
⊢ x ∈ range ofENat

case inr
hx : ℵ₀ ≤ ℵ₀
⊢ ℵ₀ ∈ range ofENat

tactic: lift x to ℕ using hlt
state_before: case inl
x : Cardinal.{u_1}
hx : x ≤ ℵ₀
hlt : x < ℵ₀
⊢ x ∈ range ofENat
state_after: case inl.intro
x : ℕ
hx : ↑x ≤ ℵ₀
⊢ ↑x ∈ range ofENat

tactic: exact mem_range_self (x : ℕ∞)
state_before: case inl.intro
x : ℕ
hx : ↑x ≤ ℵ₀
⊢ ↑x ∈ range ofENat
state_after: no goals

tactic: exact mem_range_self (⊤ : ℕ∞)
state_before: case inr
hx : ℵ₀ ≤ ℵ₀
⊢ ℵ₀ ∈ range ofENat
state_after: no goals
Theorem: pairwise_on_bool
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simpa [Pairwise, Function.onFun] using @hr a b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a✝ b✝ : α
hr : Symmetric r
a b : α
⊢ Pairwise (r on fun c => bif c then a else b) ↔ r a b
state_after: no goals
Theorem: Ordinal.sSup_eq_bsup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: congr
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ sSup (o.brange f) = o.bsup f
state_after: case e_a
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ o.brange f = range (o.familyOfBFamily f)

tactic: rw [range_familyOfBFamily]
state_before: case e_a
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ o.brange f = range (o.familyOfBFamily f)
state_after: no goals
Theorem: bernstein_nonneg
File: Mathlib/Analysis/SpecialFunctions/Bernstein.lean

tactic: simp only [bernstein_apply]
state_before: n ν : ℕ
x : ↑I
⊢ 0 ≤ (bernstein n ν) x
state_after: n ν : ℕ
x : ↑I
⊢ 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)

tactic: have h₁ : (0:ℝ) ≤ x := by unit_interval
state_before: n ν : ℕ
x : ↑I
⊢ 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)
state_after: n ν : ℕ
x : ↑I
h₁ : 0 ≤ ↑x
⊢ 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)

tactic: have h₂ : (0:ℝ) ≤ 1 - x := by unit_interval
state_before: n ν : ℕ
x : ↑I
h₁ : 0 ≤ ↑x
⊢ 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)
state_after: n ν : ℕ
x : ↑I
h₁ : 0 ≤ ↑x
h₂ : 0 ≤ 1 - ↑x
⊢ 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)

tactic: positivity
state_before: n ν : ℕ
x : ↑I
h₁ : 0 ≤ ↑x
h₂ : 0 ≤ 1 - ↑x
⊢ 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)
state_after: no goals

tactic: unit_interval
state_before: n ν : ℕ
x : ↑I
⊢ 0 ≤ ↑x
state_after: no goals

tactic: unit_interval
state_before: n ν : ℕ
x : ↑I
h₁ : 0 ≤ ↑x
⊢ 0 ≤ 1 - ↑x
state_after: no goals
Theorem: Matrix.dotProduct_cons
File: Mathlib/Data/Matrix/Notation.lean

tactic: simp [dotProduct, Fin.sum_univ_succ, vecHead, vecTail]
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
v : Fin n.succ → α
x : α
w : Fin n → α
⊢ v ⬝ᵥ vecCons x w = vecHead v * x + vecTail v ⬝ᵥ w
state_after: no goals
Theorem: MeasurableSpace.le_invariants_iterate
File: Mathlib/MeasureTheory/MeasurableSpace/Invariants.lean

tactic: induction n with
| zero => simp [invariants_le]
| succ n ihn => exact le_trans (le_inf ihn le_rfl) (inf_le_invariants_comp _ _)
state_before: α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
n : ℕ
⊢ invariants f ≤ invariants f^[n]
state_after: no goals

tactic: simp [invariants_le]
state_before: case zero
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
⊢ invariants f ≤ invariants f^[0]
state_after: no goals

tactic: exact le_trans (le_inf ihn le_rfl) (inf_le_invariants_comp _ _)
state_before: case succ
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
n : ℕ
ihn : invariants f ≤ invariants f^[n]
⊢ invariants f ≤ invariants f^[n + 1]
state_after: no goals
Theorem: Polynomial.roots_pow
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: induction' n with n ihn
state_before: R : Type u
S : Type v
T : Type w
a b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
n : ℕ
⊢ (p ^ n).roots = n • p.roots
state_after: case zero
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
⊢ (p ^ 0).roots = 0 • p.roots

case succ
R : Type u
S : Type v
T : Type w
a b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
n : ℕ
ihn : (p ^ n).roots = n • p.roots
⊢ (p ^ (n + 1)).roots = (n + 1) • p.roots

tactic: rw [pow_zero, roots_one, zero_smul, empty_eq_zero]
state_before: case zero
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
⊢ (p ^ 0).roots = 0 • p.roots
state_after: no goals

tactic: rcases eq_or_ne p 0 with (rfl | hp)
state_before: case succ
R : Type u
S : Type v
T : Type w
a b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
n : ℕ
ihn : (p ^ n).roots = n • p.roots
⊢ (p ^ (n + 1)).roots = (n + 1) • p.roots
state_after: case succ.inl
R : Type u
S : Type v
T : Type w
a b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
n : ℕ
ihn : (0 ^ n).roots = n • roots 0
⊢ (0 ^ (n + 1)).roots = (n + 1) • roots 0

case succ.inr
R : Type u
S : Type v
T : Type w
a b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
n : ℕ
ihn : (p ^ n).roots = n • p.roots
hp : p ≠ 0
⊢ (p ^ (n + 1)).roots = (n + 1) • p.roots

tactic: rw [zero_pow n.succ_ne_zero, roots_zero, smul_zero]
state_before: case succ.inl
R : Type u
S : Type v
T : Type w
a b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
n : ℕ
ihn : (0 ^ n).roots = n • roots 0
⊢ (0 ^ (n + 1)).roots = (n + 1) • roots 0
state_after: no goals

tactic: rw [pow_succ, roots_mul (mul_ne_zero (pow_ne_zero _ hp) hp), ihn, add_smul, one_smul]
state_before: case succ.inr
R : Type u
S : Type v
T : Type w
a b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
n : ℕ
ihn : (p ^ n).roots = n • p.roots
hp : p ≠ 0
⊢ (p ^ (n + 1)).roots = (n + 1) • p.roots
state_after: no goals
Theorem: Set.pow_subset_pow
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [pow_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ s ^ 0 ⊆ t ^ 0
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ 1 ⊆ t ^ 0

tactic: exact Subset.rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ 1 ⊆ t ^ 0
state_after: no goals

tactic: rw [pow_succ]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ (n + 1) ⊆ t ^ (n + 1)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ n * s ⊆ t ^ (n + 1)

tactic: exact mul_subset_mul (pow_subset_pow hst _) hst
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ n * s ⊆ t ^ (n + 1)
state_after: no goals
Theorem: ProbabilityTheory.kernel.prodMkLeft_add
File: Mathlib/Probability/Kernel/Composition.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ η : ↥(kernel α β)
⊢ prodMkLeft γ (κ + η) = prodMkLeft γ κ + prodMkLeft γ η
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ η : ↥(kernel α β)
a✝¹ : γ × α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((prodMkLeft γ (κ + η)) a✝¹) s✝ = ((prodMkLeft γ κ + prodMkLeft γ η) 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
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ η : ↥(kernel α β)
a✝¹ : γ × α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((prodMkLeft γ (κ + η)) a✝¹) s✝ = ((prodMkLeft γ κ + prodMkLeft γ η) a✝¹) s✝
state_after: no goals
Theorem: FreeGroup.Red.not_step_nil
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

tactic: generalize h' : [] = L'
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ ¬Step [] L
state_after: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
⊢ ¬Step L' L

tactic: intro h
state_before: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
⊢ ¬Step L' L
state_after: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
h : Step L' L
⊢ False

tactic: cases' h with L₁ L₂
state_before: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
h : Step L' L
⊢ False
state_after: case not
α : Type u
L₁✝ L₂✝ L₃ L₄ L₁ L₂ : List (α × Bool)
x✝ : α
b✝ : Bool
h' : [] = L₁ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂
⊢ False

tactic: simp [List.nil_eq_append] at h'
state_before: case not
α : Type u
L₁✝ L₂✝ L₃ L₄ L₁ L₂ : List (α × Bool)
x✝ : α
b✝ : Bool
h' : [] = L₁ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂
⊢ False
state_after: no goals
Theorem: MvPolynomial.radical_le_vanishingIdeal_zeroLocus
File: Mathlib/RingTheory/Nullstellensatz.lean

tactic: intro p hp x hx
state_before: k : Type u_1
inst✝ : Field k
σ : Type u_2
I : Ideal (MvPolynomial σ k)
⊢ I.radical ≤ vanishingIdeal (zeroLocus I)
state_after: k : Type u_1
inst✝ : Field k
σ : Type u_2
I : Ideal (MvPolynomial σ k)
p : MvPolynomial σ k
hp : p ∈ I.radical
x : σ → k
hx : x ∈ zeroLocus I
⊢ (eval x) p = 0

tactic: rw [← mem_vanishingIdeal_singleton_iff]
state_before: k : Type u_1
inst✝ : Field k
σ : Type u_2
I : Ideal (MvPolynomial σ k)
p : MvPolynomial σ k
hp : p ∈ I.radical
x : σ → k
hx : x ∈ zeroLocus I
⊢ (eval x) p = 0
state_after: k : Type u_1
inst✝ : Field k
σ : Type u_2
I : Ideal (MvPolynomial σ k)
p : MvPolynomial σ k
hp : p ∈ I.radical
x : σ → k
hx : x ∈ zeroLocus I
⊢ p ∈ vanishingIdeal {x}

tactic: rw [radical_eq_sInf] at hp
state_before: k : Type u_1
inst✝ : Field k
σ : Type u_2
I : Ideal (MvPolynomial σ k)
p : MvPolynomial σ k
hp : p ∈ I.radical
x : σ → k
hx : x ∈ zeroLocus I
⊢ p ∈ vanishingIdeal {x}
state_after: k : Type u_1
inst✝ : Field k
σ : Type u_2
I : Ideal (MvPolynomial σ k)
p : MvPolynomial σ k
hp : p ∈ sInf {J | I ≤ J ∧ J.IsPrime}
x : σ → k
hx : x ∈ zeroLocus I
⊢ p ∈ vanishingIdeal {x}

tactic: refine
  (mem_sInf.mp hp)
    ⟨le_trans (le_vanishingIdeal_zeroLocus I)
        (vanishingIdeal_anti_mono fun y hy => hy.symm ▸ hx),
      IsMaximal.isPrime' _⟩
state_before: k : Type u_1
inst✝ : Field k
σ : Type u_2
I : Ideal (MvPolynomial σ k)
p : MvPolynomial σ k
hp : p ∈ sInf {J | I ≤ J ∧ J.IsPrime}
x : σ → k
hx : x ∈ zeroLocus I
⊢ p ∈ vanishingIdeal {x}
state_after: no goals
Theorem: Cardinal.le_sum
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← Quotient.out_eq (f i)]
state_before: α β : Type u
ι : Type u_1
f : ι → Cardinal.{max u_1 u_2}
i : ι
⊢ f i ≤ sum f
state_after: α β : Type u
ι : Type u_1
f : ι → Cardinal.{max u_1 u_2}
i : ι
⊢ ⟦Quotient.out (f i)⟧ ≤ sum f

tactic: exact ⟨⟨fun a => ⟨i, a⟩, fun a b h => by injection h⟩⟩
state_before: α β : Type u
ι : Type u_1
f : ι → Cardinal.{max u_1 u_2}
i : ι
⊢ ⟦Quotient.out (f i)⟧ ≤ sum f
state_after: no goals

tactic: injection h
state_before: α β : Type u
ι : Type u_1
f : ι → Cardinal.{max u_1 u_2}
i : ι
a b : Quotient.out (f i)
h : (fun a => ⟨i, a⟩) a = (fun a => ⟨i, a⟩) b
⊢ a = b
state_after: no goals
Theorem: mul_le_mul_of_mul_div_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [← mul_div_assoc] at h
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a * (b / c) ≤ d
hc : 0 < c
⊢ b * a ≤ d * c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a * b / c ≤ d
hc : 0 < c
⊢ b * a ≤ d * c

tactic: rwa [mul_comm b, ← div_le_iff hc]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a * b / c ≤ d
hc : 0 < c
⊢ b * a ≤ d * c
state_after: no goals
Theorem: AlgebraicGeometry.IsAffineOpen.isCompact
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

tactic: convert @IsCompact.image _ _ _ _ Set.univ hU.fromSpec.1.base PrimeSpectrum.compactSpace.1
  (by fun_prop)
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ IsCompact ↑U
state_after: case h.e'_3
X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ ↑U = ⇑hU.fromSpec.val.base '' Set.univ

tactic: convert hU.range_fromSpec.symm
state_before: case h.e'_3
X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ ↑U = ⇑hU.fromSpec.val.base '' Set.univ
state_after: case h.e'_3
X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ ⇑hU.fromSpec.val.base '' Set.univ = Set.range ⇑hU.fromSpec.val.base

tactic: exact Set.image_univ
state_before: case h.e'_3
X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ ⇑hU.fromSpec.val.base '' Set.univ = Set.range ⇑hU.fromSpec.val.base
state_after: no goals

tactic: fun_prop
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Continuous ⇑hU.fromSpec.val.base
state_after: no goals
Theorem: Subgroup.index_eq_two_iff
File: Mathlib/GroupTheory/Index.lean

tactic: simp only [index, Nat.card_eq_two_iff' ((1 : G) : G ⧸ H), ExistsUnique, inv_mem_iff,
  QuotientGroup.exists_mk, QuotientGroup.forall_mk, Ne, QuotientGroup.eq, mul_one,
  xor_iff_iff_not]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ H.index = 2 ↔ ∃ a, ∀ (b : G), Xor' (b * a ∈ H) (b ∈ H)
state_after: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ (∃ x ∉ H, ∀ x_1 ∉ H, x_1⁻¹ * x ∈ H) ↔ ∃ a, ∀ (b : G), b * a ∈ H ↔ b ∉ H

tactic: refine exists_congr fun a =>
  ⟨fun ha b => ⟨fun hba hb => ?_, fun hb => ?_⟩, fun ha => ⟨?_, fun b hb => ?_⟩⟩
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ (∃ x ∉ H, ∀ x_1 ∉ H, x_1⁻¹ * x ∈ H) ↔ ∃ a, ∀ (b : G), b * a ∈ H ↔ b ∉ H
state_after: case refine_1
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : a ∉ H ∧ ∀ x ∉ H, x⁻¹ * a ∈ H
b : G
hba : b * a ∈ H
hb : b ∈ H
⊢ False

case refine_2
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : a ∉ H ∧ ∀ x ∉ H, x⁻¹ * a ∈ H
b : G
hb : b ∉ H
⊢ b * a ∈ H

case refine_3
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : ∀ (b : G), b * a ∈ H ↔ b ∉ H
⊢ a ∉ H

case refine_4
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : ∀ (b : G), b * a ∈ H ↔ b ∉ H
b : G
hb : b ∉ H
⊢ b⁻¹ * a ∈ H

tactic: exact ha.1 ((mul_mem_cancel_left hb).1 hba)
state_before: case refine_1
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : a ∉ H ∧ ∀ x ∉ H, x⁻¹ * a ∈ H
b : G
hba : b * a ∈ H
hb : b ∈ H
⊢ False
state_after: no goals

tactic: exact inv_inv b ▸ ha.2 _ (mt (inv_mem_iff (x := b)).1 hb)
state_before: case refine_2
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : a ∉ H ∧ ∀ x ∉ H, x⁻¹ * a ∈ H
b : G
hb : b ∉ H
⊢ b * a ∈ H
state_after: no goals

tactic: rw [← inv_mem_iff (x := a), ← ha, inv_mul_self]
state_before: case refine_3
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : ∀ (b : G), b * a ∈ H ↔ b ∉ H
⊢ a ∉ H
state_after: case refine_3
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : ∀ (b : G), b * a ∈ H ↔ b ∉ H
⊢ 1 ∈ H

tactic: exact one_mem _
state_before: case refine_3
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : ∀ (b : G), b * a ∈ H ↔ b ∉ H
⊢ 1 ∈ H
state_after: no goals

tactic: rwa [ha, inv_mem_iff (x := b)]
state_before: case refine_4
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
a : G
ha : ∀ (b : G), b * a ∈ H ↔ b ∉ H
b : G
hb : b ∉ H
⊢ b⁻¹ * a ∈ H
state_after: no goals
Theorem: Computation.not_mem_empty
File: Mathlib/Data/Seq/Computation.lean

tactic: contradiction
state_before: α : Type u
β : Type v
γ : Type w
a : α
x✝ : a ∈ empty α
n : ℕ
h : (fun b => some a = b) ((↑(empty α)).get n)
⊢ False
state_after: no goals