1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.foldl_argAux_eq_none
File: Mathlib/Data/List/MinMax.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
inst✝ : DecidableRel r
l : List α
o : Option α
a m : α
⊢ foldl (argAux r) o [] = none ↔ [] = [] ∧ o = none
state_after: no goals

tactic: simp only [foldl_append, foldl_cons, argAux, foldl_nil, append_eq_nil, and_false, false_and,
  iff_false]
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
inst✝ : DecidableRel r
l : List α
o : Option α
a m : α
tl : List α
hd : α
⊢ (foldl (argAux r) o tl = none ↔ tl = [] ∧ o = none) →
    (foldl (argAux r) o (tl ++ [hd]) = none ↔ tl ++ [hd] = [] ∧ o = none)
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
inst✝ : DecidableRel r
l : List α
o : Option α
a m : α
tl : List α
hd : α
⊢ (foldl (argAux r) o tl = none ↔ tl = [] ∧ o = none) →
    ¬Option.rec (some hd) (fun val => if r hd val then some hd else some val) (foldl (argAux r) o tl) = none

tactic: cases foldl (argAux r) o tl <;> simp
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
inst✝ : DecidableRel r
l : List α
o : Option α
a m : α
tl : List α
hd : α
⊢ (foldl (argAux r) o tl = none ↔ tl = [] ∧ o = none) →
    ¬Option.rec (some hd) (fun val => if r hd val then some hd else some val) (foldl (argAux r) o tl) = none
state_after: case some
α : Type u_1
β : Type u_2
r : α → α → Prop
inst✝ : DecidableRel r
l : List α
o : Option α
a m : α
tl : List α
hd val✝ : α
⊢ (tl = [] → ¬o = none) → ¬(if r hd val✝ then some hd else some val✝) = none

tactic: try split_ifs <;> simp
state_before: case some
α : Type u_1
β : Type u_2
r : α → α → Prop
inst✝ : DecidableRel r
l : List α
o : Option α
a m : α
tl : List α
hd val✝ : α
⊢ (tl = [] → ¬o = none) → ¬(if r hd val✝ then some hd else some val✝) = none
state_after: no goals

tactic: split_ifs <;> simp
state_before: case some
α : Type u_1
β : Type u_2
r : α → α → Prop
inst✝ : DecidableRel r
l : List α
o : Option α
a m : α
tl : List α
hd val✝ : α
⊢ (tl = [] → ¬o = none) → ¬(if r hd val✝ then some hd else some val✝) = none
state_after: no goals
Theorem: Function.star_sum_elim
File: Mathlib/Algebra/Star/Pi.lean

tactic: ext x
state_before: I✝ : Type u
f : I✝ → Type v
I : Type u_1
J : Type u_2
α : Type u_3
x : I → α
y : J → α
inst✝ : Star α
⊢ star (Sum.elim x y) = Sum.elim (star x) (star y)
state_after: case h
I✝ : Type u
f : I✝ → Type v
I : Type u_1
J : Type u_2
α : Type u_3
x✝ : I → α
y : J → α
inst✝ : Star α
x : I ⊕ J
⊢ star (Sum.elim x✝ y) x = Sum.elim (star x✝) (star y) x

tactic: cases x <;> simp only [Pi.star_apply, Sum.elim_inl, Sum.elim_inr]
state_before: case h
I✝ : Type u
f : I✝ → Type v
I : Type u_1
J : Type u_2
α : Type u_3
x✝ : I → α
y : J → α
inst✝ : Star α
x : I ⊕ J
⊢ star (Sum.elim x✝ y) x = Sum.elim (star x✝) (star y) x
state_after: no goals
Theorem: Set.MulAntidiagonal.fst_eq_fst_iff_snd_eq_snd
File: Mathlib/Data/Set/MulAntidiagonal.lean

tactic: rw [← h]
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(s.mulAntidiagonal t a)
h : (↑x).1 = (↑y).1
⊢ a = (↑y).1 * (↑x).2
state_after: α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(s.mulAntidiagonal t a)
h : (↑x).1 = (↑y).1
⊢ a = (↑x).1 * (↑x).2

tactic: exact x.2.2.2.symm
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(s.mulAntidiagonal t a)
h : (↑x).1 = (↑y).1
⊢ a = (↑x).1 * (↑x).2
state_after: no goals

