1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContextFreeRule.Rewrites.append_left
File: Mathlib/Computability/ContextFreeGrammar.lean

tactic: rw [rewrites_iff] at *
state_before: T : Type uT
N : Type uN
r : ContextFreeRule T N
v w : List (Symbol T N)
hvw : r.Rewrites v w
p : List (Symbol T N)
⊢ r.Rewrites (p ++ v) (p ++ w)
state_after: T : Type uT
N : Type uN
r : ContextFreeRule T N
v w : List (Symbol T N)
hvw : ∃ p q, v = p ++ [Symbol.nonterminal r.input] ++ q ∧ w = p ++ r.output ++ q
p : List (Symbol T N)
⊢ ∃ p_1 q, p ++ v = p_1 ++ [Symbol.nonterminal r.input] ++ q ∧ p ++ w = p_1 ++ r.output ++ q

tactic: rcases hvw with ⟨x, y, hxy⟩
state_before: T : Type uT
N : Type uN
r : ContextFreeRule T N
v w : List (Symbol T N)
hvw : ∃ p q, v = p ++ [Symbol.nonterminal r.input] ++ q ∧ w = p ++ r.output ++ q
p : List (Symbol T N)
⊢ ∃ p_1 q, p ++ v = p_1 ++ [Symbol.nonterminal r.input] ++ q ∧ p ++ w = p_1 ++ r.output ++ q
state_after: case intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
v w p x y : List (Symbol T N)
hxy : v = x ++ [Symbol.nonterminal r.input] ++ y ∧ w = x ++ r.output ++ y
⊢ ∃ p_1 q, p ++ v = p_1 ++ [Symbol.nonterminal r.input] ++ q ∧ p ++ w = p_1 ++ r.output ++ q

tactic: use p ++ x, y
state_before: case intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
v w p x y : List (Symbol T N)
hxy : v = x ++ [Symbol.nonterminal r.input] ++ y ∧ w = x ++ r.output ++ y
⊢ ∃ p_1 q, p ++ v = p_1 ++ [Symbol.nonterminal r.input] ++ q ∧ p ++ w = p_1 ++ r.output ++ q
state_after: case h
T : Type uT
N : Type uN
r : ContextFreeRule T N
v w p x y : List (Symbol T N)
hxy : v = x ++ [Symbol.nonterminal r.input] ++ y ∧ w = x ++ r.output ++ y
⊢ p ++ v = p ++ x ++ [Symbol.nonterminal r.input] ++ y ∧ p ++ w = p ++ x ++ r.output ++ y

tactic: simp_all
state_before: case h
T : Type uT
N : Type uN
r : ContextFreeRule T N
v w p x y : List (Symbol T N)
hxy : v = x ++ [Symbol.nonterminal r.input] ++ y ∧ w = x ++ r.output ++ y
⊢ p ++ v = p ++ x ++ [Symbol.nonterminal r.input] ++ y ∧ p ++ w = p ++ x ++ r.output ++ y
state_after: no goals
Theorem: BddBelow.image2
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
⊢ BddBelow s → BddBelow t → BddBelow (image2 f s t)
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddBelow (image2 f s t)

tactic: exact ⟨f a b, mem_lowerBounds_image2 h₀ h₁ ha hb⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddBelow (image2 f s t)
state_after: no goals
Theorem: CategoryTheory.Limits.spanExt_app_right
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [spanExt]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).app WalkingSpan.right = iZ
state_after: no goals
Theorem: SimpleGraph.not_isUniform_iff
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: unfold IsUniform
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ ¬G.IsUniform ε s t ↔
    ∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity s t|
state_after: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ (¬∀ ⦃s' : Finset α⦄,
        s' ⊆ s →
          ∀ ⦃t' : Finset α⦄,
            t' ⊆ t →
              ↑s.card * ε ≤ ↑s'.card → ↑t.card * ε ≤ ↑t'.card → |↑(G.edgeDensity s' t') - ↑(G.edgeDensity s t)| < ε) ↔
    ∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity s t|

