1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Mathlib.Tactic.ComputeDegree.coeff_pow_of_natDegree_le_of_eq_ite'
File: Mathlib/Tactic/ComputeDegree.lean

tactic: split_ifs with h
state_before: R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
⊢ (p ^ m).coeff o = if o = m * n then a ^ m else 0
state_after: case pos
R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : o = m * n
⊢ (p ^ m).coeff o = a ^ m

case neg
R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : ¬o = m * n
⊢ (p ^ m).coeff o = 0

tactic: subst h h_pow_bas
state_before: case pos
R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : o = m * n
⊢ (p ^ m).coeff o = a ^ m
state_after: case pos
R : Type u_1
inst✝ : Semiring R
m n : ℕ
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ m * n
⊢ (p ^ m).coeff (m * n) = p.coeff n ^ m

tactic: exact coeff_pow_of_natDegree_le ‹_›
state_before: case pos
R : Type u_1
inst✝ : Semiring R
m n : ℕ
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ m * n
⊢ (p ^ m).coeff (m * n) = p.coeff n ^ m
state_after: no goals

tactic: apply coeff_eq_zero_of_natDegree_lt
state_before: case neg
R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : ¬o = m * n
⊢ (p ^ m).coeff o = 0
state_after: case neg.h
R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : ¬o = m * n
⊢ (p ^ m).natDegree < o

tactic: apply lt_of_le_of_lt ?_ (lt_of_le_of_ne ‹_› ?_)
state_before: case neg.h
R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : ¬o = m * n
⊢ (p ^ m).natDegree < o
state_after: R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : ¬o = m * n
⊢ (p ^ m).natDegree ≤ m * n

R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : ¬o = m * n
⊢ m * n ≠ o

tactic: exact natDegree_pow_le_of_le m ‹_›
state_before: R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : ¬o = m * n
⊢ (p ^ m).natDegree ≤ m * n
state_after: no goals

tactic: exact Iff.mp ne_comm h
state_before: R : Type u_1
inst✝ : Semiring R
m n o : ℕ
a : R
p : R[X]
h_pow : p.natDegree ≤ n
h_exp : m * n ≤ o
h_pow_bas : p.coeff n = a
h : ¬o = m * n
⊢ m * n ≠ o
state_after: no goals
Theorem: MeasureTheory.tilted_congr
File: Mathlib/MeasureTheory/Measure/Tilted.lean

tactic: have h_int_eq : ∫ x, exp (f x) ∂μ = ∫ x, exp (g x) ∂μ := by
  refine integral_congr_ae ?_
  filter_upwards [hfg] with x hx
  rw [hx]
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
⊢ μ.tilted f = μ.tilted g
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
h_int_eq : ∫ (x : α), rexp (f x) ∂μ = ∫ (x : α), rexp (g x) ∂μ
⊢ μ.tilted f = μ.tilted g

tactic: refine withDensity_congr_ae ?_
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
h_int_eq : ∫ (x : α), rexp (f x) ∂μ = ∫ (x : α), rexp (g x) ∂μ
⊢ μ.tilted f = μ.tilted g
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
h_int_eq : ∫ (x : α), rexp (f x) ∂μ = ∫ (x : α), rexp (g x) ∂μ
⊢ (fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)) =ᶠ[ae μ] fun x =>
    ENNReal.ofReal (rexp (g x) / ∫ (x : α), rexp (g x) ∂μ)

tactic: filter_upwards [hfg] with x hx
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
h_int_eq : ∫ (x : α), rexp (f x) ∂μ = ∫ (x : α), rexp (g x) ∂μ
⊢ (fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)) =ᶠ[ae μ] fun x =>
    ENNReal.ofReal (rexp (g x) / ∫ (x : α), rexp (g x) ∂μ)
state_after: case h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
h_int_eq : ∫ (x : α), rexp (f x) ∂μ = ∫ (x : α), rexp (g x) ∂μ
x : α
hx : f x = g x
⊢ ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) = ENNReal.ofReal (rexp (g x) / ∫ (x : α), rexp (g x) ∂μ)

tactic: rw [h_int_eq, hx]
state_before: case h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
h_int_eq : ∫ (x : α), rexp (f x) ∂μ = ∫ (x : α), rexp (g x) ∂μ
x : α
hx : f x = g x
⊢ ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) = ENNReal.ofReal (rexp (g x) / ∫ (x : α), rexp (g x) ∂μ)
state_after: no goals