tactic: rw [← h]
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(s.mulAntidiagonal t a)
h : (↑x).2 = (↑y).2
⊢ a = (↑x).1 * (↑y).2
state_after: α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(s.mulAntidiagonal t a)
h : (↑x).2 = (↑y).2
⊢ a = (↑x).1 * (↑x).2

tactic: exact x.2.2.2.symm
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s t : Set α
a : α
x y : ↑(s.mulAntidiagonal t a)
h : (↑x).2 = (↑y).2
⊢ a = (↑x).1 * (↑x).2
state_after: no goals
Theorem: Matrix.det_conj
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← h.unit_spec, ← coe_units_inv, det_units_conj]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A B : Matrix n n α
inst✝² : Fintype m
inst✝¹ : DecidableEq m
inst✝ : CommRing α
M : Matrix m m α
h : IsUnit M
N : Matrix m m α
⊢ (M * N * M⁻¹).det = N.det
state_after: no goals
Theorem: Nat.add_eq_left
File: Mathlib/Data/Nat/Defs.lean

tactic: omega
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ a + b = a ↔ b = 0
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.dblX_of_Z_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: linear_combination (norm := (rw [dblX, dblU_of_Z_eq_zero hPz, negY_of_Z_eq_zero hPz, hPz]; ring1))
  -8 * P x * (equation_of_Z_eq_zero hPz).mp hP
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ W'.dblX P = (P x ^ 2) ^ 2
state_after: no goals

tactic: rw [dblX, dblU_of_Z_eq_zero hPz, negY_of_Z_eq_zero hPz, hPz]
state_before: case a
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ W'.dblX P - (P x ^ 2) ^ 2 - (-8 * P x * P y ^ 2 - -8 * P x * P x ^ 3) = 0
state_after: case a
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ (-3 * P x ^ 2) ^ 2 - W'.a₁ * (-3 * P x ^ 2) * 0 * (P y - -P y) - W'.a₂ * 0 ^ 2 * (P y - -P y) ^ 2 -
          2 * P x * (P y - -P y) ^ 2 -
        (P x ^ 2) ^ 2 -
      (-8 * P x * P y ^ 2 - -8 * P x * P x ^ 3) =
    0

tactic: ring1
state_before: case a
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ (-3 * P x ^ 2) ^ 2 - W'.a₁ * (-3 * P x ^ 2) * 0 * (P y - -P y) - W'.a₂ * 0 ^ 2 * (P y - -P y) ^ 2 -
          2 * P x * (P y - -P y) ^ 2 -
        (P x ^ 2) ^ 2 -
      (-8 * P x * P y ^ 2 - -8 * P x * P x ^ 3) =
    0
state_after: no goals
Theorem: AkraBazziRecurrence.exists_eventually_const_mul_le_r
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: have gt_zero : 0 < b (min_bi b) := R.b_pos (min_bi b)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∃ c ∈ Set.Ioo 0 1, ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), c * ↑n ≤ ↑(r i n)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
gt_zero : 0 < b (min_bi b)
⊢ ∃ c ∈ Set.Ioo 0 1, ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), c * ↑n ≤ ↑(r i n)

tactic: exact ⟨b (min_bi b) / 2, ⟨⟨by positivity, R.bi_min_div_two_lt_one⟩, R.eventually_bi_mul_le_r⟩⟩
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
gt_zero : 0 < b (min_bi b)
⊢ ∃ c ∈ Set.Ioo 0 1, ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), c * ↑n ≤ ↑(r i n)
state_after: no goals

tactic: positivity
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
gt_zero : 0 < b (min_bi b)
⊢ 0 < b (min_bi b) / 2
state_after: no goals
Theorem: Complex.log_conj_eq_ite
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp_rw [log, abs_conj, arg_conj, map_add, map_mul, conj_ofReal]
state_before: x : ℂ
⊢ log ((starRingEnd ℂ) x) = if x.arg = π then log x else (starRingEnd ℂ) (log x)
state_after: x : ℂ
⊢ ↑(Real.log (abs x)) + ↑(if x.arg = π then π else -x.arg) * I =
    if x.arg = π then ↑(Real.log (abs x)) + ↑x.arg * I else ↑(Real.log (abs x)) + ↑x.arg * (starRingEnd ℂ) I