tactic: simp only [not_forall, not_lt, exists_prop, exists_and_left, Rat.cast_abs, Rat.cast_sub]
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ (¬∀ ⦃s' : Finset α⦄,
        s' ⊆ s →
          ∀ ⦃t' : Finset α⦄,
            t' ⊆ t →
              ↑s.card * ε ≤ ↑s'.card → ↑t.card * ε ≤ ↑t'.card → |↑(G.edgeDensity s' t') - ↑(G.edgeDensity s t)| < ε) ↔
    ∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity s t|
state_after: no goals
Theorem: CategoryTheory.GradedObject.hom_ext
File: Mathlib/CategoryTheory/GradedObject.lean

tactic: funext
state_before: C : Type u
inst✝ : Category.{v, u} C
β : Type u_1
X Y : GradedObject β C
f g : X ⟶ Y
h : ∀ (x : β), f x = g x
⊢ f = g
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
β : Type u_1
X Y : GradedObject β C
f g : X ⟶ Y
h : ∀ (x : β), f x = g x
x✝ : β
⊢ f x✝ = g x✝

tactic: apply h
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
β : Type u_1
X Y : GradedObject β C
f g : X ⟶ Y
h : ∀ (x : β), f x = g x
x✝ : β
⊢ f x✝ = g x✝
state_after: no goals
Theorem: MvPolynomial.coeff_homogeneousComponent
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: simp_rw [← weightedDegree_one]
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ coeff d ((homogeneousComponent n) φ) = if degree d = n then coeff d φ else 0
state_after: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ coeff d ((homogeneousComponent n) φ) = if (weightedDegree 1) d = n then coeff d φ else 0

tactic: convert coeff_weightedHomogeneousComponent n φ d
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ coeff d ((homogeneousComponent n) φ) = if (weightedDegree 1) d = n then coeff d φ else 0
state_after: no goals
Theorem: OrderIso.preimage_Ici
File: Mathlib/Order/Interval/Set/OrderIso.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
b : β
⊢ ⇑e ⁻¹' Ici b = Ici (e.symm b)
state_after: case h
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
b : β
x : α
⊢ x ∈ ⇑e ⁻¹' Ici b ↔ x ∈ Ici (e.symm b)

tactic: simp [← e.le_iff_le]
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
b : β
x : α
⊢ x ∈ ⇑e ⁻¹' Ici b ↔ x ∈ Ici (e.symm b)
state_after: no goals
Theorem: List.countP_bind'
File: Mathlib/Data/List/Join.lean

