1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContinuousOn.le_sSup_image_Icc
File: Mathlib/Topology/Algebra/Order/Compact.lean

tactic: have := mem_image_of_mem f hc
state_before: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : DenselyOrdered α
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a b c : α
h : ContinuousOn f (Icc a b)
hc : c ∈ Icc a b
⊢ f c ≤ sSup (f '' Icc a b)
state_after: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : DenselyOrdered α
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a b c : α
h : ContinuousOn f (Icc a b)
hc : c ∈ Icc a b
this : f c ∈ f '' Icc a b
⊢ f c ≤ sSup (f '' Icc a b)

tactic: rw [h.image_Icc (hc.1.trans hc.2)] at this
state_before: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : DenselyOrdered α
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a b c : α
h : ContinuousOn f (Icc a b)
hc : c ∈ Icc a b
this : f c ∈ f '' Icc a b
⊢ f c ≤ sSup (f '' Icc a b)
state_after: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : DenselyOrdered α
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a b c : α
h : ContinuousOn f (Icc a b)
hc : c ∈ Icc a b
this : f c ∈ Icc (sInf (f '' Icc a b)) (sSup (f '' Icc a b))
⊢ f c ≤ sSup (f '' Icc a b)

tactic: exact this.2
state_before: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : DenselyOrdered α
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a b c : α
h : ContinuousOn f (Icc a b)
hc : c ∈ Icc a b
this : f c ∈ Icc (sInf (f '' Icc a b)) (sSup (f '' Icc a b))
⊢ f c ≤ sSup (f '' Icc a b)
state_after: no goals
Theorem: ConvexOn.lt_right_of_left_lt
File: Mathlib/Analysis/Convex/Function.lean

tactic: obtain ⟨a, b, ha, hb, hab, rfl⟩ := hz
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y z : E
hx : x ∈ s
hy : y ∈ s
hz : z ∈ openSegment 𝕜 x y
hxz : f x < f z
⊢ f z < f y
state_after: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
hx : x ∈ s
hy : y ∈ s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hxz : f x < f (a • x + b • y)
⊢ f (a • x + b • y) < f y

tactic: exact hf.lt_right_of_left_lt' hx hy ha hb hab hxz
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
hx : x ∈ s
hy : y ∈ s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hxz : f x < f (a • x + b • y)
⊢ f (a • x + b • y) < f y
state_after: no goals
Theorem: RCLike.conj_mul
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: rw [mul_comm, mul_conj]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ (starRingEnd K) z * z = ↑‖z‖ ^ 2
state_after: no goals
Theorem: Submodule.mem_colon_singleton
File: Mathlib/RingTheory/Ideal/Colon.lean

tactic: simp [Submodule.mem_colon, Submodule.mem_span_singleton]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
F : Type u_4
G : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N✝ N₁ N₂ P P₁ P₂ N : Submodule R M
x : M
r : R
⊢ r ∈ N.colon (span R {x}) ↔ ∀ (a : R), r • a • x ∈ N
state_after: no goals

tactic: simp_rw [fun (a : R) ↦ smul_comm r a x]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
F : Type u_4
G : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N✝ N₁ N₂ P P₁ P₂ N : Submodule R M
x : M
r : R
⊢ (∀ (a : R), r • a • x ∈ N) ↔ r • x ∈ N
state_after: R : Type u_1
M : Type u_2
M' : Type u_3
F : Type u_4
G : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N✝ N₁ N₂ P P₁ P₂ N : Submodule R M
x : M
r : R
⊢ (∀ (a : R), a • r • x ∈ N) ↔ r • x ∈ N

tactic: exact SetLike.forall_smul_mem_iff
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
F : Type u_4
G : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N✝ N₁ N₂ P P₁ P₂ N : Submodule R M
x : M
r : R
⊢ (∀ (a : R), a • r • x ∈ N) ↔ r • x ∈ N
state_after: no goals
Theorem: Nat.succ_descFactorial_succ
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [descFactorial_zero, descFactorial_one, Nat.mul_one]
state_before: n : ℕ
⊢ (n + 1).descFactorial (0 + 1) = (n + 1) * n.descFactorial 0
state_after: no goals

tactic: rw [descFactorial_succ, succ_descFactorial_succ _ k, descFactorial_succ, succ_sub_succ,
  Nat.mul_left_comm]