tactic: refine integral_congr_ae ?_
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
⊢ ∫ (x : α), rexp (f x) ∂μ = ∫ (x : α), rexp (g x) ∂μ
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
⊢ (fun x => rexp (f x)) =ᶠ[ae μ] fun x => rexp (g x)

tactic: filter_upwards [hfg] with x hx
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
⊢ (fun x => rexp (f x)) =ᶠ[ae μ] fun x => rexp (g x)
state_after: case h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
x : α
hx : f x = g x
⊢ rexp (f x) = rexp (g x)

tactic: rw [hx]
state_before: case h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f g : α → ℝ
hfg : f =ᶠ[ae μ] g
x : α
hx : f x = g x
⊢ rexp (f x) = rexp (g x)
state_after: no goals
Theorem: Matrix.fromBlocks_eq_of_invertible₁₁
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

tactic: simp only [fromBlocks_multiply, Matrix.mul_zero, Matrix.zero_mul, add_zero, zero_add,
  Matrix.one_mul, Matrix.mul_one, invOf_mul_self, Matrix.mul_invOf_self_assoc,
  Matrix.mul_invOf_mul_self_cancel, Matrix.mul_assoc, add_sub_cancel]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁷ : Fintype l
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A : Matrix m m α
B : Matrix m n α
C : Matrix l m α
D : Matrix l n α
inst✝ : Invertible A
⊢ fromBlocks A B C D = fromBlocks 1 0 (C * ⅟A) 1 * fromBlocks A 0 0 (D - C * ⅟A * B) * fromBlocks 1 (⅟A * B) 0 1
state_after: no goals
Theorem: DFinsupp.neLocus_self_sub_left
File: Mathlib/Data/DFinsupp/NeLocus.lean

tactic: rw [neLocus_comm, neLocus_self_sub_right]
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ (f - g).neLocus f = g.support
state_after: no goals
Theorem: Nat.pair_lt_pair_right
File: Mathlib/Data/Nat/Pairing.lean

tactic: by_cases h₁ : a < b₁ <;> simp [pair, h₁, Nat.add_assoc]
state_before: a b₁ b₂ : ℕ
h : b₁ < b₂
⊢ pair a b₁ < pair a b₂
state_after: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : a < b₁
⊢ b₁ * b₁ + a < if a < b₂ then b₂ * b₂ + a else a * a + (a + b₂)

case neg
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : ¬a < b₁
⊢ a * a + (a + b₁) < if a < b₂ then b₂ * b₂ + a else a * a + (a + b₂)

tactic: simp [pair, lt_trans h₁ h, h]
state_before: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : a < b₁
⊢ b₁ * b₁ + a < if a < b₂ then b₂ * b₂ + a else a * a + (a + b₂)
state_after: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : a < b₁
⊢ b₁ * b₁ < b₂ * b₂

tactic: exact mul_self_lt_mul_self h
state_before: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : a < b₁
⊢ b₁ * b₁ < b₂ * b₂
state_after: no goals

tactic: by_cases h₂ : a < b₂ <;> simp [pair, h₂, h]
state_before: case neg
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : ¬a < b₁
⊢ a * a + (a + b₁) < if a < b₂ then b₂ * b₂ + a else a * a + (a + b₂)
state_after: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : ¬a < b₁
h₂ : a < b₂
⊢ a * a + (a + b₁) < b₂ * b₂ + a

tactic: simp? at h₁ says simp only [not_lt] at h₁
state_before: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : ¬a < b₁
h₂ : a < b₂
⊢ a * a + (a + b₁) < b₂ * b₂ + a
state_after: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₂ : a < b₂
h₁ : b₁ ≤ a
⊢ a * a + (a + b₁) < b₂ * b₂ + a

tactic: rw [Nat.add_comm, Nat.add_comm _ a, Nat.add_assoc, Nat.add_lt_add_iff_left]
state_before: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₂ : a < b₂
h₁ : b₁ ≤ a
⊢ a * a + (a + b₁) < b₂ * b₂ + a
state_after: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₂ : a < b₂
h₁ : b₁ ≤ a
⊢ b₁ + a * a < b₂ * b₂

tactic: rwa [Nat.add_comm, ← sqrt_lt, sqrt_add_eq]
state_before: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₂ : a < b₂
h₁ : b₁ ≤ a
⊢ b₁ + a * a < b₂ * b₂
state_after: case pos.h
a b₁ b₂ : ℕ
h : b₁ < b₂
h₂ : a < b₂
h₁ : b₁ ≤ a
⊢ b₁ ≤ a + a