tactic: rw [List.bind, countP_join', map_map]
state_before: α : Type u_1
β : Type u_2
p : β → Bool
l : List α
f : α → List β
⊢ countP p (l.bind f) = Nat.sum (map (countP p ∘ f) l)
state_after: no goals
Theorem: UniqueFactorizationMonoid.prime_of_factor
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: have ane0 := ne_zero_of_mem_factors hx
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a x : α
hx : x ∈ factors a
⊢ Prime x
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a x : α
hx : x ∈ factors a
ane0 : a ≠ 0
⊢ Prime x

tactic: rw [factors, dif_neg ane0] at hx
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a x : α
hx : x ∈ factors a
ane0 : a ≠ 0
⊢ Prime x
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a x : α
ane0 : a ≠ 0
hx : x ∈ Classical.choose ⋯
⊢ Prime x

tactic: exact (Classical.choose_spec (UniqueFactorizationMonoid.exists_prime_factors a ane0)).1 x hx
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a x : α
ane0 : a ≠ 0
hx : x ∈ Classical.choose ⋯
⊢ Prime x
state_after: no goals
Theorem: smul_le_of_le_one_left
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: simpa only [one_smul] using smul_le_smul_of_nonneg_right h hb
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁶ : Monoid α
inst✝⁵ : Zero α
inst✝⁴ : Zero β
inst✝³ : MulAction α β
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : SMulPosMono α β
hb : 0 ≤ b
h : a ≤ 1
⊢ a • b ≤ b
state_after: no goals
Theorem: Int.odd_iff
File: Mathlib/Algebra/Ring/Int.lean

tactic: simp [hm, add_emod]
state_before: m✝ n : ℤ
x✝ : Odd n
m : ℤ
hm : n = 2 * m + 1
⊢ n % 2 = 1
state_after: no goals

tactic: rw [← h, add_comm, emod_add_ediv n 2]
state_before: m n : ℤ
h : n % 2 = 1
⊢ n = 2 * (n / 2) + 1
state_after: no goals
Theorem: Convex.norm_image_sub_le_of_norm_hasDerivWithin_le
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simp
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_3
G : Type u_4
inst✝³ : RCLike 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f f' : 𝕜 → G
s : Set 𝕜
x✝ y : 𝕜
C : ℝ
hf : ∀ x ∈ s, HasDerivWithinAt f (f' x) s x
bound : ∀ x ∈ s, ‖f' x‖ ≤ C
hs : Convex ℝ s
xs : x✝ ∈ s
ys : y ∈ s
x : 𝕜
hx : x ∈ s
⊢ ‖smulRight 1 (f' x)‖ ≤ ‖f' x‖
state_after: no goals
Theorem: List.get?_inj
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: apply getElem?_inj h₀ h₁
state_before: i : Nat
α✝ : Type u_1
xs : List α✝
j : Nat
h₀ : i < xs.length
h₁ : xs.Nodup
h₂ : xs.get? i = xs.get? j
⊢ i = j
state_after: i : Nat
α✝ : Type u_1
xs : List α✝
j : Nat
h₀ : i < xs.length
h₁ : xs.Nodup
h₂ : xs.get? i = xs.get? j
⊢ xs[i]? = xs[j]?

tactic: simp_all
state_before: i : Nat
α✝ : Type u_1
xs : List α✝
j : Nat
h₀ : i < xs.length
h₁ : xs.Nodup
h₂ : xs.get? i = xs.get? j
⊢ xs[i]? = xs[j]?
state_after: no goals
Theorem: multiplicity.pow_dvd_of_le_multiplicity
File: Mathlib/RingTheory/Multiplicity.lean

tactic: exact
  Nat.casesOn k
    (fun _ => by
      rw [_root_.pow_zero]
      exact one_dvd _)
    fun k ⟨_, h₂⟩ => by_contradiction fun hk => Nat.find_min _ (lt_of_succ_le (h₂ ⟨k, hk⟩)) hk
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
k : ℕ
⊢ ↑k ≤ multiplicity a b → a ^ k ∣ b
state_after: no goals

tactic: rw [_root_.pow_zero]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
k : ℕ
x✝ : ↑zero ≤ multiplicity a b
⊢ a ^ zero ∣ b
state_after: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
k : ℕ
x✝ : ↑zero ≤ multiplicity a b
⊢ 1 ∣ b

tactic: exact one_dvd _
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
k : ℕ
x✝ : ↑zero ≤ multiplicity a b
⊢ 1 ∣ b
state_after: no goals
Theorem: LinearMap.comap_le_comap_iff
File: Mathlib/Algebra/Module/Submodule/Range.lean

tactic: rcases range_eq_top.1 hf x with ⟨y, hy, rfl⟩
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_11
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
hf : range f = ⊤
p p' : Submodule R₂ M₂
H : comap f p ≤ comap f p'
x : M₂
hx : x ∈ p
⊢ x ∈ p'
state_after: case intro.refl
R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_11
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
hf : range f = ⊤
p p' : Submodule R₂ M₂
H : comap f p ≤ comap f p'
y : M
hx : f y ∈ p
⊢ f y ∈ p'

tactic: exact H hx
state_before: case intro.refl
R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_11
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
hf : range f = ⊤
p p' : Submodule R₂ M₂
H : comap f p ≤ comap f p'
y : M
hx : f y ∈ p
⊢ f y ∈ p'
state_after: no goals
Theorem: OrderHom.fst_prod_snd
File: Mathlib/Order/Hom/Basic.lean

tactic: ext ⟨x, y⟩ : 2
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
⊢ fst.prod snd = id
state_after: case h.h.mk
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
x : α
y : β
⊢ (fst.prod snd) (x, y) = id (x, y)

tactic: rfl
state_before: case h.h.mk
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
x : α
y : β
⊢ (fst.prod snd) (x, y) = id (x, y)
state_after: no goals
Theorem: Finset.powersetCard_zero
File: Mathlib/Data/Finset/Powerset.lean

tactic: ext
state_before: α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.14430
s✝ t s : Finset α
⊢ powersetCard 0 s = {∅}
state_after: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.14430
s✝ t s a✝ : Finset α
⊢ a✝ ∈ powersetCard 0 s ↔ a✝ ∈ {∅}

tactic: rw [mem_powersetCard, mem_singleton, card_eq_zero]
state_before: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.14430
s✝ t s a✝ : Finset α
⊢ a✝ ∈ powersetCard 0 s ↔ a✝ ∈ {∅}
state_after: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.14430
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝ = ∅ ↔ a✝ = ∅

tactic: refine
  ⟨fun h => h.2, fun h => by
    rw [h]
    exact ⟨empty_subset s, rfl⟩⟩
state_before: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.14430
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝ = ∅ ↔ a✝ = ∅
state_after: no goals

tactic: rw [h]
state_before: α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.14430
s✝ t s a✝ : Finset α
h : a✝ = ∅
⊢ a✝ ⊆ s ∧ a✝ = ∅
state_after: α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.14430
s✝ t s a✝ : Finset α
h : a✝ = ∅
⊢ ∅ ⊆ s ∧ ∅ = ∅

tactic: exact ⟨empty_subset s, rfl⟩
state_before: α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.14430
s✝ t s a✝ : Finset α
h : a✝ = ∅
⊢ ∅ ⊆ s ∧ ∅ = ∅
state_after: no goals
Theorem: Submodule.comap_snd
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext ⟨x, y⟩
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ comap (snd R M M₂) q = ⊤.prod q
state_after: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ comap (snd R M M₂) q ↔ (x, y) ∈ ⊤.prod q

tactic: simp
state_before: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ comap (snd R M M₂) q ↔ (x, y) ∈ ⊤.prod q
state_after: no goals
Theorem: OrderIso.trans_refl
File: Mathlib/Order/Hom/Basic.lean

tactic: ext x
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝² : LE α
inst✝¹ : LE β
inst✝ : LE γ
e : α ≃o β
⊢ e.trans (refl β) = e
state_after: case h.h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝² : LE α
inst✝¹ : LE β
inst✝ : LE γ
e : α ≃o β
x : α
⊢ (e.trans (refl β)) x = e x

tactic: rfl
state_before: case h.h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝² : LE α
inst✝¹ : LE β
inst✝ : LE γ
e : α ≃o β
x : α
⊢ (e.trans (refl β)) x = e x
state_after: no goals
Theorem: ENNReal.inv_strictAnti
File: Mathlib/Data/ENNReal/Inv.lean

tactic: intro a b h
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ StrictAnti Inv.inv
state_after: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
h : a < b
⊢ b⁻¹ < a⁻¹

tactic: lift a to ℝ≥0 using h.ne_top
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
h : a < b
⊢ b⁻¹ < a⁻¹
state_after: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
b : ℝ≥0∞
a : ℝ≥0
h : ↑a < b
⊢ b⁻¹ < (↑a)⁻¹

tactic: induction b
state_before: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
b : ℝ≥0∞
a : ℝ≥0
h : ↑a < b
⊢ b⁻¹ < (↑a)⁻¹
state_after: case intro.top
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
h : ↑a < ⊤
⊢ ⊤⁻¹ < (↑a)⁻¹

case intro.coe
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : ↑a < ↑x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹

tactic: rw [coe_lt_coe] at h
state_before: case intro.coe
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : ↑a < ↑x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹
state_after: case intro.coe
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: case intro.coe
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹
state_after: case intro.coe.inl
a b c d : ℝ≥0∞
r p q x✝ : ℝ≥0
h : 0 < x✝
⊢ (↑x✝)⁻¹ < (↑0)⁻¹

case intro.coe.inr
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ (↑x✝)⁻¹ < (↑a)⁻¹

tactic: rw [← coe_inv h.ne_bot, ← coe_inv ha, coe_lt_coe]
state_before: case intro.coe.inr
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ (↑x✝)⁻¹ < (↑a)⁻¹
state_after: case intro.coe.inr
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ x✝⁻¹ < a⁻¹

tactic: exact NNReal.inv_lt_inv ha h
state_before: case intro.coe.inr
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ x✝⁻¹ < a⁻¹
state_after: no goals

tactic: simp
state_before: case intro.top
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
h : ↑a < ⊤
⊢ ⊤⁻¹ < (↑a)⁻¹
state_after: no goals

tactic: simp [h]
state_before: case intro.coe.inl
a b c d : ℝ≥0∞
r p q x✝ : ℝ≥0
h : 0 < x✝
⊢ (↑x✝)⁻¹ < (↑0)⁻¹
state_after: no goals
Theorem: Finset.map_subtype_embedding_Ioc
File: Mathlib/Order/Interval/Finset/Defs.lean

tactic: rw [subtype_Ioc_eq]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Ioc a b) = Ioc ↑a ↑b
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ioc ↑a ↑b)) = Ioc ↑a ↑b

