1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.TProd.ext
File: Mathlib/Data/Prod/TProd.lean

tactic: apply Prod.ext
state_before: ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
⊢ v = w
state_after: case a
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
⊢ v.1 = w.1

case a
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
⊢ v.2 = w.2

tactic: refine ext (nodup_cons.mp hl).2 fun j hj => ?_
state_before: case a
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
⊢ v.2 = w.2
state_after: case a
ι : Type u
α : ι → Type v
i✝ j✝ : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
j : ι
hj : j ∈ is
⊢ TProd.elim v.2 hj = TProd.elim w.2 hj

tactic: rw [← elim_of_mem hl, hvw, elim_of_mem hl]
state_before: case a
ι : Type u
α : ι → Type v
i✝ j✝ : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
j : ι
hj : j ∈ is
⊢ TProd.elim v.2 hj = TProd.elim w.2 hj
state_after: no goals

tactic: rw [← elim_self v, hvw, elim_self]
state_before: case a
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
⊢ v.1 = w.1
state_after: no goals
Theorem: Pell.yn_modEq_a_sub_one
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: simp [Nat.ModEq.refl]
state_before: a : ℕ
a1 : 1 < a
⊢ yn a1 0 ≡ 0 [MOD a - 1]
state_after: no goals

tactic: simp [Nat.ModEq.refl]
state_before: a : ℕ
a1 : 1 < a
⊢ yn a1 1 ≡ 1 [MOD a - 1]
state_after: no goals

tactic: rw [yn_succ_succ, (by ring : n + 2 + n = 2 * (n + 1))]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ yn a1 (n + 2) + yn a1 n ≡ n + 2 + n [MOD a - 1]
state_after: a : ℕ
a1 : 1 < a
n : ℕ
⊢ 2 * a * yn a1 (n + 1) ≡ 2 * (n + 1) [MOD a - 1]

tactic: exact ((modEq_sub a1.le).mul_left 2).mul (yn_modEq_a_sub_one (n + 1))
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ 2 * a * yn a1 (n + 1) ≡ 2 * (n + 1) [MOD a - 1]
state_after: no goals

tactic: ring
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ n + 2 + n = 2 * (n + 1)
state_after: no goals
Theorem: compl_sdiff_compl
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sdiff_compl, sdiff_eq, inf_comm]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : BooleanAlgebra α
⊢ xᶜ \ yᶜ = y \ x
state_after: no goals
Theorem: Stirling.stirlingSeq_one
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

tactic: rw [stirlingSeq, pow_one, factorial_one, cast_one, mul_one, mul_one_div, one_div_div]
state_before: ⊢ stirlingSeq 1 = rexp 1 / √2
state_after: no goals
Theorem: ProbabilityTheory.kernel.deterministic_comp_eq_map
File: Mathlib/Probability/Kernel/Composition.lean

tactic: ext a s hs
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
hf : Measurable f
κ : ↥(kernel α β)
⊢ deterministic f hf ∘ₖ κ = map κ f hf
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
hf : Measurable f
κ : ↥(kernel α β)
a : α
s : Set γ
hs : MeasurableSet s
⊢ ((deterministic f hf ∘ₖ κ) a) s = ((map κ f hf) a) s

tactic: simp_rw [map_apply' _ _ _ hs, comp_apply' _ _ _ hs, deterministic_apply' hf _ hs,
  lintegral_indicator_const_comp hf hs, one_mul]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
hf : Measurable f
κ : ↥(kernel α β)
a : α
s : Set γ
hs : MeasurableSet s
⊢ ((deterministic f hf ∘ₖ κ) a) s = ((map κ f hf) a) s
state_after: no goals
Theorem: Filter.disjoint_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [disjoint_iff, prod_inf_prod, prod_eq_bot]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
f' : Filter α
g' : Filter β
⊢ Disjoint (f ×ˢ g) (f' ×ˢ g') ↔ Disjoint f f' ∨ Disjoint g g'
state_after: no goals
Theorem: SetLike.pow_mem_graded
File: Mathlib/Algebra/GradedMonoid.lean

tactic: match n with
| 0 =>
  rw [pow_zero, zero_nsmul]
  exact one_mem_graded _
| n+1 =>
  rw [pow_succ', succ_nsmul']
  exact mul_mem_graded h (pow_mem_graded n h)
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
r : R
i : ι
h : r ∈ A i
⊢ r ^ n ∈ A (n • i)
state_after: no goals

tactic: rw [pow_zero, zero_nsmul]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
r : R
i : ι
h : r ∈ A i
⊢ r ^ 0 ∈ A (0 • i)
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
r : R
i : ι
h : r ∈ A i
⊢ 1 ∈ A 0