tactic: exact le_trans h₁ (Nat.le_add_left _ _)
state_before: case pos.h
a b₁ b₂ : ℕ
h : b₁ < b₂
h₂ : a < b₂
h₁ : b₁ ≤ a
⊢ b₁ ≤ a + a
state_after: no goals

tactic: simp only [not_lt] at h₁
state_before: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₁ : ¬a < b₁
h₂ : a < b₂
⊢ a * a + (a + b₁) < b₂ * b₂ + a
state_after: case pos
a b₁ b₂ : ℕ
h : b₁ < b₂
h₂ : a < b₂
h₁ : b₁ ≤ a
⊢ a * a + (a + b₁) < b₂ * b₂ + a
Theorem: List.reverse_foldl
File: Mathlib/Data/List/Basic.lean

tactic: rw [← foldr_reverse]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
⊢ (foldl (fun t h => h :: t) [] l).reverse = l
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
⊢ (foldr cons [] l.reverse).reverse = l

tactic: simp only [foldr_self_append, append_nil, reverse_reverse]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
⊢ (foldr cons [] l.reverse).reverse = l
state_after: no goals
Theorem: List.nodup_middle
File: Mathlib/Data/List/Nodup.lean

tactic: simp only [nodup_append, not_or, and_left_comm, and_assoc, nodup_cons, mem_append,
  disjoint_cons_right]
state_before: α : Type u
β : Type v
l l₁✝ l₂✝ : List α
r : α → α → Prop
a✝ b a : α
l₁ l₂ : List α
⊢ (l₁ ++ a :: l₂).Nodup ↔ (a :: (l₁ ++ l₂)).Nodup
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.eval_polynomialY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [polynomialY_eq]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ (eval P) W'.polynomialY = 2 * P y + W'.a₁ * P x * P z + W'.a₃ * P z ^ 3
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ (eval P) (C 2 * X y + C W'.a₁ * X x * X z + C W'.a₃ * X z ^ 3) = 2 * P y + W'.a₁ * P x * P z + W'.a₃ * P z ^ 3

tactic: eval_simp
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ (eval P) (C 2 * X y + C W'.a₁ * X x * X z + C W'.a₃ * X z ^ 3) = 2 * P y + W'.a₁ * P x * P z + W'.a₃ * P z ^ 3
state_after: no goals
Theorem: dist_mono_right_pi
File: Mathlib/Analysis/Normed/Order/UpperLower.lean

tactic: simpa only [dist_comm _ x] using dist_mono_left_pi (y := x)
state_before: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x y : ι → ℝ
δ : ℝ
⊢ MonotoneOn (dist x) (Ici x)
state_after: no goals
Theorem: List.mem_range'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [range', Nat.not_lt_zero]
state_before: m s step : Nat
⊢ m ∈ range' s 0 step ↔ ∃ i, i < 0 ∧ m = s + step * i
state_after: no goals

tactic: have h (i) : i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n := by cases i <;> simp [Nat.succ_le]
state_before: m s step n : Nat
⊢ m ∈ range' s (n + 1) step ↔ ∃ i, i < n + 1 ∧ m = s + step * i
state_after: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ m ∈ range' s (n + 1) step ↔ ∃ i, i < n + 1 ∧ m = s + step * i

tactic: simp [range', mem_range', Nat.lt_succ, h]
state_before: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ m ∈ range' s (n + 1) step ↔ ∃ i, i < n + 1 ∧ m = s + step * i
state_after: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a, (∃ j, a = j + 1 ∧ j < n) ∧ m = s + step * a

tactic: simp only [← exists_and_right, and_assoc]
state_before: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a, (∃ j, a = j + 1 ∧ j < n) ∧ m = s + step * a
state_after: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a x, a = x + 1 ∧ x < n ∧ m = s + step * a

tactic: rw [exists_comm]
state_before: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ a x, a = x + 1 ∧ x < n ∧ m = s + step * a
state_after: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ b a, a = b + 1 ∧ b < n ∧ m = s + step * a

tactic: simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
state_before: m s step n : Nat
h : ∀ (i : Nat), i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
⊢ (m = s ∨ ∃ i, i < n ∧ m = s + step + step * i) ↔ m = s ∨ ∃ b a, a = b + 1 ∧ b < n ∧ m = s + step * a
state_after: no goals