tactic: refine Finset.subtype_map_of_mem fun x hx => ?_
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ioc ↑a ↑b)) = Ioc ↑a ↑b
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : x ∈ Ioc ↑a ↑b
⊢ p x

tactic: rw [mem_Ioc] at hx
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : x ∈ Ioc ↑a ↑b
⊢ p x
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : ↑a < x ∧ x ≤ ↑b
⊢ p x

tactic: exact hp hx.1.le hx.2 a.prop b.prop
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : ↑a < x ∧ x ≤ ↑b
⊢ p x
state_after: no goals
Theorem: CategoryTheory.Bicategory.pentagon_inv_hom_hom_hom_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv ((α_ (f ≫ g) h i).inv ≫ (α_ f g h).hom ▷ i ≫ (α_ f (g ≫ h) i).hom) =
    inv ((α_ f g (h ≫ i)).hom ≫ f ◁ (α_ g h i).inv)
state_after: no goals
Theorem: Nat.factors_eq
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp
state_before: α : Type u_1
⊢ normalizedFactors 0 = ↑(factors 0)
state_after: no goals

tactic: rw [← Multiset.rel_eq, ← associated_eq_eq]
state_before: α : Type u_1
n : ℕ
⊢ normalizedFactors (n + 1) = ↑(n + 1).factors
state_after: α : Type u_1
n : ℕ
⊢ Multiset.Rel (fun x x_1 => x ~ᵤ x_1) (normalizedFactors (n + 1)) ↑(n + 1).factors