tactic: exact one_mem_graded _
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
r : R
i : ι
h : r ∈ A i
⊢ 1 ∈ A 0
state_after: no goals

tactic: rw [pow_succ', succ_nsmul']
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n✝ : ℕ
r : R
i : ι
h : r ∈ A i
n : ℕ
⊢ r ^ (n + 1) ∈ A ((n + 1) • i)
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n✝ : ℕ
r : R
i : ι
h : r ∈ A i
n : ℕ
⊢ r * r ^ n ∈ A (i + n • i)

tactic: exact mul_mem_graded h (pow_mem_graded n h)
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n✝ : ℕ
r : R
i : ι
h : r ∈ A i
n : ℕ
⊢ r * r ^ n ∈ A (i + n • i)
state_after: no goals
Theorem: Finset.powerset_card_disjiUnion
File: Mathlib/Data/Finset/Powerset.lean

tactic: refine ext fun a => ⟨fun ha => ?_, fun ha => ?_⟩
state_before: α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.29806
s✝ t s : Finset α
⊢ s.powerset = (range (s.card + 1)).disjiUnion (fun i => powersetCard i s) ⋯
state_after: case refine_1
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.29806
s✝ t s a : Finset α
ha : a ∈ s.powerset
⊢ a ∈ (range (s.card + 1)).disjiUnion (fun i => powersetCard i s) ⋯

case refine_2
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.29806
s✝ t s a : Finset α
ha : a ∈ (range (s.card + 1)).disjiUnion (fun i => powersetCard i s) ⋯
⊢ a ∈ s.powerset

tactic: rw [mem_disjiUnion]
state_before: case refine_1
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.29806
s✝ t s a : Finset α
ha : a ∈ s.powerset
⊢ a ∈ (range (s.card + 1)).disjiUnion (fun i => powersetCard i s) ⋯
state_after: case refine_1
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.29806
s✝ t s a : Finset α
ha : a ∈ s.powerset
⊢ ∃ a_1 ∈ range (s.card + 1), a ∈ powersetCard a_1 s

tactic: exact
  ⟨a.card, mem_range.mpr (Nat.lt_succ_of_le (card_le_card (mem_powerset.mp ha))),
    mem_powersetCard.mpr ⟨mem_powerset.mp ha, rfl⟩⟩
state_before: case refine_1
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.29806
s✝ t s a : Finset α
ha : a ∈ s.powerset
⊢ ∃ a_1 ∈ range (s.card + 1), a ∈ powersetCard a_1 s
state_after: no goals

tactic: rcases mem_disjiUnion.mp ha with ⟨i, _hi, ha⟩
state_before: case refine_2
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.29806
s✝ t s a : Finset α
ha : a ∈ (range (s.card + 1)).disjiUnion (fun i => powersetCard i s) ⋯
⊢ a ∈ s.powerset
state_after: case refine_2.intro.intro
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.29806
s✝ t s a : Finset α
ha✝ : a ∈ (range (s.card + 1)).disjiUnion (fun i => powersetCard i s) ⋯
i : ℕ
_hi : i ∈ range (s.card + 1)
ha : a ∈ powersetCard i s
⊢ a ∈ s.powerset

tactic: exact mem_powerset.mpr (mem_powersetCard.mp ha).1
state_before: case refine_2.intro.intro
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.29806
s✝ t s a : Finset α
ha✝ : a ∈ (range (s.card + 1)).disjiUnion (fun i => powersetCard i s) ⋯
i : ℕ
_hi : i ∈ range (s.card + 1)
ha : a ∈ powersetCard i s
⊢ a ∈ s.powerset
state_after: no goals
Theorem: Nat.factors_add_two
File: Mathlib/Data/Nat/Factors.lean

tactic: rw [factors]
state_before: n : ℕ
⊢ (n + 2).factors = (n + 2).minFac :: ((n + 2) / (n + 2).minFac).factors
state_after: no goals
Theorem: normalClosure_eq_iSup_adjoin'
File: Mathlib/FieldTheory/NormalClosure.lean

tactic: have ⟨φ⟩ := ne
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
⊢ normalClosure F K L = ⨆ x, adjoin F ((minpoly F x).rootSet L)
state_after: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
⊢ normalClosure F K L = ⨆ x, adjoin F ((minpoly F x).rootSet L)

tactic: refine h.toIsAlgebraic.of_injective φ φ.injective
  |>.normalClosure_eq_iSup_adjoin_of_splits fun x ↦ ?_
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
⊢ normalClosure F K L = ⨆ x, adjoin F ((minpoly F x).rootSet L)
state_after: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
x : K
⊢ Splits (algebraMap F L) (minpoly F x)

