1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: UpperHalfPlane.sinh_half_dist_add_dist
File: Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean

tactic: simp only [add_div _ _ (2 : ℝ), sinh_add, sinh_half_dist, cosh_half_dist, div_mul_div_comm]
state_before: z w : ℍ
r R : ℝ
a b c : ℍ
⊢ sinh ((dist a b + dist b c) / 2) =
    (dist ↑a ↑b * dist (↑c) ((starRingEnd ℂ) ↑b) + dist ↑b ↑c * dist (↑a) ((starRingEnd ℂ) ↑b)) /
      (2 * √(a.im * c.im) * dist (↑b) ((starRingEnd ℂ) ↑b))
state_after: z w : ℍ
r R : ℝ
a b c : ℍ
⊢ dist ↑a ↑b * dist (↑b) ((starRingEnd ℂ) ↑c) / (2 * √(a.im * b.im) * (2 * √(b.im * c.im))) +
      dist (↑a) ((starRingEnd ℂ) ↑b) * dist ↑b ↑c / (2 * √(a.im * b.im) * (2 * √(b.im * c.im))) =
    (dist ↑a ↑b * dist (↑c) ((starRingEnd ℂ) ↑b) + dist ↑b ↑c * dist (↑a) ((starRingEnd ℂ) ↑b)) /
      (2 * √(a.im * c.im) * dist (↑b) ((starRingEnd ℂ) ↑b))

tactic: rw [← add_div, Complex.dist_self_conj, coe_im, abs_of_pos b.im_pos, mul_comm (dist (b : ℂ) _),
  dist_comm (b : ℂ), Complex.dist_conj_comm, mul_mul_mul_comm, mul_mul_mul_comm _ _ _ b.im]
state_before: z w : ℍ
r R : ℝ
a b c : ℍ
⊢ dist ↑a ↑b * dist (↑b) ((starRingEnd ℂ) ↑c) / (2 * √(a.im * b.im) * (2 * √(b.im * c.im))) +
      dist (↑a) ((starRingEnd ℂ) ↑b) * dist ↑b ↑c / (2 * √(a.im * b.im) * (2 * √(b.im * c.im))) =
    (dist ↑a ↑b * dist (↑c) ((starRingEnd ℂ) ↑b) + dist ↑b ↑c * dist (↑a) ((starRingEnd ℂ) ↑b)) /
      (2 * √(a.im * c.im) * dist (↑b) ((starRingEnd ℂ) ↑b))
state_after: z w : ℍ
r R : ℝ
a b c : ℍ
⊢ (dist ↑a ↑b * dist (↑c) ((starRingEnd ℂ) ↑b) + dist (↑a) ((starRingEnd ℂ) ↑b) * dist ↑b ↑c) /
      (2 * 2 * (√(a.im * b.im) * √(b.im * c.im))) =
    (dist ↑a ↑b * dist (↑c) ((starRingEnd ℂ) ↑b) + dist (↑a) ((starRingEnd ℂ) ↑b) * dist ↑b ↑c) /
      (2 * 2 * (√(a.im * c.im) * b.im))

tactic: congr 2
state_before: z w : ℍ
r R : ℝ
a b c : ℍ
⊢ (dist ↑a ↑b * dist (↑c) ((starRingEnd ℂ) ↑b) + dist (↑a) ((starRingEnd ℂ) ↑b) * dist ↑b ↑c) /
      (2 * 2 * (√(a.im * b.im) * √(b.im * c.im))) =
    (dist ↑a ↑b * dist (↑c) ((starRingEnd ℂ) ↑b) + dist (↑a) ((starRingEnd ℂ) ↑b) * dist ↑b ↑c) /
      (2 * 2 * (√(a.im * c.im) * b.im))
state_after: case e_a.e_a
z w : ℍ
r R : ℝ
a b c : ℍ
⊢ √(a.im * b.im) * √(b.im * c.im) = √(a.im * c.im) * b.im

tactic: rw [sqrt_mul, sqrt_mul, sqrt_mul, mul_comm (√a.im), mul_mul_mul_comm, mul_self_sqrt,
    mul_comm] <;> exact (im_pos _).le