tactic: apply UniqueFactorizationMonoid.factors_unique irreducible_of_normalized_factor _
state_before: α : Type u_1
n : ℕ
⊢ Multiset.Rel (fun x x_1 => x ~ᵤ x_1) (normalizedFactors (n + 1)) ↑(n + 1).factors
state_after: α : Type u_1
n : ℕ
⊢ (normalizedFactors (n + 1)).prod ~ᵤ (↑(n + 1).factors).prod

α : Type u_1
n : ℕ
⊢ ∀ x ∈ ↑(n + 1).factors, Irreducible x

tactic: rw [Multiset.prod_coe, Nat.prod_factors n.succ_ne_zero]
state_before: α : Type u_1
n : ℕ
⊢ (normalizedFactors (n + 1)).prod ~ᵤ (↑(n + 1).factors).prod
state_after: α : Type u_1
n : ℕ
⊢ (normalizedFactors (n + 1)).prod ~ᵤ n.succ

tactic: exact normalizedFactors_prod n.succ_ne_zero
state_before: α : Type u_1
n : ℕ
⊢ (normalizedFactors (n + 1)).prod ~ᵤ n.succ
state_after: no goals

tactic: intro x hx
state_before: α : Type u_1
n : ℕ
⊢ ∀ x ∈ ↑(n + 1).factors, Irreducible x
state_after: α : Type u_1
n x : ℕ
hx : x ∈ ↑(n + 1).factors
⊢ Irreducible x

tactic: rw [Nat.irreducible_iff_prime, ← Nat.prime_iff]
state_before: α : Type u_1
n x : ℕ
hx : x ∈ ↑(n + 1).factors
⊢ Irreducible x
state_after: α : Type u_1
n x : ℕ
hx : x ∈ ↑(n + 1).factors
⊢ Prime x

tactic: exact Nat.prime_of_mem_factors hx
state_before: α : Type u_1
n x : ℕ
hx : x ∈ ↑(n + 1).factors
⊢ Prime x
state_after: no goals