tactic: cases i <;> simp [Nat.succ_le]
state_before: m s step n i : Nat
⊢ i ≤ n ↔ i = 0 ∨ ∃ j, i = j.succ ∧ j < n
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.isCaratheodory_compl_iff
File: Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean

tactic: simpa using isCaratheodory_compl m h
state_before: α : Type u
m : OuterMeasure α
s s₁ s₂ : Set α
h : m.IsCaratheodory sᶜ
⊢ m.IsCaratheodory s
state_after: no goals
Theorem: CategoryTheory.Yoneda.obj_map_id
File: Mathlib/CategoryTheory/Yoneda.lean

tactic: dsimp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : { unop := X } ⟶ { unop := Y }
⊢ (yoneda.obj X).map f (𝟙 X) = (yoneda.map f.unop).app { unop := Y } (𝟙 Y)
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : { unop := X } ⟶ { unop := Y }
⊢ f.unop ≫ 𝟙 X = 𝟙 Y ≫ f.unop

tactic: simp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : { unop := X } ⟶ { unop := Y }
⊢ f.unop ≫ 𝟙 X = 𝟙 Y ≫ f.unop
state_after: no goals
Theorem: Filter.Realizer.ne_bot_iff
File: Mathlib/Data/Analysis/Filter.lean

tactic: rw [not_iff_comm, ← le_bot_iff, F.le_iff Realizer.bot, not_forall]
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
f : Filter α
F : f.Realizer
⊢ f ≠ ⊥ ↔ ∀ (a : F.σ), (F.F.f a).Nonempty
state_after: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
f : Filter α
F : f.Realizer
⊢ (∃ x, ¬(F.F.f x).Nonempty) ↔ ∀ (b : Realizer.bot.σ), ∃ a, F.F.f a ≤ Realizer.bot.F.f b

tactic: simp only [Set.not_nonempty_iff_eq_empty]
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
f : Filter α
F : f.Realizer
⊢ (∃ x, ¬(F.F.f x).Nonempty) ↔ ∀ (b : Realizer.bot.σ), ∃ a, F.F.f a ≤ Realizer.bot.F.f b
state_after: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
f : Filter α
F : f.Realizer
⊢ (∃ x, F.F.f x = ∅) ↔ ∀ (b : Realizer.bot.σ), ∃ a, F.F.f a ≤ Realizer.bot.F.f b

tactic: exact ⟨fun ⟨x, e⟩ _ ↦ ⟨x, le_of_eq e⟩, fun h ↦
  let ⟨x, h⟩ := h ()
  ⟨x, le_bot_iff.1 h⟩⟩
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
f : Filter α
F : f.Realizer
⊢ (∃ x, F.F.f x = ∅) ↔ ∀ (b : Realizer.bot.σ), ∃ a, F.F.f a ≤ Realizer.bot.F.f b
state_after: no goals
Theorem: Basis.repr_total
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rw [← b.coe_repr_symm]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
v : ι →₀ R
⊢ b.repr ((Finsupp.total ι M R ⇑b) v) = v
state_after: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
v : ι →₀ R
⊢ b.repr (↑b.repr.symm v) = v

tactic: exact b.repr.apply_symm_apply v
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
v : ι →₀ R
⊢ b.repr (↑b.repr.symm v) = v
state_after: no goals
Theorem: MeasureTheory.condexpInd_ae_eq_condexpIndSMul
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean

tactic: refine EventuallyEq.trans ?_ (condexpIndL1Fin_ae_eq_condexpIndSMul hm hs hμs x)
state_before: α : Type u_1
β : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹² : RCLike 𝕜
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
inst✝⁹ : NormedAddCommGroup F'
inst✝⁸ : NormedSpace 𝕜 F'
inst✝⁷ : NormedSpace ℝ F'
inst✝⁶ : CompleteSpace F'
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace ℝ G'
inst✝² : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝¹ : NormedSpace ℝ G
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
hs : MeasurableSet s
hμs : μ s ≠ ⊤
x : G
⊢ ↑↑((condexpInd G hm μ s) x) =ᶠ[ae μ] ↑↑(condexpIndSMul hm hs hμs x)
state_after: α : Type u_1
β : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹² : RCLike 𝕜
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
inst✝⁹ : NormedAddCommGroup F'
inst✝⁸ : NormedSpace 𝕜 F'
inst✝⁷ : NormedSpace ℝ F'
inst✝⁶ : CompleteSpace F'
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace ℝ G'
inst✝² : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝¹ : NormedSpace ℝ G
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
hs : MeasurableSet s
hμs : μ s ≠ ⊤
x : G
⊢ ↑↑((condexpInd G hm μ s) x) =ᶠ[ae μ] ↑↑(condexpIndL1Fin hm hs hμs x)