state_before: n k : ℕ
⊢ (n + 1).descFactorial (k.succ + 1) = (n + 1) * n.descFactorial k.succ
state_after: no goals
Theorem: WithZero.le_max_iff
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

tactic: simp only [WithZero.coe_le_coe, le_max_iff]
state_before: α : Type u_1
inst✝ : LinearOrder α
a b c : α
⊢ ↑a ≤ max ↑b ↑c ↔ a ≤ max b c
state_after: no goals
Theorem: Nat.Prime.dvd_choose_pow
File: Mathlib/Data/Nat/Multiplicity.lean

tactic: obtain hkp | hkp := hkp.symm.lt_or_lt
state_before: p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp : k ≠ p ^ n
⊢ p ∣ (p ^ n).choose k
state_after: case inl
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : p ^ n < k
⊢ p ∣ (p ^ n).choose k

case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
⊢ p ∣ (p ^ n).choose k

tactic: refine multiplicity_ne_zero.1 fun h => hkp.not_le <| Nat.le_of_dvd hk.bot_lt ?_
state_before: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
⊢ p ∣ (p ^ n).choose k
state_after: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
h : multiplicity p ((p ^ n).choose k) = 0
⊢ p ^ n ∣ k

tactic: have H := hp.multiplicity_choose_prime_pow_add_multiplicity hkp.le hk
state_before: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
h : multiplicity p ((p ^ n).choose k) = 0
⊢ p ^ n ∣ k
state_after: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
h : multiplicity p ((p ^ n).choose k) = 0
H : multiplicity p ((p ^ n).choose k) + multiplicity p k = ↑n
⊢ p ^ n ∣ k

tactic: rw [h, zero_add, eq_coe_iff] at H
state_before: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
h : multiplicity p ((p ^ n).choose k) = 0
H : multiplicity p ((p ^ n).choose k) + multiplicity p k = ↑n
⊢ p ^ n ∣ k
state_after: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
h : multiplicity p ((p ^ n).choose k) = 0
H : p ^ n ∣ k ∧ ¬p ^ (n + 1) ∣ k
⊢ p ^ n ∣ k

tactic: exact H.1
state_before: case inr
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : k < p ^ n
h : multiplicity p ((p ^ n).choose k) = 0
H : p ^ n ∣ k ∧ ¬p ^ (n + 1) ∣ k
⊢ p ^ n ∣ k
state_after: no goals