state_before: case e_a.e_a
z w : ℍ
r R : ℝ
a b c : ℍ
⊢ √(a.im * b.im) * √(b.im * c.im) = √(a.im * c.im) * b.im
state_after: no goals
Theorem: smul_mul_smul
File: Mathlib/Algebra/Group/Action/Defs.lean

tactic: rw [smul_mul_assoc, mul_smul_comm, ← smul_assoc, smul_eq_mul]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
inst✝⁴ : Monoid M
inst✝³ : MulAction M α
inst✝² : Mul α
r s : M
x y : α
inst✝¹ : IsScalarTower M α α
inst✝ : SMulCommClass M α α
⊢ r • x * s • y = (r * s) • (x * y)
state_after: no goals
Theorem: HomologicalComplexUpToQuasiIso.Qh_inverts_quasiIso
File: Mathlib/Algebra/Homology/Localization.lean

tactic: rintro ⟨K⟩ ⟨L⟩ φ
state_before: C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
ι : Type u_2
c : ComplexShape ι
inst✝³ : Preadditive C
inst✝² : CategoryWithHomology C
inst✝¹ : (HomologicalComplex.quasiIso C c).HasLocalization
inst✝ : c.QFactorsThroughHomotopy C
⊢ (HomotopyCategory.quasiIso C c).IsInvertedBy Qh
state_after: case mk.mk
C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
ι : Type u_2
c : ComplexShape ι
inst✝³ : Preadditive C
inst✝² : CategoryWithHomology C
inst✝¹ : (HomologicalComplex.quasiIso C c).HasLocalization
inst✝ : c.QFactorsThroughHomotopy C
K L : HomologicalComplex C c
φ : { as := K } ⟶ { as := L }
⊢ HomotopyCategory.quasiIso C c φ → IsIso (Qh.map φ)

tactic: obtain ⟨φ, rfl⟩ := (HomotopyCategory.quotient C c).map_surjective φ
state_before: case mk.mk
C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
ι : Type u_2
c : ComplexShape ι
inst✝³ : Preadditive C
inst✝² : CategoryWithHomology C
inst✝¹ : (HomologicalComplex.quasiIso C c).HasLocalization
inst✝ : c.QFactorsThroughHomotopy C
K L : HomologicalComplex C c
φ : { as := K } ⟶ { as := L }
⊢ HomotopyCategory.quasiIso C c φ → IsIso (Qh.map φ)
state_after: case mk.mk.intro
C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
ι : Type u_2
c : ComplexShape ι
inst✝³ : Preadditive C
inst✝² : CategoryWithHomology C
inst✝¹ : (HomologicalComplex.quasiIso C c).HasLocalization
inst✝ : c.QFactorsThroughHomotopy C
K L : HomologicalComplex C c
φ : K ⟶ L
⊢ HomotopyCategory.quasiIso C c ((HomotopyCategory.quotient C c).map φ) →
    IsIso (Qh.map ((HomotopyCategory.quotient C c).map φ))

tactic: rw [HomotopyCategory.quotient_map_mem_quasiIso_iff φ,
  ← HomologicalComplexUpToQuasiIso.isIso_Q_map_iff_mem_quasiIso]
state_before: case mk.mk.intro
C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
ι : Type u_2
c : ComplexShape ι
inst✝³ : Preadditive C
inst✝² : CategoryWithHomology C
inst✝¹ : (HomologicalComplex.quasiIso C c).HasLocalization
inst✝ : c.QFactorsThroughHomotopy C
K L : HomologicalComplex C c
φ : K ⟶ L
⊢ HomotopyCategory.quasiIso C c ((HomotopyCategory.quotient C c).map φ) →
    IsIso (Qh.map ((HomotopyCategory.quotient C c).map φ))
state_after: case mk.mk.intro
C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
ι : Type u_2
c : ComplexShape ι
inst✝³ : Preadditive C
inst✝² : CategoryWithHomology C
inst✝¹ : (HomologicalComplex.quasiIso C c).HasLocalization
inst✝ : c.QFactorsThroughHomotopy C
K L : HomologicalComplex C c
φ : K ⟶ L
⊢ IsIso (Q.map φ) → IsIso (Qh.map ((HomotopyCategory.quotient C c).map φ))

