tasksource/leandojo huggingface dataset:
Theorem: Polynomial.degree_eq_one_of_irreducible_of_splits
File: Mathlib/Data/Polynomial/Splits.lean

tactic: rcases hp_splits with ⟨⟩ | hp_splits
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hp : Irreducible p
hp_splits : Splits (RingHom.id K) p
⊢ degree p = 1

tactic: exfalso
state_before: case inl
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hp : Irreducible p
h✝ : map (RingHom.id K) p = 0
⊢ degree p = 1

tactic: simp_all
state_before: case inl.h
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hp : Irreducible p
h✝ : map (RingHom.id K) p = 0
⊢ False

tactic: apply hp_splits hp
state_before: case inr
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hp : Irreducible p
hp_splits : ∀ {g : K[X]}, Irreducible g → g ∣ map (RingHom.id K) p → degree g = 1
⊢ degree p = 1

tactic: simp
state_before: case inr
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hp : Irreducible p
hp_splits : ∀ {g : K[X]}, Irreducible g → g ∣ map (RingHom.id K) p → degree g = 1
⊢ p ∣ map (RingHom.id K) p
Theorem: List.append_ne_nil_of_ne_nil_right
File: Std/Data/List/Lemmas.lean

tactic: simp_all
state_before: α : Type u_1
s t : List α
⊢ t ≠ [] → s ++ t ≠ []
Theorem: LinearMap.det_eq_det_toMatrix_of_finset
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: have : ∃ s : Finset M, Nonempty (Basis s A M) := ⟨s, ⟨b⟩⟩
state_before: R : Type ?u.374035
inst✝¹⁰ : CommRing R
M : Type u_1
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type ?u.374626
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type ?u.375168
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type ?u.376144
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
s : Finset M
b : Basis { x // x ∈ s } A M
f : M →ₗ[A] M
⊢ ↑LinearMap.det f = det (↑(toMatrix b b) f)

tactic: rw [LinearMap.coe_det, dif_pos, detAux_def'' _ b] <;> assumption
state_before: R : Type ?u.374035
inst✝¹⁰ : CommRing R
M : Type u_1
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type ?u.374626
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type ?u.375168
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type ?u.376144
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
s : Finset M
b : Basis { x // x ∈ s } A M
f : M →ₗ[A] M
this : ∃ s, Nonempty (Basis { x // x ∈ s } A M)
⊢ ↑LinearMap.det f = det (↑(toMatrix b b) f)
Theorem: MvPolynomial.support_finSuccEquiv_nonempty
File: Mathlib/Data/MvPolynomial/Equiv.lean

tactic: simp only [Finset.nonempty_iff_ne_empty, Ne, Polynomial.support_eq_empty]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1276068
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
⊢ Finset.Nonempty (Polynomial.support (↑(finSuccEquiv R n) f))

tactic: refine fun c => h ?_
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1276068
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
⊢ ¬↑(finSuccEquiv R n) f = 0

tactic: let ii := (finSuccEquiv R n).symm
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1276068
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
c : ↑(finSuccEquiv R n) f = 0
⊢ f = 0

tactic: calc
  f = ii (finSuccEquiv R n f) := by
    simpa only [← AlgEquiv.invFun_eq_symm] using ((finSuccEquiv R n).left_inv f).symm
  _ = ii 0 := by rw [c]
  _ = 0 := by simp
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1276068
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
c : ↑(finSuccEquiv R n) f = 0
ii : (MvPolynomial (Fin n) R)[X] ≃ₐ[R] MvPolynomial (Fin (n + 1)) R := AlgEquiv.symm (finSuccEquiv R n)
⊢ f = 0

tactic: simpa only [← AlgEquiv.invFun_eq_symm] using ((finSuccEquiv R n).left_inv f).symm
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1276068
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
c : ↑(finSuccEquiv R n) f = 0
ii : (MvPolynomial (Fin n) R)[X] ≃ₐ[R] MvPolynomial (Fin (n + 1)) R := AlgEquiv.symm (finSuccEquiv R n)
⊢ f = ↑ii (↑(finSuccEquiv R n) f)

tactic: rw [c]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1276068
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
c : ↑(finSuccEquiv R n) f = 0
ii : (MvPolynomial (Fin n) R)[X] ≃ₐ[R] MvPolynomial (Fin (n + 1)) R := AlgEquiv.symm (finSuccEquiv R n)
⊢ ↑ii (↑(finSuccEquiv R n) f) = ↑ii 0

tactic: simp
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1276068
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
c : ↑(finSuccEquiv R n) f = 0
ii : (MvPolynomial (Fin n) R)[X] ≃ₐ[R] MvPolynomial (Fin (n + 1)) R := AlgEquiv.symm (finSuccEquiv R n)
⊢ ↑ii 0 = 0
Theorem: Finset.Icc_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_eq_singleton, coe_Icc, Set.Icc_self]
state_before: ι : Type ?u.71479
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b c a : α
⊢ Icc a a = {a}
Theorem: LinearMap.isSymm_iff_eq_flip
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: constructor <;> intro h
state_before: R : Type u_1
R₁ : Type ?u.168800
R₂ : Type ?u.168803
R₃ : Type ?u.168806
M : Type u_2
M₁ : Type ?u.168812
M₂ : Type ?u.168815
Mₗ₁ : Type ?u.168818
Mₗ₁' : Type ?u.168821
Mₗ₂ : Type ?u.168824
Mₗ₂' : Type ?u.168827
K : Type ?u.168830
K₁ : Type ?u.168833
K₂ : Type ?u.168836
V : Type ?u.168839
V₁ : Type ?u.168842
V₂ : Type ?u.168845
n : Type ?u.168848
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I : R →+* R
B✝ : M →ₛₗ[I] M →ₗ[R] R
B : M →ₗ[R] M →ₗ[R] R
⊢ IsSymm B ↔ B = flip B

tactic: intro x y
state_before: case mpr
R : Type u_1
R₁ : Type ?u.168800
R₂ : Type ?u.168803
R₃ : Type ?u.168806
M : Type u_2
M₁ : Type ?u.168812
M₂ : Type ?u.168815
Mₗ₁ : Type ?u.168818
Mₗ₁' : Type ?u.168821
Mₗ₂ : Type ?u.168824
Mₗ₂' : Type ?u.168827
K : Type ?u.168830
K₁ : Type ?u.168833
K₂ : Type ?u.168836
V : Type ?u.168839
V₁ : Type ?u.168842
V₂ : Type ?u.168845
n : Type ?u.168848
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I : R →+* R
B✝ : M →ₛₗ[I] M →ₗ[R] R
B : M →ₗ[R] M →ₗ[R] R
h : B = flip B
⊢ IsSymm B

tactic: conv_lhs => rw [h]
state_before: case mpr
R : Type u_1
R₁ : Type ?u.168800
R₂ : Type ?u.168803
R₃ : Type ?u.168806
M : Type u_2
M₁ : Type ?u.168812
M₂ : Type ?u.168815
Mₗ₁ : Type ?u.168818
Mₗ₁' : Type ?u.168821
Mₗ₂ : Type ?u.168824
Mₗ₂' : Type ?u.168827
K : Type ?u.168830
K₁ : Type ?u.168833
K₂ : Type ?u.168836
V : Type ?u.168839
V₁ : Type ?u.168842
V₂ : Type ?u.168845
n : Type ?u.168848
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I : R →+* R
B✝ : M →ₛₗ[I] M →ₗ[R] R
B : M →ₗ[R] M →ₗ[R] R
h : B = flip B
x y : M
⊢ ↑(RingHom.id R) (↑(↑B x) y) = ↑(↑B y) x

tactic: ext
state_before: case mp
R : Type u_1
R₁ : Type ?u.168800
R₂ : Type ?u.168803
R₃ : Type ?u.168806
M : Type u_2
M₁ : Type ?u.168812
M₂ : Type ?u.168815
Mₗ₁ : Type ?u.168818
Mₗ₁' : Type ?u.168821
Mₗ₂ : Type ?u.168824
Mₗ₂' : Type ?u.168827
K : Type ?u.168830
K₁ : Type ?u.168833
K₂ : Type ?u.168836
V : Type ?u.168839
V₁ : Type ?u.168842
V₂ : Type ?u.168845
n : Type ?u.168848
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I : R →+* R
B✝ : M →ₛₗ[I] M →ₗ[R] R
B : M →ₗ[R] M →ₗ[R] R
h : IsSymm B
⊢ B = flip B

tactic: rw [← h, flip_apply, RingHom.id_apply]
state_before: case mp.h.h
R : Type u_1
R₁ : Type ?u.168800
R₂ : Type ?u.168803
R₃ : Type ?u.168806
M : Type u_2
M₁ : Type ?u.168812
M₂ : Type ?u.168815
Mₗ₁ : Type ?u.168818
Mₗ₁' : Type ?u.168821
Mₗ₂ : Type ?u.168824
Mₗ₂' : Type ?u.168827
K : Type ?u.168830
K₁ : Type ?u.168833
K₂ : Type ?u.168836
V : Type ?u.168839
V₁ : Type ?u.168842
V₂ : Type ?u.168845
n : Type ?u.168848
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I : R →+* R
B✝ : M →ₛₗ[I] M →ₗ[R] R
B : M →ₗ[R] M →ₗ[R] R
h : IsSymm B
x✝¹ x✝ : M
⊢ ↑(↑B x✝¹) x✝ = ↑(↑(flip B) x✝¹) x✝
Theorem: AffineBasis.affineCombination_coord_eq_self
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: have hq : q ∈ affineSpan k (range b) := by
  rw [b.tot]
  exact AffineSubspace.mem_top k V q
state_before: ι : Type u_1
ι' : Type ?u.118805
k : Type u_4
V : Type u_3
P : Type u_2
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
q : P
⊢ (↑(Finset.affineCombination k Finset.univ ↑b) fun i => ↑(coord b i) q) = q

tactic: obtain ⟨w, hw, rfl⟩ := eq_affineCombination_of_mem_affineSpan_of_fintype hq
state_before: ι : Type u_1
ι' : Type ?u.118805
k : Type u_4
V : Type u_3
P : Type u_2
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
q : P
hq : q ∈ affineSpan k (range ↑b)
⊢ (↑(Finset.affineCombination k Finset.univ ↑b) fun i => ↑(coord b i) q) = q

tactic: congr
state_before: case intro.intro
ι : Type u_1
ι' : Type ?u.118805
k : Type u_4
V : Type u_3
P : Type u_2
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
w : ι → k
hw : ∑ i : ι, w i = 1
hq : ↑(Finset.affineCombination k Finset.univ ↑b) w ∈ affineSpan k (range ↑b)
⊢ (↑(Finset.affineCombination k Finset.univ ↑b) fun i =>
      ↑(coord b i) (↑(Finset.affineCombination k Finset.univ ↑b) w)) =
    ↑(Finset.affineCombination k Finset.univ ↑b) w

tactic: ext i
state_before: case intro.intro.h.e_6.h
ι : Type u_1
ι' : Type ?u.118805
k : Type u_4
V : Type u_3
P : Type u_2
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
w : ι → k
hw : ∑ i : ι, w i = 1
hq : ↑(Finset.affineCombination k Finset.univ ↑b) w ∈ affineSpan k (range ↑b)
⊢ (fun i => ↑(coord b i) (↑(Finset.affineCombination k Finset.univ ↑b) w)) = w

tactic: exact b.coord_apply_combination_of_mem (Finset.mem_univ i) hw
state_before: case intro.intro.h.e_6.h.h
ι : Type u_1
ι' : Type ?u.118805
k : Type u_4
V : Type u_3
P : Type u_2
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i✝ j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
w : ι → k
hw : ∑ i : ι, w i = 1
hq : ↑(Finset.affineCombination k Finset.univ ↑b) w ∈ affineSpan k (range ↑b)
i : ι
⊢ ↑(coord b i) (↑(Finset.affineCombination k Finset.univ ↑b) w) = w i

tactic: rw [b.tot]
state_before: ι : Type u_1
ι' : Type ?u.118805
k : Type u_4
V : Type u_3
P : Type u_2
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
q : P
⊢ q ∈ affineSpan k (range ↑b)

tactic: exact AffineSubspace.mem_top k V q
state_before: ι : Type u_1
ι' : Type ?u.118805
k : Type u_4
V : Type u_3
P : Type u_2
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
q : P
⊢ q ∈ ⊤
Theorem: int_smul_eq_zsmul
File: Mathlib/Algebra/Module/Basic.lean

tactic: rw [zsmul_eq_smul_cast ℤ n x, Int.cast_id]
state_before: α : Type ?u.158540
R : Type ?u.158543
k : Type ?u.158546
S : Type ?u.158549
M : Type u_1
M₂ : Type ?u.158555
M₃ : Type ?u.158558
ι : Type ?u.158561
inst✝⁴ : Semiring S
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module S M
inst✝ : Module R M
h : Module ℤ M
n : ℤ
x : M
⊢ SMul.smul n x = n • x

tactic: rfl
state_before: α : Type ?u.158540
R : Type ?u.158543
k : Type ?u.158546
S : Type ?u.158549
M : Type u_1
M₂ : Type ?u.158555
M₃ : Type ?u.158558
ι : Type ?u.158561
inst✝⁴ : Semiring S
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module S M
inst✝ : Module R M
h : Module ℤ M
n : ℤ
x : M
⊢ SMul.smul n x = n • x
Theorem: Rat.neg_mkRat
File: Std/Data/Rat/Lemmas.lean

tactic: if z : d = 0 then simp [z] else simp [← normalize_eq_mkRat z, neg_normalize]
state_before: n : Int
d : Nat
⊢ -mkRat n d = mkRat (-n) d

tactic: simp [z]
state_before: n : Int
d : Nat
z : d = 0
⊢ -mkRat n d = mkRat (-n) d

tactic: simp [← normalize_eq_mkRat z, neg_normalize]
state_before: n : Int
d : Nat
z : ¬d = 0
⊢ -mkRat n d = mkRat (-n) d
Theorem: Set.mulIndicator_comp_right
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: simp only [mulIndicator, Function.comp]
state_before: α : Type u_1
β : Type u_3
ι : Type ?u.20670
M : Type u_2
N : Type ?u.20676
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f : β → α
g : α → M
x : β
⊢ mulIndicator (f ⁻¹' s) (g ∘ f) x = mulIndicator s g (f x)

tactic: split_ifs with h h' h'' <;> first | rfl | contradiction
state_before: α : Type u_1
β : Type u_3
ι : Type ?u.20670
M : Type u_2
N : Type ?u.20676
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f : β → α
g : α → M
x : β
⊢ (if x ∈ f ⁻¹' s then g (f x) else 1) = if f x ∈ s then g (f x) else 1

tactic: rfl
state_before: case inr.inr
α : Type u_1
β : Type u_3
ι : Type ?u.20670
M : Type u_2
N : Type ?u.20676
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f : β → α
g : α → M
x : β
h : ¬x ∈ f ⁻¹' s
h'' : ¬f x ∈ s
⊢ 1 = 1

tactic: contradiction
state_before: case inr.inl
α : Type u_1
β : Type u_3
ι : Type ?u.20670
M : Type u_2
N : Type ?u.20676
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f : β → α
g : α → M
x : β
h : ¬x ∈ f ⁻¹' s
h'' : f x ∈ s
⊢ 1 = g (f x)
Theorem: LipschitzWith.ediam_image_le
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: apply EMetric.diam_le
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ≥0∞
hf : LipschitzWith K f
s : Set α
⊢ diam (f '' s) ≤ ↑K * diam s

tactic: rintro _ ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ≥0∞
hf : LipschitzWith K f
s : Set α
⊢ ∀ (x : β), x ∈ f '' s → ∀ (y : β), y ∈ f '' s → edist x y ≤ ↑K * diam s

tactic: exact hf.edist_le_mul_of_le (EMetric.edist_le_diam_of_mem hx hy)
state_before: case h.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x✝ y✝ : α
r : ℝ≥0∞
hf : LipschitzWith K f
s : Set α
x : α
hx : x ∈ s
y : α
hy : y ∈ s
⊢ edist (f x) (f y) ≤ ↑K * diam s
Theorem: MeasureTheory.measure_biUnion₀
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: haveI := hs.toEncodable
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.8654
δ : Type ?u.8657
ι : Type ?u.8660
R : Type ?u.8663
R' : Type ?u.8666
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : Set.Countable s
hd : Set.Pairwise s (AEDisjoint μ on f)
h : ∀ (b : β), b ∈ s → NullMeasurableSet (f b)
⊢ ↑↑μ (⋃ (b : β) (_ : b ∈ s), f b) = ∑' (p : ↑s), ↑↑μ (f ↑p)

tactic: rw [biUnion_eq_iUnion]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.8654
δ : Type ?u.8657
ι : Type ?u.8660
R : Type ?u.8663
R' : Type ?u.8666
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : Set.Countable s
hd : Set.Pairwise s (AEDisjoint μ on f)
h : ∀ (b : β), b ∈ s → NullMeasurableSet (f b)
this : Encodable ↑s
⊢ ↑↑μ (⋃ (b : β) (_ : b ∈ s), f b) = ∑' (p : ↑s), ↑↑μ (f ↑p)

tactic: exact measure_iUnion₀ (hd.on_injective Subtype.coe_injective fun x => x.2) fun x => h x x.2
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.8654
δ : Type ?u.8657
ι : Type ?u.8660
R : Type ?u.8663
R' : Type ?u.8666
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : Set.Countable s
hd : Set.Pairwise s (AEDisjoint μ on f)
h : ∀ (b : β), b ∈ s → NullMeasurableSet (f b)
this : Encodable ↑s
⊢ ↑↑μ (⋃ (x : ↑s), f ↑x) = ∑' (p : ↑s), ↑↑μ (f ↑p)
Theorem: AbsoluteValue.sub_le
File: Mathlib/Algebra/Order/AbsoluteValue.lean

tactic: simpa [sub_eq_add_neg, add_assoc] using abv.add_le (a - b) (b - c)
state_before: R : Type u_2
S : Type u_1
inst✝¹ : Ring R
inst✝ : OrderedSemiring S
abv : AbsoluteValue R S
a b c : R
⊢ ↑abv (a - c) ≤ ↑abv (a - b) + ↑abv (b - c)
Theorem: MeasureTheory.lintegral_dirac'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp [lintegral_congr_ae (ae_eq_dirac' hf)]
state_before: α : Type u_1
β : Type ?u.1688682
γ : Type ?u.1688685
δ : Type ?u.1688688
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSpace α
a : α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (∫⁻ (a : α), f a ∂dirac a) = f a
Theorem: nhds_eq_order
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [t.topology_eq_generate_intervals, nhds_generateFrom]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
t : OrderTopology α
a : α
⊢ 𝓝 a = (⨅ (b : α) (_ : b ∈ Iio a), 𝓟 (Ioi b)) ⊓ ⨅ (b : α) (_ : b ∈ Ioi a), 𝓟 (Iio b)

tactic: simp_rw [mem_setOf_eq, @and_comm (a ∈ _), exists_or, or_and_right, iInf_or, iInf_and, iInf_exists,
  iInf_inf_eq, iInf_comm (ι := Set α), iInf_iInf_eq_left, mem_Ioi, mem_Iio]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
t : OrderTopology α
a : α
⊢ (⨅ (s : Set α) (_ : s ∈ {s | a ∈ s ∧ s ∈ {s | ∃ a, s = Ioi a ∨ s = Iio a}}), 𝓟 s) =
    (⨅ (b : α) (_ : b ∈ Iio a), 𝓟 (Ioi b)) ⊓ ⨅ (b : α) (_ : b ∈ Ioi a), 𝓟 (Iio b)
Theorem: Set.surjective_iff_surjOn_univ
File: Mathlib/Data/Set/Function.lean

tactic: simp [Surjective, SurjOn, subset_def]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.44646
ι : Sort ?u.44649
π : α → Type ?u.44654
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ Surjective f ↔ SurjOn f univ univ
Theorem: List.ofFn_succ'
File: Mathlib/Data/List/OfFn.lean

tactic: induction' n with n IH
state_before: α : Type u
n : ℕ
f : Fin (succ n) → α
⊢ ofFn f = concat (ofFn fun i => f (↑Fin.castSucc i)) (f (Fin.last n))

tactic: rw [ofFn_zero, concat_nil, ofFn_succ, ofFn_zero]
state_before: case zero
α : Type u
n : ℕ
f✝ : Fin (succ n) → α
f : Fin (succ zero) → α
⊢ ofFn f = concat (ofFn fun i => f (↑Fin.castSucc i)) (f (Fin.last zero))

tactic: rfl
state_before: case zero
α : Type u
n : ℕ
f✝ : Fin (succ n) → α
f : Fin (succ zero) → α
⊢ [f 0] = [f (Fin.last zero)]

tactic: rw [ofFn_succ, IH, ofFn_succ, concat_cons, Fin.castSucc_zero]
state_before: case succ
α : Type u
n✝ : ℕ
f✝ : Fin (succ n✝) → α
n : ℕ
IH : ∀ (f : Fin (succ n) → α), ofFn f = concat (ofFn fun i => f (↑Fin.castSucc i)) (f (Fin.last n))
f : Fin (succ (succ n)) → α
⊢ ofFn f = concat (ofFn fun i => f (↑Fin.castSucc i)) (f (Fin.last (succ n)))

tactic: congr
state_before: case succ
α : Type u
n✝ : ℕ
f✝ : Fin (succ n✝) → α
n : ℕ
IH : ∀ (f : Fin (succ n) → α), ofFn f = concat (ofFn fun i => f (↑Fin.castSucc i)) (f (Fin.last n))
f : Fin (succ (succ n)) → α
⊢ f 0 :: concat (ofFn fun i => f (Fin.succ (↑Fin.castSucc i))) (f (Fin.succ (Fin.last n))) =
    f 0 :: concat (ofFn fun i => f (↑Fin.castSucc (Fin.succ i))) (f (Fin.last (succ n)))
Theorem: Nat.div2_succ
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: simp only [bodd, boddDiv2, div2]
state_before: n : ℕ
⊢ div2 (succ n) = bif bodd n then succ (div2 n) else div2 n

tactic: cases' boddDiv2 n with fst snd
state_before: n : ℕ
⊢ (match boddDiv2 n with
      | (false, m) => (true, m)
      | (true, m) => (false, succ m)).snd =
    bif (boddDiv2 n).fst then succ (boddDiv2 n).snd else (boddDiv2 n).snd

tactic: cases fst
state_before: case mk
n : ℕ
fst : Bool
snd : ℕ
⊢ (match (fst, snd) with
      | (false, m) => (true, m)
      | (true, m) => (false, succ m)).snd =
    bif (fst, snd).fst then succ (fst, snd).snd else (fst, snd).snd

tactic: case mk.false =>
  simp
state_before: case mk.false
n snd : ℕ
⊢ (match (false, snd) with
      | (false, m) => (true, m)
      | (true, m) => (false, succ m)).snd =
    bif (false, snd).fst then succ (false, snd).snd else (false, snd).snd

case mk.true
n snd : ℕ
⊢ (match (true, snd) with
      | (false, m) => (true, m)
      | (true, m) => (false, succ m)).snd =
    bif (true, snd).fst then succ (true, snd).snd else (true, snd).snd

tactic: case mk.true =>
  simp
state_before: case mk.true
n snd : ℕ
⊢ (match (true, snd) with
      | (false, m) => (true, m)
      | (true, m) => (false, succ m)).snd =
    bif (true, snd).fst then succ (true, snd).snd else (true, snd).snd

tactic: simp
state_before: n snd : ℕ
⊢ (match (false, snd) with
      | (false, m) => (true, m)
      | (true, m) => (false, succ m)).snd =
    bif (false, snd).fst then succ (false, snd).snd else (false, snd).snd

tactic: simp
state_before: n snd : ℕ
⊢ (match (true, snd) with
      | (false, m) => (true, m)
      | (true, m) => (false, succ m)).snd =
    bif (true, snd).fst then succ (true, snd).snd else (true, snd).snd
Theorem: Matrix.dotProductᵣ_eq
File: Mathlib/Data/Matrix/Reflection.lean

tactic: simp_rw [dotProductᵣ, dotProduct, FinVec.sum_eq, FinVec.seq_eq, FinVec.map_eq,
    Function.comp_apply]
state_before: l m✝ n : ℕ
α : Type u_1
β : Type ?u.26440
inst✝¹ : Mul α
inst✝ : AddCommMonoid α
m : ℕ
a b : Fin m → α
⊢ dotProductᵣ a b = a ⬝ᵥ b
Theorem: Int.shiftr_coe_nat
File: Mathlib/Data/Int/Bitwise.lean

tactic: cases n <;> rfl
state_before: m n : ℕ
⊢ shiftr ↑m ↑n = ↑(Nat.shiftr m n)
Theorem: Nat.lxor'_self
File: Mathlib/Data/Nat/Bitwise.lean

tactic: simp
state_before: n i : ℕ
⊢ testBit (lxor' n n) i = false
Theorem: Finset.image₂_insert_right
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_3
α' : Type ?u.38450
β : Type u_1
β' : Type ?u.38456
γ : Type u_2
γ' : Type ?u.38462
δ : Type ?u.38465
δ' : Type ?u.38468
ε : Type ?u.38471
ε' : Type ?u.38474
ζ : Type ?u.38477
ζ' : Type ?u.38480
ν : Type ?u.38483
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 (insert b t)) = ↑(image (fun a => f a b) s ∪ image₂ f s t)

tactic: exact image2_insert_right
state_before: α : Type u_3
α' : Type ?u.38450
β : Type u_1
β' : Type ?u.38456
γ : Type u_2
γ' : Type ?u.38462
δ : Type ?u.38465
δ' : Type ?u.38468
ε : Type ?u.38471
ε' : Type ?u.38474
ζ : Type ?u.38477
ζ' : Type ?u.38480
ν : Type ?u.38483
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) (insert b ↑t) = (fun a => f a b) '' ↑s ∪ image2 f ↑s ↑t