tactic: split_ifs with hx
state_before: x : ℂ
⊢ ↑(Real.log (abs x)) + ↑(if x.arg = π then π else -x.arg) * I =
    if x.arg = π then ↑(Real.log (abs x)) + ↑x.arg * I else ↑(Real.log (abs x)) + ↑x.arg * (starRingEnd ℂ) I
state_after: case pos
x : ℂ
hx : x.arg = π
⊢ ↑(Real.log (abs x)) + ↑π * I = ↑(Real.log (abs x)) + ↑x.arg * I

case neg
x : ℂ
hx : ¬x.arg = π
⊢ ↑(Real.log (abs x)) + ↑(-x.arg) * I = ↑(Real.log (abs x)) + ↑x.arg * (starRingEnd ℂ) I

tactic: simp_rw [ofReal_neg, conj_I, mul_neg, neg_mul]
state_before: case neg
x : ℂ
hx : ¬x.arg = π
⊢ ↑(Real.log (abs x)) + ↑(-x.arg) * I = ↑(Real.log (abs x)) + ↑x.arg * (starRingEnd ℂ) I
state_after: no goals

tactic: rw [hx]
state_before: case pos
x : ℂ
hx : x.arg = π
⊢ ↑(Real.log (abs x)) + ↑π * I = ↑(Real.log (abs x)) + ↑x.arg * I
state_after: no goals
Theorem: inv_mul_lt_one_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [mul_one]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ b < a * 1 ↔ b < a
state_after: no goals
Theorem: SetTheory.PGame.Impartial.lf_zero_iff
File: Mathlib/SetTheory/Game/Impartial.lean

tactic: rw [← zero_lf_neg_iff, lf_congr_right (neg_equiv_self G)]
state_before: G✝ : PGame
inst✝¹ : G✝.Impartial
G : PGame
inst✝ : G.Impartial
⊢ G ⧏ 0 ↔ 0 ⧏ G
state_after: no goals
Theorem: le_dimH_of_hausdorffMeasure_eq_top
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

tactic: rw [dimH_def]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
d : ℝ≥0
h : μH[↑d] s = ⊤
⊢ ↑d ≤ dimH s
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
d : ℝ≥0
h : μH[↑d] s = ⊤
⊢ ↑d ≤ ⨆ d, ⨆ (_ : μH[↑d] s = ⊤), ↑d

tactic: exact le_iSup₂ (α := ℝ≥0∞) d h
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
d : ℝ≥0
h : μH[↑d] s = ⊤
⊢ ↑d ≤ ⨆ d, ⨆ (_ : μH[↑d] s = ⊤), ↑d
state_after: no goals
Theorem: FirstOrder.Ring.realize_mul
File: Mathlib/ModelTheory/Algebra/Ring/Basic.lean

tactic: simp [mul_def, funMap_mul]
state_before: α : Type u_1
R : Type u_2
inst✝⁵ : Add R
inst✝⁴ : Mul R
inst✝³ : Neg R
inst✝² : One R
inst✝¹ : Zero R
inst✝ : CompatibleRing R
x y : ring.Term α
v : α → R
⊢ Term.realize v (x * y) = Term.realize v x * Term.realize v y
state_after: no goals
Theorem: MeasureTheory.measure_trim_toMeasurable_eq_zero
File: Mathlib/MeasureTheory/Measure/Trim.lean