tactic: exact (NatIso.isIso_map_iff (quotientCompQhIso C c) φ).2
state_before: case mk.mk.intro
C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
ι : Type u_2
c : ComplexShape ι
inst✝³ : Preadditive C
inst✝² : CategoryWithHomology C
inst✝¹ : (HomologicalComplex.quasiIso C c).HasLocalization
inst✝ : c.QFactorsThroughHomotopy C
K L : HomologicalComplex C c
φ : K ⟶ L
⊢ IsIso (Q.map φ) → IsIso (Qh.map ((HomotopyCategory.quotient C c).map φ))
state_after: no goals
Theorem: padicValNat.padicValNat_eq_maxPowDiv
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: ext p n
state_before: p : ℕ
⊢ padicValNat = maxPowDiv
state_after: case h.h
p✝ p n : ℕ
⊢ padicValNat p n = p.maxPowDiv n

tactic: by_cases h : 1 < p ∧ 0 < n
state_before: case h.h
p✝ p n : ℕ
⊢ padicValNat p n = p.maxPowDiv n
state_after: case pos
p✝ p n : ℕ
h : 1 < p ∧ 0 < n
⊢ padicValNat p n = p.maxPowDiv n

case neg
p✝ p n : ℕ
h : ¬(1 < p ∧ 0 < n)
⊢ padicValNat p n = p.maxPowDiv n

tactic: dsimp [padicValNat]
state_before: case pos
p✝ p n : ℕ
h : 1 < p ∧ 0 < n
⊢ padicValNat p n = p.maxPowDiv n
state_after: case pos
p✝ p n : ℕ
h : 1 < p ∧ 0 < n
⊢ (if h : ¬p = 1 ∧ 0 < n then (multiplicity p n).get ⋯ else 0) = p.maxPowDiv n

tactic: rw [dif_pos ⟨Nat.ne_of_gt h.1,h.2⟩, maxPowDiv_eq_multiplicity_get h.1 h.2]
state_before: case pos
p✝ p n : ℕ
h : 1 < p ∧ 0 < n
⊢ (if h : ¬p = 1 ∧ 0 < n then (multiplicity p n).get ⋯ else 0) = p.maxPowDiv n
state_after: no goals

tactic: simp only [not_and_or,not_gt_eq,Nat.le_zero] at h
state_before: case neg
p✝ p n : ℕ
h : ¬(1 < p ∧ 0 < n)
⊢ padicValNat p n = p.maxPowDiv n
state_after: case neg
p✝ p n : ℕ
h : p ≤ 1 ∨ n = 0
⊢ padicValNat p n = p.maxPowDiv n

tactic: apply h.elim
state_before: case neg
p✝ p n : ℕ
h : p ≤ 1 ∨ n = 0
⊢ padicValNat p n = p.maxPowDiv n
state_after: case neg.left
p✝ p n : ℕ
h : p ≤ 1 ∨ n = 0
⊢ p ≤ 1 → padicValNat p n = p.maxPowDiv n

case neg.right
p✝ p n : ℕ
h : p ≤ 1 ∨ n = 0
⊢ n = 0 → padicValNat p n = p.maxPowDiv n

tactic: intro h
state_before: case neg.left
p✝ p n : ℕ
h : p ≤ 1 ∨ n = 0
⊢ p ≤ 1 → padicValNat p n = p.maxPowDiv n
state_after: case neg.left
p✝ p n : ℕ
h✝ : p ≤ 1 ∨ n = 0
h : p ≤ 1
⊢ padicValNat p n = p.maxPowDiv n

tactic: interval_cases p
state_before: case neg.left
p✝ p n : ℕ
h✝ : p ≤ 1 ∨ n = 0
h : p ≤ 1
⊢ padicValNat p n = p.maxPowDiv n
state_after: case neg.left.«0»
p✝ p n : ℕ
h✝ : 0 ≤ 1 ∨ n = 0
h : 0 ≤ 1
⊢ padicValNat 0 n = maxPowDiv 0 n