tactic: rw [← minpoly.algHom_eq _ φ.injective]
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
x : K
⊢ Splits (algebraMap F L) (minpoly F x)
state_after: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
x : K
⊢ Splits (algebraMap F L) (minpoly F (φ x))

tactic: apply h.splits
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁴ : Field F
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra F K
inst✝ : Algebra F L
ne : Nonempty (K →ₐ[F] L)
h : Normal F L
φ : K →ₐ[F] L
x : K
⊢ Splits (algebraMap F L) (minpoly F (φ x))
state_after: no goals
Theorem: hasFDerivAtFilter_pi'
File: Mathlib/Analysis/Calculus/FDeriv/Prod.lean

tactic: simp only [hasFDerivAtFilter_iff_isLittleO, ContinuousLinearMap.coe_pi]
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_6
inst✝² : Fintype ι
F' : ι → Type u_7
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
⊢ HasFDerivAtFilter Φ Φ' x L ↔ ∀ (i : ι), HasFDerivAtFilter (fun x => Φ x i) ((proj i).comp Φ') x L
state_after: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_6
inst✝² : Fintype ι
F' : ι → Type u_7
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
⊢ ((fun x' => Φ x' - Φ x - Φ' (x' - x)) =o[L] fun x' => x' - x) ↔
    ∀ (i : ι), (fun x' => Φ x' i - Φ x i - ((proj i).comp Φ') (x' - x)) =o[L] fun x' => x' - x

tactic: exact isLittleO_pi
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_6
inst✝² : Fintype ι
F' : ι → Type u_7
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
⊢ ((fun x' => Φ x' - Φ x - Φ' (x' - x)) =o[L] fun x' => x' - x) ↔
    ∀ (i : ι), (fun x' => Φ x' i - Φ x i - ((proj i).comp Φ') (x' - x)) =o[L] fun x' => x' - x