tactic: simp [condexpInd, condexpIndL1, hs, hμs]
state_before: α : Type u_1
β : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹² : RCLike 𝕜
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
inst✝⁹ : NormedAddCommGroup F'
inst✝⁸ : NormedSpace 𝕜 F'
inst✝⁷ : NormedSpace ℝ F'
inst✝⁶ : CompleteSpace F'
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace ℝ G'
inst✝² : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝¹ : NormedSpace ℝ G
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
hs : MeasurableSet s
hμs : μ s ≠ ⊤
x : G
⊢ ↑↑((condexpInd G hm μ s) x) =ᶠ[ae μ] ↑↑(condexpIndL1Fin hm hs hμs x)
state_after: no goals
Theorem: StrictConcaveOn.slope_lt_of_hasDerivAt
File: Mathlib/Analysis/Convex/Deriv.lean

tactic: simpa only [Pi.neg_def, slope_neg, neg_neg] using
  neg_lt_neg (hfc.neg.lt_slope_of_hasDerivAt hx hy hxy hfd.neg)
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : StrictConcaveOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hfd : HasDerivAt f f' x
⊢ slope f x y < f'
state_after: no goals
Theorem: Finset.shatterer_eq
File: Mathlib/Combinatorics/SetFamily/Shatter.lean

tactic: refine ⟨fun h ↦ ?_, fun h ↦ Subset.antisymm (fun s hs ↦ ?_) <| subset_shatterer h⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
⊢ 𝒜.shatterer = 𝒜 ↔ IsLowerSet ↑𝒜
state_after: case refine_1
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.shatterer = 𝒜
⊢ IsLowerSet ↑𝒜

case refine_2
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ t : Finset α
a : α
n : ℕ
h : IsLowerSet ↑𝒜
s : Finset α
hs : s ∈ 𝒜.shatterer
⊢ s ∈ 𝒜

tactic: rw [← h]
state_before: case refine_1
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.shatterer = 𝒜
⊢ IsLowerSet ↑𝒜
state_after: case refine_1
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.shatterer = 𝒜
⊢ IsLowerSet ↑𝒜.shatterer

tactic: exact isLowerSet_shatterer _
state_before: case refine_1
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜.shatterer = 𝒜
⊢ IsLowerSet ↑𝒜.shatterer
state_after: no goals

tactic: obtain ⟨t, ht, hst⟩ := (mem_shatterer.1 hs).exists_superset
state_before: case refine_2
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ t : Finset α
a : α
n : ℕ
h : IsLowerSet ↑𝒜
s : Finset α
hs : s ∈ 𝒜.shatterer
⊢ s ∈ 𝒜
state_after: case refine_2.intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ t✝ : Finset α
a : α
n : ℕ
h : IsLowerSet ↑𝒜
s : Finset α
hs : s ∈ 𝒜.shatterer
t : Finset α
ht : t ∈ 𝒜
hst : s ⊆ t
⊢ s ∈ 𝒜

tactic: exact h hst ht
state_before: case refine_2.intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ t✝ : Finset α
a : α
n : ℕ
h : IsLowerSet ↑𝒜
s : Finset α
hs : s ∈ 𝒜.shatterer
t : Finset α
ht : t ∈ 𝒜
hst : s ⊆ t
⊢ s ∈ 𝒜
state_after: no goals
Theorem: PseudoMetricSpace.replaceBornology_eq
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: ext
state_before: α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
m : PseudoMetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
⊢ m.replaceBornology H = m
state_after: case h.dist.h.h
α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
m : PseudoMetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
x✝¹ x✝ : α
⊢ dist x✝¹ x✝ = dist x✝¹ x✝

tactic: rfl
state_before: case h.dist.h.h
α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
m : PseudoMetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
x✝¹ x✝ : α
⊢ dist x✝¹ x✝ = dist x✝¹ x✝
state_after: no goals
Theorem: LinearMap.map_eq_top_iff
File: Mathlib/LinearAlgebra/Span.lean

tactic: simp_rw [← top_le_iff, ← hf, range_eq_map, LinearMap.map_le_map_iff]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : Semiring R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝² : RingHomSurjective τ₁₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : F
hf : range f = ⊤
p : Submodule R M
⊢ map f p = ⊤ ↔ p ⊔ ker f = ⊤
state_after: no goals