case neg.left.«1»
p✝ p n : ℕ
h✝ : 1 ≤ 1 ∨ n = 0
h : 1 ≤ 1
⊢ padicValNat 1 n = maxPowDiv 1 n

tactic: simp [Classical.em]
state_before: case neg.left.«0»
p✝ p n : ℕ
h✝ : 0 ≤ 1 ∨ n = 0
h : 0 ≤ 1
⊢ padicValNat 0 n = maxPowDiv 0 n
state_after: no goals

tactic: dsimp [padicValNat, maxPowDiv]
state_before: case neg.left.«1»
p✝ p n : ℕ
h✝ : 1 ≤ 1 ∨ n = 0
h : 1 ≤ 1
⊢ padicValNat 1 n = maxPowDiv 1 n
state_after: case neg.left.«1»
p✝ p n : ℕ
h✝ : 1 ≤ 1 ∨ n = 0
h : 1 ≤ 1
⊢ 0 = go 0 1 n

tactic: rw [go, if_neg]
state_before: case neg.left.«1»
p✝ p n : ℕ
h✝ : 1 ≤ 1 ∨ n = 0
h : 1 ≤ 1
⊢ 0 = go 0 1 n
state_after: case neg.left.«1».hnc
p✝ p n : ℕ
h✝ : 1 ≤ 1 ∨ n = 0
h : 1 ≤ 1
⊢ ¬(1 < 1 ∧ 0 < n ∧ n % 1 = 0)

tactic: simp
state_before: case neg.left.«1».hnc
p✝ p n : ℕ
h✝ : 1 ≤ 1 ∨ n = 0
h : 1 ≤ 1
⊢ ¬(1 < 1 ∧ 0 < n ∧ n % 1 = 0)
state_after: no goals

tactic: intro h
state_before: case neg.right
p✝ p n : ℕ
h : p ≤ 1 ∨ n = 0
⊢ n = 0 → padicValNat p n = p.maxPowDiv n
state_after: case neg.right
p✝ p n : ℕ
h✝ : p ≤ 1 ∨ n = 0
h : n = 0
⊢ padicValNat p n = p.maxPowDiv n

tactic: simp [h]
state_before: case neg.right
p✝ p n : ℕ
h✝ : p ≤ 1 ∨ n = 0
h : n = 0
⊢ padicValNat p n = p.maxPowDiv n
state_after: no goals
Theorem: Ideal.span_singleton_lt_span_singleton
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [lt_iff_le_not_le, span_singleton_le_span_singleton, span_singleton_le_span_singleton,
  dvd_and_not_dvd_iff]
state_before: α : Type u
β : Type v
a b : α
inst✝¹ : CommSemiring α
I : Ideal α
inst✝ : IsDomain α
x y : α
⊢ span {x} < span {y} ↔ DvdNotUnit y x
state_after: no goals
Theorem: Computable.map_decode_iff
File: Mathlib/Computability/Partrec.lean

tactic: convert (bind_decode_iff (f := fun a => Option.some ∘ f a)).trans option_some_iff
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Computable₂ fun a n => Option.map (f a) (decode n)) ↔ Computable₂ f
state_after: case h.e'_1.h.e'_7.h.h
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β → σ
x✝¹ : α
x✝ : ℕ
⊢ Option.map (f x✝¹) (decode x✝) = (decode x✝).bind (Option.some ∘ f x✝¹)

tactic: apply Option.map_eq_bind
state_before: case h.e'_1.h.e'_7.h.h
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β → σ
x✝¹ : α
x✝ : ℕ
⊢ Option.map (f x✝¹) (decode x✝) = (decode x✝).bind (Option.some ∘ f x✝¹)
state_after: no goals
Theorem: EuclideanDomain.mod_eq_zero
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [← div_add_mod a b, h, add_zero]
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
h : a % b = 0
⊢ b ∣ a
state_after: R : Type u
inst✝ : EuclideanDomain R
a b : R
h : a % b = 0
⊢ b ∣ b * (a / b)

tactic: exact dvd_mul_right _ _
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
h : a % b = 0
⊢ b ∣ b * (a / b)
state_after: no goals

tactic: rw [e, ← add_left_cancel_iff, div_add_mod, add_zero]
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
⊢ a % b = 0
state_after: R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
⊢ b * c = b * (b * c / b)