state_after: no goals
Theorem: CategoryTheory.shiftComm_hom_comp
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: rw [shiftComm', ← shiftComm_symm, Iso.symm_hom, Iso.inv_hom_id_assoc]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftComm X i j).hom ≫ (shiftFunctor C i).map ((shiftFunctor C j).map f) =
    (shiftFunctor C j).map ((shiftFunctor C i).map f) ≫ (shiftComm Y i j).hom
state_after: no goals
Theorem: Finpartition.IsEquipartition.card_part_eq_average_iff
File: Mathlib/Order/Partition/Equipartition.lean

tactic: have a := hP.card_parts_eq_average ht
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
⊢ t.card = s.card / P.parts.card ↔ t.card ≠ s.card / P.parts.card + 1
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
a : t.card = s.card / P.parts.card ∨ t.card = s.card / P.parts.card + 1
⊢ t.card = s.card / P.parts.card ↔ t.card ≠ s.card / P.parts.card + 1

tactic: have b : ¬(t.card = s.card / P.parts.card ∧ t.card = s.card / P.parts.card + 1) := by
  by_contra h; exact absurd (h.1 ▸ h.2) (lt_add_one _).ne
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
a : t.card = s.card / P.parts.card ∨ t.card = s.card / P.parts.card + 1
⊢ t.card = s.card / P.parts.card ↔ t.card ≠ s.card / P.parts.card + 1
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
a : t.card = s.card / P.parts.card ∨ t.card = s.card / P.parts.card + 1
b : ¬(t.card = s.card / P.parts.card ∧ t.card = s.card / P.parts.card + 1)
⊢ t.card = s.card / P.parts.card ↔ t.card ≠ s.card / P.parts.card + 1

tactic: tauto
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
a : t.card = s.card / P.parts.card ∨ t.card = s.card / P.parts.card + 1
b : ¬(t.card = s.card / P.parts.card ∧ t.card = s.card / P.parts.card + 1)
⊢ t.card = s.card / P.parts.card ↔ t.card ≠ s.card / P.parts.card + 1
state_after: no goals

tactic: by_contra h
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
a : t.card = s.card / P.parts.card ∨ t.card = s.card / P.parts.card + 1
⊢ ¬(t.card = s.card / P.parts.card ∧ t.card = s.card / P.parts.card + 1)
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
a : t.card = s.card / P.parts.card ∨ t.card = s.card / P.parts.card + 1
h : t.card = s.card / P.parts.card ∧ t.card = s.card / P.parts.card + 1
⊢ False

tactic: exact absurd (h.1 ▸ h.2) (lt_add_one _).ne
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
a : t.card = s.card / P.parts.card ∨ t.card = s.card / P.parts.card + 1
h : t.card = s.card / P.parts.card ∧ t.card = s.card / P.parts.card + 1
⊢ False
state_after: no goals
Theorem: List.filterMap_eq_bind_toList
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with a l ih <;> simp [filterMap_cons]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β
l : List α
⊢ filterMap f l = l.bind fun a => (f a).toList
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β
a : α
l : List α
ih : filterMap f l = l.bind fun a => (f a).toList
⊢ (match f a with
    | none => filterMap f l
    | some b => b :: filterMap f l) =
    (f a).toList ++ l.bind fun a => (f a).toList

tactic: rcases f a <;> simp [ih]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β
a : α
l : List α
ih : filterMap f l = l.bind fun a => (f a).toList
⊢ (match f a with
    | none => filterMap f l
    | some b => b :: filterMap f l) =
    (f a).toList ++ l.bind fun a => (f a).toList
state_after: no goals
Theorem: Nat.unpair_zero
File: Mathlib/Data/Nat/Pairing.lean

tactic: rw [unpair]
state_before: ⊢ unpair 0 = 0
state_after: ⊢ (let s := sqrt 0;
    if 0 - s * s < s then (0 - s * s, s) else (s, 0 - s * s - s)) =
    0

tactic: simp
state_before: ⊢ (let s := sqrt 0;
    if 0 - s * s < s then (0 - s * s, s) else (s, 0 - s * s - s)) =
    0
state_after: no goals
Theorem: TopologicalSpace.Closeds.mem_iInf
File: Mathlib/Topology/Sets/Closeds.lean

tactic: simp [iInf]
state_before: ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
x : α
s : ι → Closeds α
⊢ x ∈ iInf s ↔ ∀ (i : ι), x ∈ s i
state_after: no goals
Theorem: TensorAlgebra.ι_range_disjoint_one
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

tactic: rw [Submodule.disjoint_def]
state_before: R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ Disjoint (LinearMap.range (ι R)) 1
state_after: R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ ∀ x ∈ LinearMap.range (ι R), x ∈ 1 → x = 0

tactic: rintro _ ⟨x, hx⟩ ⟨r, rfl⟩
state_before: R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ ∀ x ∈ LinearMap.range (ι R), x ∈ 1 → x = 0
state_after: case intro.intro
R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : M
r : R
hx : (ι R) x = (Algebra.linearMap R (TensorAlgebra R M)) r
⊢ (Algebra.linearMap R (TensorAlgebra R M)) r = 0

tactic: rw [Algebra.linearMap_apply, ι_eq_algebraMap_iff] at hx
state_before: case intro.intro
R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : M
r : R
hx : (ι R) x = (Algebra.linearMap R (TensorAlgebra R M)) r
⊢ (Algebra.linearMap R (TensorAlgebra R M)) r = 0
state_after: case intro.intro
R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : M
r : R
hx : x = 0 ∧ r = 0
⊢ (Algebra.linearMap R (TensorAlgebra R M)) r = 0

tactic: rw [hx.2, map_zero]
state_before: case intro.intro
R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : M
r : R
hx : x = 0 ∧ r = 0
⊢ (Algebra.linearMap R (TensorAlgebra R M)) r = 0
state_after: no goals
Theorem: padicValNat_mul_pow_right
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [mul_comm (p^n) (q^m)]
state_before: p q : ℕ
hp : Fact (Nat.Prime p)
hq : Fact (Nat.Prime q)
n m : ℕ
neq : q ≠ p
⊢ padicValNat q (p ^ n * q ^ m) = m
state_after: p q : ℕ
hp : Fact (Nat.Prime p)
hq : Fact (Nat.Prime q)
n m : ℕ
neq : q ≠ p
⊢ padicValNat q (q ^ m * p ^ n) = m

tactic: exact padicValNat_mul_pow_left m n neq
state_before: p q : ℕ
hp : Fact (Nat.Prime p)
hq : Fact (Nat.Prime q)
n m : ℕ
neq : q ≠ p
⊢ padicValNat q (q ^ m * p ^ n) = m
state_after: no goals
Theorem: AddCommGroup.add_nsmul_modEq
File: Mathlib/Algebra/ModEq.lean

tactic: simp
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n✝ : ℕ
z : ℤ
n : ℕ
⊢ a - (a + n • p) = -↑n • p
state_after: no goals
Theorem: ContDiffOn.continuousOn_fderivWithin_apply
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: rwa [zero_add]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hf : ContDiffOn 𝕜 n f s
hs : UniqueDiffOn 𝕜 s
hn : 1 ≤ n
⊢ ?m.999079 + 1 ≤ n
state_after: no goals
Theorem: Primrec.of_equiv_iff
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β✝ : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β✝
inst✝ : Primcodable σ
β : Type u_4
e : β ≃ α
f : σ → β
this : Primcodable β := Primcodable.ofEquiv α e
h : Primrec fun a => e (f a)
a : σ
⊢ e.symm (e (f a)) = f a
state_after: no goals