tactic: simp [choose_eq_zero_of_lt hkp]
state_before: case inl
p n k : ℕ
hp : Prime p
hk : k ≠ 0
hkp✝ : k ≠ p ^ n
hkp : p ^ n < k
⊢ p ∣ (p ^ n).choose k
state_after: no goals
Theorem: Ordinal.lsub_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [(#ι).lift_id]
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
c : Ordinal.{u}
hι : #ι < c.cof
⊢ Cardinal.lift.{u, u} #ι < c.cof
state_after: no goals
Theorem: WeierstrassCurve.baseChange_Ψ₂Sq
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: rw [← map_Ψ₂Sq, map_baseChange]
state_before: R : Type r
S : Type s
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
W : WeierstrassCurve R
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
⊢ (W.baseChange B).Ψ₂Sq = Polynomial.map (↑f) (W.baseChange A).Ψ₂Sq
state_after: no goals
Theorem: ENNReal.rpow_natCast
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases x
state_before: x : ℝ≥0∞
n : ℕ
⊢ x ^ ↑n = x ^ n
state_after: case top
n : ℕ
⊢ ⊤ ^ ↑n = ⊤ ^ n

case coe
n : ℕ
x✝ : ℝ≥0
⊢ ↑x✝ ^ ↑n = ↑x✝ ^ n

tactic: cases n <;> simp [top_rpow_of_pos (Nat.cast_add_one_pos _), top_pow (Nat.succ_pos _)]
state_before: case top
n : ℕ
⊢ ⊤ ^ ↑n = ⊤ ^ n
state_after: no goals

tactic: simp [coe_rpow_of_nonneg _ (Nat.cast_nonneg n)]
state_before: case coe
n : ℕ
x✝ : ℝ≥0
⊢ ↑x✝ ^ ↑n = ↑x✝ ^ n
state_after: no goals
Theorem: LinearMap.quotientInfEquivSupQuotient_symm_apply_eq_zero_iff
File: Mathlib/LinearAlgebra/Isomorphisms.lean

tactic: rw [_root_.map_zero, Quotient.mk_eq_zero, mem_comap, Submodule.coeSubtype]
state_before: R : Type u_1
M : Type u_2
M₂ : Type u_3
M₃ : Type u_4
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
x : ↥(p ⊔ p')
⊢ Submodule.Quotient.mk x = (quotientInfEquivSupQuotient p p') 0 ↔ ↑x ∈ p'
state_after: no goals
Theorem: ENNReal.log_surjective
File: Mathlib/Analysis/SpecialFunctions/Log/ENNReal.lean

tactic: intro y
state_before: ⊢ Function.Surjective log
state_after: y : EReal
⊢ ∃ a, a.log = y

tactic: cases' eq_bot_or_bot_lt y with y_bot y_nbot
state_before: y : EReal
⊢ ∃ a, a.log = y
state_after: case inl
y : EReal
y_bot : y = ⊥
⊢ ∃ a, a.log = y

case inr
y : EReal
y_nbot : ⊥ < y
⊢ ∃ a, a.log = y

tactic: cases' eq_top_or_lt_top y with y_top y_ntop
state_before: case inr
y : EReal
y_nbot : ⊥ < y
⊢ ∃ a, a.log = y
state_after: case inr.inl
y : EReal
y_nbot : ⊥ < y
y_top : y = ⊤
⊢ ∃ a, a.log = y

case inr.inr
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
⊢ ∃ a, a.log = y

tactic: use ENNReal.ofReal (Real.exp y.toReal)
state_before: case inr.inr
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
⊢ ∃ a, a.log = y
state_after: case h
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
⊢ (ENNReal.ofReal (Real.exp y.toReal)).log = y

tactic: have exp_y_pos := not_le_of_lt (Real.exp_pos y.toReal)
state_before: case h
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
⊢ (ENNReal.ofReal (Real.exp y.toReal)).log = y
state_after: case h
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
exp_y_pos : ¬Real.exp y.toReal ≤ 0
⊢ (ENNReal.ofReal (Real.exp y.toReal)).log = y

tactic: simp only [log, ofReal_eq_zero, exp_y_pos, ↓reduceIte, ofReal_ne_top,
  ENNReal.toReal_ofReal (le_of_lt (Real.exp_pos y.toReal)), Real.log_exp y.toReal]
state_before: case h
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
exp_y_pos : ¬Real.exp y.toReal ≤ 0
⊢ (ENNReal.ofReal (Real.exp y.toReal)).log = y
state_after: case h
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
exp_y_pos : ¬Real.exp y.toReal ≤ 0
⊢ ↑y.toReal = y

tactic: exact EReal.coe_toReal (ne_of_lt y_ntop) (Ne.symm (ne_of_lt y_nbot))
state_before: case h
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
exp_y_pos : ¬Real.exp y.toReal ≤ 0
⊢ ↑y.toReal = y
state_after: no goals

tactic: exact y_bot ▸ ⟨⊥, log_zero⟩
state_before: case inl
y : EReal
y_bot : y = ⊥
⊢ ∃ a, a.log = y
state_after: no goals

tactic: exact y_top ▸ ⟨⊤, log_top⟩
state_before: case inr.inl
y : EReal
y_nbot : ⊥ < y
y_top : y = ⊤
⊢ ∃ a, a.log = y
state_after: no goals
Theorem: Matrix.vecMul_vecMul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype m
v : m → α
M : Matrix m n α
N : Matrix n o α
⊢ v ᵥ* M ᵥ* N = v ᵥ* (M * N)
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype m
v : m → α
M : Matrix m n α
N : Matrix n o α
x✝ : o
⊢ (v ᵥ* M ᵥ* N) x✝ = (v ᵥ* (M * N)) x✝

tactic: apply dotProduct_assoc
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype m
v : m → α
M : Matrix m n α
N : Matrix n o α
x✝ : o
⊢ (v ᵥ* M ᵥ* N) x✝ = (v ᵥ* (M * N)) x✝
state_after: no goals
Theorem: Nat.Primrec.add
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: p : ℕ
⊢ unpaired (fun z n => Nat.rec (id z) (fun y IH => (unpair (unpair (Nat.pair z (Nat.pair y IH))).2).2.succ) n) p =
    unpaired (fun x x_1 => x + x_1) p
state_after: p : ℕ
⊢ Nat.rec (unpair p).1 (fun y IH => IH + 1) (unpair p).2 = (unpair p).1 + (unpair p).2

tactic: induction p.unpair.2 <;> simp [*, Nat.add_assoc]
state_before: p : ℕ
⊢ Nat.rec (unpair p).1 (fun y IH => IH + 1) (unpair p).2 = (unpair p).1 + (unpair p).2
state_after: no goals
Theorem: Algebra.adjoin_res_eq_adjoin_res
File: Mathlib/RingTheory/Adjoin/Tower.lean

tactic: rw [adjoin_restrictScalars C E, adjoin_restrictScalars C D, ← hS, ← hT, ← Algebra.adjoin_image,
  ← Algebra.adjoin_image, ← AlgHom.coe_toRingHom, ← AlgHom.coe_toRingHom,
  IsScalarTower.coe_toAlgHom, IsScalarTower.coe_toAlgHom, ← adjoin_union_eq_adjoin_adjoin, ←
  adjoin_union_eq_adjoin_adjoin, Set.union_comm]
state_before: R : Type u
S✝ : Type v
A : Type w
B : Type u₁
C : Type u_1
D : Type u_2
E : Type u_3
F : Type u_4
inst✝¹⁰ : CommSemiring C
inst✝⁹ : CommSemiring D
inst✝⁸ : CommSemiring E
inst✝⁷ : CommSemiring F
inst✝⁶ : Algebra C D
inst✝⁵ : Algebra C E
inst✝⁴ : Algebra C F
inst✝³ : Algebra D F
inst✝² : Algebra E F
inst✝¹ : IsScalarTower C D F
inst✝ : IsScalarTower C E F
S : Set D
T : Set E
hS : adjoin C S = ⊤
hT : adjoin C T = ⊤
⊢ Subalgebra.restrictScalars C (adjoin E (⇑(algebraMap D F) '' S)) =
    Subalgebra.restrictScalars C (adjoin D (⇑(algebraMap E F) '' T))
state_after: no goals
Theorem: Filter.cofinite.liminf_set_eq
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [← cofinite.bliminf_true s, cofinite.bliminf_set_eq, true_and_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a : α
⊢ liminf s cofinite = {x | {n | x ∉ s n}.Finite}
state_after: no goals
Theorem: Relation.cutExpand_singleton_singleton
File: Mathlib/Logic/Hydra.lean

tactic: rwa [mem_singleton.1 h]
state_before: α : Type u_1
r : α → α → Prop
x' x : α
h✝ : r x' x
a : α
h : a ∈ {x'}
⊢ r a x
state_after: no goals
Theorem: isLowerSet_iff_forall_lt
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [le_iff_eq_or_lt, or_imp, forall_and]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : PartialOrder α
s : Set α
a : α
⊢ (∀ ⦃b : α⦄, b ≤ a → a ∈ s → b ∈ s) ↔ ∀ ⦃b : α⦄, b < a → a ∈ s → b ∈ s
state_after: no goals
Theorem: div_mul_eq_div_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / (b * c) = a / b / c
state_after: no goals
Theorem: Submonoid.orderOf_le_card
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [← Nat.card_submonoidPowers]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
s : Submonoid G
hs : (↑s).Finite
hx : x ∈ s
⊢ orderOf x ≤ Nat.card ↥s
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
s : Submonoid G
hs : (↑s).Finite
hx : x ∈ s
⊢ Nat.card ↥(powers x) ≤ Nat.card ↥s

tactic: exact Nat.card_mono hs <| powers_le.2 hx
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
s : Submonoid G
hs : (↑s).Finite
hx : x ∈ s
⊢ Nat.card ↥(powers x) ≤ Nat.card ↥s
state_after: no goals
Theorem: ZMod.isQuadratic_χ₈'
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: unfold MulChar.IsQuadratic
state_before: ⊢ χ₈'.IsQuadratic
state_after: ⊢ ∀ (a : ZMod 8), χ₈' a = 0 ∨ χ₈' a = 1 ∨ χ₈' a = -1

tactic: decide
state_before: ⊢ ∀ (a : ZMod 8), χ₈' a = 0 ∨ χ₈' a = 1 ∨ χ₈' a = -1
state_after: no goals
Theorem: CategoryTheory.shift_shift'
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: symm
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftFunctor C j).map ((shiftFunctor C i).map f) =
    (shiftAdd X i j).inv ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftAdd X i j).inv ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom =
    (shiftFunctor C j).map ((shiftFunctor C i).map f)

tactic: rw [← Functor.comp_map, NatIso.app_inv]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftAdd X i j).inv ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom =
    (shiftFunctor C j).map ((shiftFunctor C i).map f)
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftFunctorAdd C i j).inv.app X ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom =
    (shiftFunctor C i ⋙ shiftFunctor C j).map f

tactic: apply NatIso.naturality_1
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftFunctorAdd C i j).inv.app X ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom =
    (shiftFunctor C i ⋙ shiftFunctor C j).map f
state_after: no goals
Theorem: Rat.normalize_eq_zero
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: have' := normalize_eq_iff d0 Nat.one_ne_zero
state_before: d : Nat
n : Int
d0 : d ≠ 0
⊢ normalize n d d0 = 0 ↔ n = 0
state_after: case refine'_3
d : Nat
n : Int
d0 : d ≠ 0
this : normalize ?refine'_1 d d0 = normalize ?refine'_2 1 Nat.one_ne_zero ↔ ?refine'_1 * ↑1 = ?refine'_2 * ↑d
⊢ normalize n d d0 = 0 ↔ n = 0

case refine'_1
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int

case refine'_2
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int

tactic: rw [normalize_zero (d := 1)] at this
state_before: case refine'_3
d : Nat
n : Int
d0 : d ≠ 0
this : normalize ?refine'_1 d d0 = normalize ?refine'_2 1 Nat.one_ne_zero ↔ ?refine'_1 * ↑1 = ?refine'_2 * ↑d
⊢ normalize n d d0 = 0 ↔ n = 0

case refine'_1
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int

case refine'_2
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int
state_after: case refine'_3
d : Nat
n : Int
d0 : d ≠ 0
this : normalize ?refine'_1 d d0 = 0 ↔ ?refine'_1 * ↑1 = 0 * ↑d
⊢ normalize n d d0 = 0 ↔ n = 0

case refine'_1
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int

tactic: rw [this]
state_before: case refine'_3
d : Nat
n : Int
d0 : d ≠ 0
this : normalize ?refine'_1 d d0 = 0 ↔ ?refine'_1 * ↑1 = 0 * ↑d
⊢ normalize n d d0 = 0 ↔ n = 0

case refine'_1
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int
state_after: case refine'_3
d : Nat
n : Int
d0 : d ≠ 0
this : normalize n d d0 = 0 ↔ n * ↑1 = 0 * ↑d
⊢ n * ↑1 = 0 * ↑d ↔ n = 0

tactic: simp
state_before: case refine'_3
d : Nat
n : Int
d0 : d ≠ 0
this : normalize n d d0 = 0 ↔ n * ↑1 = 0 * ↑d
⊢ n * ↑1 = 0 * ↑d ↔ n = 0
state_after: no goals
Theorem: IsLowerSet.memberSubfamily
File: Mathlib/Combinatorics/SetFamily/HarrisKleitman.lean

tactic: rintro s t hts
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
h : IsLowerSet ↑𝒜
⊢ IsLowerSet ↑(Finset.memberSubfamily a 𝒜)
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ : Finset α
a : α
h : IsLowerSet ↑𝒜
s t : Finset α
hts : t ≤ s
⊢ s ∈ ↑(Finset.memberSubfamily a 𝒜) → t ∈ ↑(Finset.memberSubfamily a 𝒜)

tactic: simp_rw [mem_coe, mem_memberSubfamily]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ : Finset α
a : α
h : IsLowerSet ↑𝒜
s t : Finset α
hts : t ≤ s
⊢ s ∈ ↑(Finset.memberSubfamily a 𝒜) → t ∈ ↑(Finset.memberSubfamily a 𝒜)
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ : Finset α
a : α
h : IsLowerSet ↑𝒜
s t : Finset α
hts : t ≤ s
⊢ insert a s ∈ 𝒜 ∧ a ∉ s → insert a t ∈ 𝒜 ∧ a ∉ t

tactic: exact And.imp (h <| insert_subset_insert _ hts) (mt <| @hts _)
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ : Finset α
a : α
h : IsLowerSet ↑𝒜
s t : Finset α
hts : t ≤ s
⊢ insert a s ∈ 𝒜 ∧ a ∉ s → insert a t ∈ 𝒜 ∧ a ∉ t
state_after: no goals
Theorem: Real.log_intCast_nonneg
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: cases lt_trichotomy 0 n with
| inl hn =>
    have : (1 : ℝ) ≤ n := mod_cast hn
    exact log_nonneg this
| inr hn =>
    cases hn with
    | inl hn => simp [hn.symm]
    | inr hn =>
        have : (1 : ℝ) ≤ -n := by rw [← neg_zero, ← lt_neg] at hn; exact mod_cast hn
        rw [← log_neg_eq_log]
        exact log_nonneg this
state_before: x y : ℝ
n : ℤ
⊢ 0 ≤ log ↑n
state_after: no goals

tactic: have : (1 : ℝ) ≤ n := mod_cast hn
state_before: case inl
x y : ℝ
n : ℤ
hn : 0 < n
⊢ 0 ≤ log ↑n
state_after: case inl
x y : ℝ
n : ℤ
hn : 0 < n
this : 1 ≤ ↑n
⊢ 0 ≤ log ↑n

tactic: exact log_nonneg this
state_before: case inl
x y : ℝ
n : ℤ
hn : 0 < n
this : 1 ≤ ↑n
⊢ 0 ≤ log ↑n
state_after: no goals

tactic: cases hn with
| inl hn => simp [hn.symm]
| inr hn =>
    have : (1 : ℝ) ≤ -n := by rw [← neg_zero, ← lt_neg] at hn; exact mod_cast hn
    rw [← log_neg_eq_log]
    exact log_nonneg this
state_before: case inr
x y : ℝ
n : ℤ
hn : 0 = n ∨ n < 0
⊢ 0 ≤ log ↑n
state_after: no goals

tactic: simp [hn.symm]
state_before: case inr.inl
x y : ℝ
n : ℤ
hn : 0 = n
⊢ 0 ≤ log ↑n
state_after: no goals

tactic: have : (1 : ℝ) ≤ -n := by rw [← neg_zero, ← lt_neg] at hn; exact mod_cast hn
state_before: case inr.inr
x y : ℝ
n : ℤ
hn : n < 0
⊢ 0 ≤ log ↑n
state_after: case inr.inr
x y : ℝ
n : ℤ
hn : n < 0
this : 1 ≤ -↑n
⊢ 0 ≤ log ↑n

tactic: rw [← log_neg_eq_log]
state_before: case inr.inr
x y : ℝ
n : ℤ
hn : n < 0
this : 1 ≤ -↑n
⊢ 0 ≤ log ↑n
state_after: case inr.inr
x y : ℝ
n : ℤ
hn : n < 0
this : 1 ≤ -↑n
⊢ 0 ≤ log (-↑n)

tactic: exact log_nonneg this
state_before: case inr.inr
x y : ℝ
n : ℤ
hn : n < 0
this : 1 ≤ -↑n
⊢ 0 ≤ log (-↑n)
state_after: no goals

tactic: rw [← neg_zero, ← lt_neg] at hn
state_before: x y : ℝ
n : ℤ
hn : n < 0
⊢ 1 ≤ -↑n
state_after: x y : ℝ
n : ℤ
hn : 0 < -n
⊢ 1 ≤ -↑n

tactic: exact mod_cast hn
state_before: x y : ℝ
n : ℤ
hn : 0 < -n
⊢ 1 ≤ -↑n
state_after: no goals
Theorem: Matrix.conjTranspose_fromColumns_eq_fromRows_conjTranspose
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

tactic: ext (_ | _) _ <;> simp
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Star R
A₁ : Matrix m n₁ R
A₂ : Matrix m n₂ R
⊢ (A₁.fromColumns A₂)ᴴ = A₁ᴴ.fromRows A₂ᴴ
state_after: no goals