tactic: haveI := Classical.dec
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
⊢ b * c = b * (b * c / b)
state_after: R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
this : (p : Prop) → Decidable p
⊢ b * c = b * (b * c / b)

tactic: by_cases b0 : b = 0
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
this : (p : Prop) → Decidable p
⊢ b * c = b * (b * c / b)
state_after: case pos
R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
this : (p : Prop) → Decidable p
b0 : b = 0
⊢ b * c = b * (b * c / b)

case neg
R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
this : (p : Prop) → Decidable p
b0 : ¬b = 0
⊢ b * c = b * (b * c / b)

tactic: simp only [b0, zero_mul]
state_before: case pos
R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
this : (p : Prop) → Decidable p
b0 : b = 0
⊢ b * c = b * (b * c / b)
state_after: no goals

tactic: rw [mul_div_cancel_left₀ _ b0]
state_before: case neg
R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
this : (p : Prop) → Decidable p
b0 : ¬b = 0
⊢ b * c = b * (b * c / b)
state_after: no goals
Theorem: integrable_inv_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean

tactic: suffices Integrable fun (x : ℝ) ↦ (1 + ‖x‖ ^ 2) ^ ((-2 : ℝ) / 2) by simpa [rpow_neg_one]
state_before: ⊢ Integrable (fun x => (1 + x ^ 2)⁻¹) volume
state_after: ⊢ Integrable (fun x => (1 + ‖x‖ ^ 2) ^ (-2 / 2)) volume

tactic: exact integrable_rpow_neg_one_add_norm_sq (by simp)
state_before: ⊢ Integrable (fun x => (1 + ‖x‖ ^ 2) ^ (-2 / 2)) volume
state_after: no goals

tactic: simpa [rpow_neg_one]
state_before: this : Integrable (fun x => (1 + ‖x‖ ^ 2) ^ (-2 / 2)) volume
⊢ Integrable (fun x => (1 + x ^ 2)⁻¹) volume
state_after: no goals

tactic: simp
state_before: ⊢ ↑(FiniteDimensional.finrank ℝ ℝ) < 2
state_after: no goals
Theorem: MeasureTheory.measure_preimage_mul
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: rw [map_mul_left_eq_self μ g]
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulLeftInvariant
g : G
A : Set G
⊢ (Measure.map (fun h => g * h) μ) A = μ A
state_after: no goals
Theorem: subset_interior_iff_nhds
File: Mathlib/Topology/Basic.lean

tactic: simp_rw [subset_def, mem_interior_iff_mem_nhds]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
V : Set X
⊢ s ⊆ interior V ↔ ∀ x ∈ s, V ∈ 𝓝 x
state_after: no goals
Theorem: MvPolynomial.homogeneousComponent_apply
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
⊢ (homogeneousComponent n) φ = ∑ d ∈ filter (fun d => degree d = n) φ.support, (monomial d) (coeff d φ)
state_after: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
⊢ (homogeneousComponent n) φ = ∑ x ∈ filter (fun d => (weightedDegree 1) d = n) φ.support, (monomial x) (coeff x φ)

tactic: convert weightedHomogeneousComponent_apply n φ
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
⊢ (homogeneousComponent n) φ = ∑ x ∈ filter (fun d => (weightedDegree 1) d = n) φ.support, (monomial x) (coeff x φ)
state_after: no goals
Theorem: ValuationSubring.monotone_mapOfLE
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

tactic: rintro ⟨⟩ ⟨⟩ ⟨a, ha⟩
state_before: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
h : R ≤ S
⊢ Monotone ⇑(R.mapOfLE S h)
state_after: case mk.mk.intro
K : Type u
inst✝ : Field K
A R S : ValuationSubring K
h : R ≤ S
a✝² : R.ValueGroup
a✝¹ : K
b✝ : R.ValueGroup
a✝ : K
a : ↥R
ha : a • a✝ = a✝¹
⊢ (R.mapOfLE S h) (Quot.mk Setoid.r a✝¹) ≤ (R.mapOfLE S h) (Quot.mk Setoid.r a✝)