tactic: rwa [@measure_toMeasurable _ m]
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
hm : m ≤ m0
hs : (μ.trim hm) s = 0
⊢ (μ.trim hm) (toMeasurable (μ.trim hm) s) = 0
state_after: no goals
Theorem: Matrix.toLinearMapRight'_one
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: ext
state_before: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
⊢ toLinearMapRight' 1 = LinearMap.id
state_after: case h.h.h
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
i✝ x✝ : m
⊢ (toLinearMapRight' 1 ∘ₗ single i✝) 1 x✝ = (LinearMap.id ∘ₗ single i✝) 1 x✝

tactic: simp [LinearMap.one_apply, stdBasis_apply]
state_before: case h.h.h
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
i✝ x✝ : m
⊢ (toLinearMapRight' 1 ∘ₗ single i✝) 1 x✝ = (LinearMap.id ∘ₗ single i✝) 1 x✝
state_after: no goals
Theorem: unitInterval.qRight_one_right
File: Mathlib/Topology/Homotopy/HSpaces.lean

tactic: rw [qRight]
state_before: t : ↑I
⊢ qRight (t, 1) = Set.projIcc 0 1 ⋯ ↑t
state_after: t : ↑I
⊢ Set.projIcc 0 1 qRight.proof_1 (2 * ↑(t, 1).1 / (1 + ↑(t, 1).2)) = Set.projIcc 0 1 ⋯ ↑t

tactic: norm_num
state_before: t : ↑I
⊢ Set.projIcc 0 1 qRight.proof_1 (2 * ↑(t, 1).1 / (1 + ↑(t, 1).2)) = Set.projIcc 0 1 ⋯ ↑t
state_after: no goals
Theorem: image_gaugeRescaleHomeomorph_interior
File: Mathlib/Analysis/Convex/GaugeRescale.lean

tactic: rw [← Homeomorph.preimage_symm, ← image_subset_iff]
state_before: E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module ℝ E
inst✝³ : TopologicalSpace E
inst✝² : T1Space E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s✝ t✝ s t : Set E
hsc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
hsb : IsVonNBounded ℝ s
htc : Convex ℝ t
ht₀ : t ∈ 𝓝 0
htb : IsVonNBounded ℝ t
⊢ interior t ⊆ ⇑(gaugeRescaleHomeomorph s t hsc hs₀ hsb htc ht₀ htb) '' interior s
state_after: E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module ℝ E
inst✝³ : TopologicalSpace E
inst✝² : T1Space E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s✝ t✝ s t : Set E
hsc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
hsb : IsVonNBounded ℝ s
htc : Convex ℝ t
ht₀ : t ∈ 𝓝 0
htb : IsVonNBounded ℝ t
⊢ ⇑(gaugeRescaleHomeomorph s t hsc hs₀ hsb htc ht₀ htb).symm '' interior t ⊆ interior s

tactic: exact (mapsTo_gaugeRescale_interior hs₀ hsc).image_subset
state_before: E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module ℝ E
inst✝³ : TopologicalSpace E
inst✝² : T1Space E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousSMul ℝ E
s✝ t✝ s t : Set E
hsc : Convex ℝ s
hs₀ : s ∈ 𝓝 0
hsb : IsVonNBounded ℝ s
htc : Convex ℝ t
ht₀ : t ∈ 𝓝 0
htb : IsVonNBounded ℝ t
⊢ ⇑(gaugeRescaleHomeomorph s t hsc hs₀ hsb htc ht₀ htb).symm '' interior t ⊆ interior s
state_after: no goals
Theorem: MvPolynomial.psum_one
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

tactic: simp only [psum, _root_.pow_one]
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝² : CommSemiring R
inst✝¹ : Fintype σ
inst✝ : Fintype τ
⊢ psum σ R 1 = ∑ i : σ, X i
state_after: no goals
Theorem: GromovHausdorff.GHSpace.toGHSpace_rep
File: Mathlib/Topology/MetricSpace/GromovHausdorff.lean

tactic: change toGHSpace (Quot.out p : NonemptyCompacts ℓ_infty_ℝ) = p
state_before: p : GHSpace
⊢ toGHSpace p.Rep = p
state_after: p : GHSpace
⊢ toGHSpace ↥(Quot.out p) = p

tactic: rw [← eq_toGHSpace]
state_before: p : GHSpace
⊢ toGHSpace ↥(Quot.out p) = p
state_after: p : GHSpace
⊢ ⟦Quot.out p⟧ = p

tactic: exact Quot.out_eq p
state_before: p : GHSpace
⊢ ⟦Quot.out p⟧ = p
state_after: no goals
Theorem: abs_sub_sq
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: rw [abs_mul_abs_self]
state_before: α : Type u_1
inst✝ : LinearOrderedCommRing α
a✝ b✝ c d a b : α
⊢ |a - b| * |a - b| = a * a + b * b - (1 + 1) * a * b
state_after: α : Type u_1
inst✝ : LinearOrderedCommRing α
a✝ b✝ c d a b : α
⊢ (a - b) * (a - b) = a * a + b * b - (1 + 1) * a * b

tactic: simp only [mul_add, add_comm, add_left_comm, mul_comm, sub_eq_add_neg, mul_one, mul_neg,
  neg_add_rev, neg_neg, add_assoc]
state_before: α : Type u_1
inst✝ : LinearOrderedCommRing α
a✝ b✝ c d a b : α
⊢ (a - b) * (a - b) = a * a + b * b - (1 + 1) * a * b
state_after: no goals
Theorem: TruncatedWittVector.commutes_symm
File: Mathlib/RingTheory/WittVector/Compare.lean

tactic: ext
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
⊢ (zmodEquivTrunc p n).symm.toRingHom.comp (truncate hm) =
    (ZMod.castHom ⋯ (ZMod (p ^ n))).comp (zmodEquivTrunc p m).symm.toRingHom
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x✝ : TruncatedWittVector p m (ZMod p)
⊢ ((zmodEquivTrunc p n).symm.toRingHom.comp (truncate hm)) x✝ =
    ((ZMod.castHom ⋯ (ZMod (p ^ n))).comp (zmodEquivTrunc p m).symm.toRingHom) x✝

tactic: apply commutes_symm'
state_before: case a
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x✝ : TruncatedWittVector p m (ZMod p)
⊢ ((zmodEquivTrunc p n).symm.toRingHom.comp (truncate hm)) x✝ =
    ((ZMod.castHom ⋯ (ZMod (p ^ n))).comp (zmodEquivTrunc p m).symm.toRingHom) x✝
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.OpenCover.ι_glueMorphisms
File: Mathlib/AlgebraicGeometry/Gluing.lean

tactic: rw [← ι_fromGlued, Category.assoc]
state_before: X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f : (x : 𝒰.J) → 𝒰.obj x ⟶ Y
hf : ∀ (x y : 𝒰.J), pullback.fst ≫ f x = pullback.snd ≫ f y
x : 𝒰.J
⊢ 𝒰.map x ≫ 𝒰.glueMorphisms f hf = f x
state_after: X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f : (x : 𝒰.J) → 𝒰.obj x ⟶ Y
hf : ∀ (x y : 𝒰.J), pullback.fst ≫ f x = pullback.snd ≫ f y
x : 𝒰.J
⊢ 𝒰.gluedCover.ι x ≫ 𝒰.fromGlued ≫ 𝒰.glueMorphisms f hf = f x

tactic: erw [IsIso.hom_inv_id_assoc, Multicoequalizer.π_desc]
state_before: X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f : (x : 𝒰.J) → 𝒰.obj x ⟶ Y
hf : ∀ (x y : 𝒰.J), pullback.fst ≫ f x = pullback.snd ≫ f y
x : 𝒰.J
⊢ 𝒰.gluedCover.ι x ≫ 𝒰.fromGlued ≫ 𝒰.glueMorphisms f hf = f x
state_after: no goals
Theorem: TendstoUniformlyOn.congr_right
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: filter_upwards [hf u hu] with i hi a ha using hfg ha ▸ hi a ha
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g✝ : ι → α
g : α → β
hf : TendstoUniformlyOn F f p s
hfg : EqOn f g s
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (g x, F n x) ∈ u
state_after: no goals
Theorem: dist_one_right
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [dist_eq_norm_div, div_one]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
a : E
⊢ dist a 1 = ‖a‖
state_after: no goals
Theorem: Module.isTorsionBy_iff_torsionBy_eq_top
File: Mathlib/Algebra/Module/Torsion.lean

tactic: rw [← torsionBySet_singleton_eq, ← isTorsionBySet_singleton_iff,
  isTorsionBySet_iff_torsionBySet_eq_top]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
⊢ IsTorsionBy R M a ↔ torsionBy R M a = ⊤
state_after: no goals
Theorem: Int.even_add_one
File: Mathlib/Algebra/Group/Int.lean

tactic: simp [even_add]
state_before: u v m n : ℤ
⊢ Even (n + 1) ↔ ¬Even n
state_after: no goals
Theorem: List.rotate'_cons_succ
File: Mathlib/Data/List/Rotate.lean

tactic: simp [rotate']
state_before: α : Type u
l : List α
a : α
n : ℕ
⊢ (a :: l).rotate' n.succ = (l ++ [a]).rotate' n
state_after: no goals
Theorem: Nat.find_comp_succ
File: Mathlib/Data/Nat/Defs.lean

tactic: refine (find_eq_iff _).2 ⟨Nat.find_spec h₂, fun n hn ↦ ?_⟩
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
⊢ Nat.find h₁ = Nat.find h₂ + 1
state_after: a b c d m n✝ k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
n : ℕ
hn : n < Nat.find h₂ + 1
⊢ ¬p n

tactic: cases n
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
n : ℕ
hn : n < Nat.find h₂ + 1
⊢ ¬p n
state_after: case zero
a b c d m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
hn : 0 < Nat.find h₂ + 1
⊢ ¬p 0

case succ
a b c d m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
n✝ : ℕ
hn : n✝ + 1 < Nat.find h₂ + 1
⊢ ¬p (n✝ + 1)

tactic: exacts [h0, @Nat.find_min (fun n ↦ p (n + 1)) _ h₂ _ (succ_lt_succ_iff.1 hn)]
state_before: case zero
a b c d m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
hn : 0 < Nat.find h₂ + 1
⊢ ¬p 0

case succ
a b c d m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
n✝ : ℕ
hn : n✝ + 1 < Nat.find h₂ + 1
⊢ ¬p (n✝ + 1)
state_after: no goals
Theorem: Zlattice.covolume_ne_zero
File: Mathlib/Algebra/Module/Zlattice/Covolume.lean

tactic: rw [covolume_eq_measure_fundamentalDomain L μ (isAddFundamentalDomain (Free.chooseBasis ℤ L) μ),
  ENNReal.toReal_ne_zero]
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : MeasurableSpace E
inst✝³ : BorelSpace E
L : AddSubgroup E
inst✝² : DiscreteTopology ↥L
inst✝¹ : IsZlattice ℝ L
μ : autoParam (Measure E) _auto✝
inst✝ : Measure.IsAddHaarMeasure μ
⊢ covolume L μ ≠ 0
state_after: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : MeasurableSpace E
inst✝³ : BorelSpace E
L : AddSubgroup E
inst✝² : DiscreteTopology ↥L
inst✝¹ : IsZlattice ℝ L
μ : autoParam (Measure E) _auto✝
inst✝ : Measure.IsAddHaarMeasure μ
⊢ μ (Zspan.fundamentalDomain (Basis.ofZlatticeBasis ℝ L (Free.chooseBasis ℤ ↥L))) ≠ 0 ∧
    μ (Zspan.fundamentalDomain (Basis.ofZlatticeBasis ℝ L (Free.chooseBasis ℤ ↥L))) ≠ ⊤

tactic: refine ⟨Zspan.measure_fundamentalDomain_ne_zero _, ne_of_lt ?_⟩
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : MeasurableSpace E
inst✝³ : BorelSpace E
L : AddSubgroup E
inst✝² : DiscreteTopology ↥L
inst✝¹ : IsZlattice ℝ L
μ : autoParam (Measure E) _auto✝
inst✝ : Measure.IsAddHaarMeasure μ
⊢ μ (Zspan.fundamentalDomain (Basis.ofZlatticeBasis ℝ L (Free.chooseBasis ℤ ↥L))) ≠ 0 ∧
    μ (Zspan.fundamentalDomain (Basis.ofZlatticeBasis ℝ L (Free.chooseBasis ℤ ↥L))) ≠ ⊤
state_after: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : MeasurableSpace E
inst✝³ : BorelSpace E
L : AddSubgroup E
inst✝² : DiscreteTopology ↥L
inst✝¹ : IsZlattice ℝ L
μ : autoParam (Measure E) _auto✝
inst✝ : Measure.IsAddHaarMeasure μ
⊢ μ (Zspan.fundamentalDomain (Basis.ofZlatticeBasis ℝ L (Free.chooseBasis ℤ ↥L))) < ⊤

tactic: exact Bornology.IsBounded.measure_lt_top (Zspan.fundamentalDomain_isBounded _)
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : MeasurableSpace E
inst✝³ : BorelSpace E
L : AddSubgroup E
inst✝² : DiscreteTopology ↥L
inst✝¹ : IsZlattice ℝ L
μ : autoParam (Measure E) _auto✝
inst✝ : Measure.IsAddHaarMeasure μ
⊢ μ (Zspan.fundamentalDomain (Basis.ofZlatticeBasis ℝ L (Free.chooseBasis ℤ ↥L))) < ⊤
state_after: no goals