tactic: exact ⟨R.inclusion S h a, ha⟩
state_before: case mk.mk.intro
K : Type u
inst✝ : Field K
A R S : ValuationSubring K
h : R ≤ S
a✝² : R.ValueGroup
a✝¹ : K
b✝ : R.ValueGroup
a✝ : K
a : ↥R
ha : a • a✝ = a✝¹
⊢ (R.mapOfLE S h) (Quot.mk Setoid.r a✝¹) ≤ (R.mapOfLE S h) (Quot.mk Setoid.r a✝)
state_after: no goals
Theorem: Finset.sup_coe
File: Mathlib/Data/Finset/Lattice.lean

tactic: letI := Subtype.semilatticeSup Psup
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
P : α → Prop
Pbot : P ⊥
Psup : ∀ ⦃x y : α⦄, P x → P y → P (x ⊔ y)
t : Finset β
f : β → { x // P x }
⊢ ↑(t.sup f) = t.sup fun x => ↑(f x)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
P : α → Prop
Pbot : P ⊥
Psup : ∀ ⦃x y : α⦄, P x → P y → P (x ⊔ y)
t : Finset β
f : β → { x // P x }
this : SemilatticeSup { x // P x } := Subtype.semilatticeSup Psup
⊢ ↑(t.sup f) = t.sup fun x => ↑(f x)

tactic: letI := Subtype.orderBot Pbot
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
P : α → Prop
Pbot : P ⊥
Psup : ∀ ⦃x y : α⦄, P x → P y → P (x ⊔ y)
t : Finset β
f : β → { x // P x }
this : SemilatticeSup { x // P x } := Subtype.semilatticeSup Psup
⊢ ↑(t.sup f) = t.sup fun x => ↑(f x)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
P : α → Prop
Pbot : P ⊥
Psup : ∀ ⦃x y : α⦄, P x → P y → P (x ⊔ y)
t : Finset β
f : β → { x // P x }
this✝ : SemilatticeSup { x // P x } := Subtype.semilatticeSup Psup
this : OrderBot { x // P x } := Subtype.orderBot Pbot
⊢ ↑(t.sup f) = t.sup fun x => ↑(f x)

tactic: apply comp_sup_eq_sup_comp Subtype.val <;> intros <;> rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
P : α → Prop
Pbot : P ⊥
Psup : ∀ ⦃x y : α⦄, P x → P y → P (x ⊔ y)
t : Finset β
f : β → { x // P x }
this✝ : SemilatticeSup { x // P x } := Subtype.semilatticeSup Psup
this : OrderBot { x // P x } := Subtype.orderBot Pbot
⊢ ↑(t.sup f) = t.sup fun x => ↑(f x)
state_after: no goals
Theorem: hasProd_extend_one
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [← hg.hasProd_iff, extend_comp hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
g : β → γ
hg : Injective g
⊢ HasProd (extend g f 1) a ↔ HasProd f a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
g : β → γ
hg : Injective g
⊢ ∀ x ∉ Set.range g, extend g f 1 x = 1

tactic: exact extend_apply' _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
g : β → γ
hg : Injective g
⊢ ∀ x ∉ Set.range g, extend g f 1 x = 1
state_after: no goals
Theorem: ProbabilityTheory.IsRatCondKernelCDF.iInf_rat_gt_eq
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

tactic: filter_upwards [hf.isRatStieltjesPoint_ae a] with b hb using hb.iInf_rat_gt_eq
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDF f κ ν
a : α
⊢ ∀ᵐ (b : β) ∂ν a, ∀ (q : ℚ), ⨅ r, f (a, b) ↑r = f (a, b) q
state_after: no goals
Theorem: Orientation.oangle_rotation_self_left
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

tactic: simp [hx]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
hx : x ≠ 0
θ : Real.Angle
⊢ o.oangle ((o.rotation θ) x) x = -θ
state_after: no goals
Theorem: CategoryTheory.Limits.biproduct.lift_map
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: ext
state_before: J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
P : C
k : (j : J) → P ⟶ f j
p : (j : J) → f j ⟶ g j
⊢ lift k ≫ map p = lift fun j => k j ≫ p j
state_after: case w
J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
P : C
k : (j : J) → P ⟶ f j
p : (j : J) → f j ⟶ g j
j✝ : J
⊢ (lift k ≫ map p) ≫ π g j✝ = (lift fun j => k j ≫ p j) ≫ π g j✝

tactic: simp
state_before: case w
J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
P : C
k : (j : J) → P ⟶ f j
p : (j : J) → f j ⟶ g j
j✝ : J
⊢ (lift k ≫ map p) ≫ π g j✝ = (lift fun j => k j ≫ p j) ≫ π g j✝
state_after: no goals
Theorem: Ordinal.isOpen_iff
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: refine isOpen_iff_mem_nhds.trans <| forall₂_congr fun o ho => ?_
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
⊢ IsOpen s ↔ ∀ o ∈ s, o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s
state_after: s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s

tactic: by_cases ho' : IsLimit o
state_before: s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s
state_after: case pos
s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
ho' : o.IsLimit
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s

case neg
s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
ho' : ¬o.IsLimit
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s

tactic: simp only [(nhdsBasis_Ioc ho'.1).mem_iff, ho', true_implies]
state_before: case pos
s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
ho' : o.IsLimit
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s
state_after: case pos
s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
ho' : o.IsLimit
⊢ (∃ i < o, Set.Ioc i o ⊆ s) ↔ ∃ a < o, Set.Ioo a o ⊆ s

tactic: refine exists_congr fun a => and_congr_right fun ha => ?_
state_before: case pos
s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
ho' : o.IsLimit
⊢ (∃ i < o, Set.Ioc i o ⊆ s) ↔ ∃ a < o, Set.Ioo a o ⊆ s
state_after: case pos
s : Set Ordinal.{u}
a✝ o : Ordinal.{u}
ho : o ∈ s
ho' : o.IsLimit
a : Ordinal.{u}
ha : a < o
⊢ Set.Ioc a o ⊆ s ↔ Set.Ioo a o ⊆ s

tactic: simp only [← Set.Ioo_insert_right ha, Set.insert_subset_iff, ho, true_and]
state_before: case pos
s : Set Ordinal.{u}
a✝ o : Ordinal.{u}
ho : o ∈ s
ho' : o.IsLimit
a : Ordinal.{u}
ha : a < o
⊢ Set.Ioc a o ⊆ s ↔ Set.Ioo a o ⊆ s
state_after: no goals

tactic: simp [nhds_eq_pure.2 ho', ho, ho']
state_before: case neg
s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
ho' : ¬o.IsLimit
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s
state_after: no goals
Theorem: Cardinal.lt_one_iff_zero
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simpa using lt_succ_bot_iff (a := c)
state_before: α β : Type u
c : Cardinal.{u_1}
⊢ c < 1 ↔ c = 0
state_after: no goals
Theorem: Real.tan_eq_zero_iff'
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: revert hθ
state_before: θ : ℝ
hθ : cos θ ≠ 0
⊢ tan θ = 0 ↔ ∃ k, ↑k * π = θ
state_after: θ : ℝ
⊢ cos θ ≠ 0 → (tan θ = 0 ↔ ∃ k, ↑k * π = θ)

tactic: exact_mod_cast @Complex.tan_eq_zero_iff' θ
state_before: θ : ℝ
⊢ cos θ ≠ 0 → (tan θ = 0 ↔ ∃ k, ↑k * π = θ)
state_after: no goals
Theorem: LinearMap.ker_dualMap_eq_dualCoannihilator_range
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext x
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
⊢ ker f.dualMap = (range (Dual.eval R M' ∘ₗ f)).dualCoannihilator
state_after: case h
R : Type u_1
M : Type u_2
M' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
x : Dual R M'
⊢ x ∈ ker f.dualMap ↔ x ∈ (range (Dual.eval R M' ∘ₗ f)).dualCoannihilator

tactic: simp [ext_iff (f := dualMap f x)]
state_before: case h
R : Type u_1
M : Type u_2
M' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
x : Dual R M'
⊢ x ∈ ker f.dualMap ↔ x ∈ (range (Dual.eval R M' ∘ₗ f)).dualCoannihilator
state_after: no goals