1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Polynomial.not_isField
File: Mathlib/Algebra/Polynomial/Div.lean

tactic: nontriviality R
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
⊢ ¬IsField R[X]
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
⊢ ¬IsField R[X]

tactic: intro h
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
⊢ ¬IsField R[X]
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
h : IsField R[X]
⊢ False

tactic: letI := h.toField
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
h : IsField R[X]
⊢ False
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
h : IsField R[X]
this : Field R[X] := h.toField
⊢ False

tactic: simpa using congr_arg natDegree (monic_X.eq_one_of_isUnit <| monic_X (R := R).ne_zero.isUnit)
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
a✝ : Nontrivial R
h : IsField R[X]
this : Field R[X] := h.toField
⊢ False
state_after: no goals
Theorem: Primrec.option_casesOn
File: Mathlib/Computability/Primrec.lean

tactic: cases' o a with b <;> simp [encodek]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
o : α → Option β
f : α → σ
g : α → β → σ
ho : Primrec o
hf : Primrec f
hg : Primrec₂ g
a : α
⊢ (Nat.casesOn (encode (o a)) (encode (f a)) fun b =>
      (encode ((decode (encode (a, b).1)).bind fun a => Option.map (g a) (decode b))).pred) =
    encode (Option.casesOn (o a) (f a) (g a))
state_after: no goals
Theorem: WittVector.verschiebung_shift
File: Mathlib/RingTheory/WittVector/Domain.lean

tactic: ext ⟨j⟩
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
⊢ verschiebung (x.shift k.succ) = x.shift k
state_after: case h.zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
⊢ (verschiebung (x.shift k.succ)).coeff 0 = (x.shift k).coeff 0

case h.succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
n✝ : ℕ
⊢ (verschiebung (x.shift k.succ)).coeff (n✝ + 1) = (x.shift k).coeff (n✝ + 1)

tactic: rw [verschiebung_coeff_zero, shift_coeff, h]
state_before: case h.zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
⊢ (verschiebung (x.shift k.succ)).coeff 0 = (x.shift k).coeff 0
state_after: case h.zero.a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
⊢ k + 0 < k + 1

tactic: apply Nat.lt_succ_self
state_before: case h.zero.a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
⊢ k + 0 < k + 1
state_after: no goals

tactic: simp only [verschiebung_coeff_succ, shift]
state_before: case h.succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
n✝ : ℕ
⊢ (verschiebung (x.shift k.succ)).coeff (n✝ + 1) = (x.shift k).coeff (n✝ + 1)
state_after: case h.succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
n✝ : ℕ
⊢ x.coeff (k.succ + n✝) = x.coeff (k + (n✝ + 1))

tactic: congr 1
state_before: case h.succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
n✝ : ℕ
⊢ x.coeff (k.succ + n✝) = x.coeff (k + (n✝ + 1))
state_after: case h.succ.e_a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
n✝ : ℕ
⊢ k.succ + n✝ = k + (n✝ + 1)

tactic: rw [Nat.add_succ, add_comm, Nat.add_succ, add_comm]
state_before: case h.succ.e_a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
n✝ : ℕ
⊢ k.succ + n✝ = k + (n✝ + 1)
state_after: no goals
Theorem: Finset.sup_congr
File: Mathlib/Data/Finset/Lattice.lean

tactic: subst hs
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 : α
f g : β → α
hs : s₁ = s₂
hfg : ∀ a ∈ s₂, f a = g a
⊢ s₁.sup f = s₂.sup g
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₁ : Finset β
f✝ g✝ : β → α
a : α
f g : β → α
hfg : ∀ a ∈ s₁, f a = g a
⊢ s₁.sup f = s₁.sup g

tactic: exact Finset.fold_congr hfg
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₁ : Finset β
f✝ g✝ : β → α
a : α
f g : β → α
hfg : ∀ a ∈ s₁, f a = g a
⊢ s₁.sup f = s₁.sup g
state_after: no goals
Theorem: IsOpenMap.of_sections
File: Mathlib/Topology/Maps.lean

tactic: rw [map_map, hgf.comp_eq_id, map_id]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g✝ : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
h : ∀ (x : X), ∃ g, ContinuousAt g (f x) ∧ g (f x) = x ∧ Function.RightInverse g f
x : X
g : Y → X
hgc : ContinuousAt g (f x)
hgx : g (f x) = x
hgf : Function.RightInverse g f
⊢ 𝓝 (f x) = map f (map g (𝓝 (f x)))
state_after: no goals

tactic: rw [hgx]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g✝ : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
h : ∀ (x : X), ∃ g, ContinuousAt g (f x) ∧ g (f x) = x ∧ Function.RightInverse g f
x : X
g : Y → X
hgc : ContinuousAt g (f x)
hgx : g (f x) = x
hgf : Function.RightInverse g f
⊢ map f (𝓝 (g (f x))) = map f (𝓝 x)
state_after: no goals
Theorem: PartialHomeomorph.univBall_apply_zero
File: Mathlib/Analysis/NormedSpace/HomeomorphBall.lean

tactic: unfold univBall
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
⊢ ↑(univBall c r) 0 = c
state_after: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
⊢ ↑(if h : 0 < r then univUnitBall.trans' (unitBallBall c r h) ⋯
        else (IsometryEquiv.vaddConst c).toHomeomorph.toPartialHomeomorph)
      0 =
    c

tactic: split_ifs <;> simp
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
⊢ ↑(if h : 0 < r then univUnitBall.trans' (unitBallBall c r h) ⋯
        else (IsometryEquiv.vaddConst c).toHomeomorph.toPartialHomeomorph)
      0 =
    c
state_after: no goals
Theorem: List.Nat.antidiagonalTuple_two
File: Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean

tactic: rw [antidiagonalTuple]
state_before: n : ℕ
⊢ antidiagonalTuple 2 n = map (fun i => ![i.1, i.2]) (antidiagonal n)
state_after: n : ℕ
⊢ ((antidiagonal n).bind fun ni => map (fun x => Fin.cons ni.1 x) (antidiagonalTuple 1 ni.2)) =
    map (fun i => ![i.1, i.2]) (antidiagonal n)

tactic: simp_rw [antidiagonalTuple_one, List.map_singleton]
state_before: n : ℕ
⊢ ((antidiagonal n).bind fun ni => map (fun x => Fin.cons ni.1 x) (antidiagonalTuple 1 ni.2)) =
    map (fun i => ![i.1, i.2]) (antidiagonal n)
state_after: n : ℕ
⊢ ((antidiagonal n).bind fun ni => [Fin.cons ni.1 ![ni.2]]) = map (fun i => ![i.1, i.2]) (antidiagonal n)

tactic: rw [List.map_eq_bind]
state_before: n : ℕ
⊢ ((antidiagonal n).bind fun ni => [Fin.cons ni.1 ![ni.2]]) = map (fun i => ![i.1, i.2]) (antidiagonal n)
state_after: n : ℕ
⊢ ((antidiagonal n).bind fun ni => [Fin.cons ni.1 ![ni.2]]) = (antidiagonal n).bind fun x => [![x.1, x.2]]

tactic: rfl
state_before: n : ℕ
⊢ ((antidiagonal n).bind fun ni => [Fin.cons ni.1 ![ni.2]]) = (antidiagonal n).bind fun x => [![x.1, x.2]]
state_after: no goals
Theorem: StarSubalgebra.comap_comap
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: exact Set.preimage_preimage
state_before: F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
C : Type u_5
inst✝¹³ : CommSemiring R
inst✝¹² : StarRing R
inst✝¹¹ : Semiring A
inst✝¹⁰ : StarRing A
inst✝⁹ : Algebra R A
inst✝⁸ : StarModule R A
inst✝⁷ : Semiring B
inst✝⁶ : StarRing B
inst✝⁵ : Algebra R B
inst✝⁴ : StarModule R B
inst✝³ : Semiring C
inst✝² : StarRing C
inst✝¹ : Algebra R C
inst✝ : StarModule R C
S✝ : StarSubalgebra R A
S : StarSubalgebra R C
g : B →⋆ₐ[R] C
f : A →⋆ₐ[R] B
⊢ ↑(comap f (comap g S)) = ↑(comap (g.comp f) S)
state_after: no goals
Theorem: Filter.isBounded_ge_map_of_bounded_range
File: Mathlib/Topology/Order/Bounded.lean

tactic: obtain ⟨c, hc⟩ := h.bddBelow
state_before: ι : Type u_1
F : Filter ι
f : ι → ℝ
h : Bornology.IsBounded (range f)
⊢ IsBounded (fun x x_1 => x ≥ x_1) (map f F)
state_after: case intro
ι : Type u_1
F : Filter ι
f : ι → ℝ
h : Bornology.IsBounded (range f)
c : ℝ
hc : c ∈ lowerBounds (range f)
⊢ IsBounded (fun x x_1 => x ≥ x_1) (map f F)

tactic: apply isBoundedUnder_of ⟨c, by simpa [mem_lowerBounds] using hc⟩
state_before: case intro
ι : Type u_1
F : Filter ι
f : ι → ℝ
h : Bornology.IsBounded (range f)
c : ℝ
hc : c ∈ lowerBounds (range f)
⊢ IsBounded (fun x x_1 => x ≥ x_1) (map f F)
state_after: no goals

tactic: simpa [mem_lowerBounds] using hc
state_before: ι : Type u_1
F : Filter ι
f : ι → ℝ
h : Bornology.IsBounded (range f)
c : ℝ
hc : c ∈ lowerBounds (range f)
⊢ ∀ (x : ι), f x ≥ c
state_after: no goals
Theorem: MeasureTheory.Measure.FiniteAtFilter.inf_ae_iff
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: refine ⟨?_, fun h => h.filter_mono inf_le_left⟩
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
f g : Filter α
⊢ μ.FiniteAtFilter (f ⊓ ae μ) ↔ μ.FiniteAtFilter f
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
f g : Filter α
⊢ μ.FiniteAtFilter (f ⊓ ae μ) → μ.FiniteAtFilter f

tactic: rintro ⟨s, ⟨t, ht, u, hu, rfl⟩, hμ⟩
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
f g : Filter α
⊢ μ.FiniteAtFilter (f ⊓ ae μ) → μ.FiniteAtFilter f
state_after: case intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t✝ : Set α
f g : Filter α
t : Set α
ht : t ∈ f
u : Set α
hu : u ∈ ae μ
hμ : μ (t ∩ u) < ⊤
⊢ μ.FiniteAtFilter f

tactic: suffices μ t ≤ μ (t ∩ u) from ⟨t, ht, this.trans_lt hμ⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t✝ : Set α
f g : Filter α
t : Set α
ht : t ∈ f
u : Set α
hu : u ∈ ae μ
hμ : μ (t ∩ u) < ⊤
⊢ μ.FiniteAtFilter f
state_after: case intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t✝ : Set α
f g : Filter α
t : Set α
ht : t ∈ f
u : Set α
hu : u ∈ ae μ
hμ : μ (t ∩ u) < ⊤
⊢ μ t ≤ μ (t ∩ u)

tactic: exact measure_mono_ae (mem_of_superset hu fun x hu ht => ⟨ht, hu⟩)
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t✝ : Set α
f g : Filter α
t : Set α
ht : t ∈ f
u : Set α
hu : u ∈ ae μ
hμ : μ (t ∩ u) < ⊤
⊢ μ t ≤ μ (t ∩ u)
state_after: no goals
Theorem: Rat.cast_nonpos
File: Mathlib/Data/Rat/Cast/Order.lean

tactic: norm_cast
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
p q : ℚ
K : Type u_5
inst✝ : LinearOrderedField K
⊢ ↑q ≤ 0 ↔ q ≤ 0
state_after: no goals
Theorem: squarefree_iff_irreducible_sq_not_dvd_of_ne_zero
File: Mathlib/Algebra/Squarefree/Basic.lean

tactic: simpa [hr] using (irreducible_sq_not_dvd_iff_eq_zero_and_no_irreducibles_or_squarefree r).symm
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
r : R
hr : r ≠ 0
⊢ Squarefree r ↔ ∀ (x : R), Irreducible x → ¬x * x ∣ r
state_after: no goals
Theorem: Nat.choose_eq_zero_of_lt
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: have hnk : n < k := lt_of_succ_lt_succ hk
state_before: n k : ℕ
hk : n + 1 < k + 1
⊢ (n + 1).choose (k + 1) = 0
state_after: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
⊢ (n + 1).choose (k + 1) = 0

tactic: have hnk1 : n < k + 1 := lt_of_succ_lt hk
state_before: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
⊢ (n + 1).choose (k + 1) = 0
state_after: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
hnk1 : n < k + 1
⊢ (n + 1).choose (k + 1) = 0

tactic: rw [choose_succ_succ, choose_eq_zero_of_lt hnk, choose_eq_zero_of_lt hnk1]
state_before: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
hnk1 : n < k + 1
⊢ (n + 1).choose (k + 1) = 0
state_after: no goals
Theorem: Rat.divInt_one
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [divInt, mkRat, normalize]
state_before: q a b c : ℚ
n : ℤ
⊢ n /. 1 = ↑n
state_after: no goals
Theorem: LSeries.term_add
File: Mathlib/NumberTheory/LSeries/Linearity.lean

tactic: ext ⟨- | n⟩
state_before: f g : ℕ → ℂ
s : ℂ
⊢ term (f + g) s = term f s + term g s
state_after: case h.zero
f g : ℕ → ℂ
s : ℂ
⊢ term (f + g) s 0 = (term f s + term g s) 0

case h.succ
f g : ℕ → ℂ
s : ℂ
n✝ : ℕ
⊢ term (f + g) s (n✝ + 1) = (term f s + term g s) (n✝ + 1)

tactic: simp only [term_zero, Pi.add_apply, add_zero]
state_before: case h.zero
f g : ℕ → ℂ
s : ℂ
⊢ term (f + g) s 0 = (term f s + term g s) 0
state_after: no goals

tactic: simp only [term_of_ne_zero (Nat.succ_ne_zero _), Pi.add_apply, add_div]
state_before: case h.succ
f g : ℕ → ℂ
s : ℂ
n✝ : ℕ
⊢ term (f + g) s (n✝ + 1) = (term f s + term g s) (n✝ + 1)
state_after: no goals
Theorem: Monoid.CoprodI.ext_hom
File: Mathlib/GroupTheory/CoprodI.lean

tactic: erw [MonoidHom.comp_apply, MonoidHom.comp_apply, ← of_apply, ← MonoidHom.comp_apply, ←
  MonoidHom.comp_apply, h]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
f g : CoprodI M →* N
h : ∀ (i : ι), f.comp of = g.comp of
x✝ : (i : ι) × M i
i : ι
x : M i
⊢ (f.comp (conGen (Rel M)).mk') (FreeMonoid.of ⟨i, x⟩) = (g.comp (conGen (Rel M)).mk') (FreeMonoid.of ⟨i, x⟩)
state_after: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
f g : CoprodI M →* N
h : ∀ (i : ι), f.comp of = g.comp of
x✝ : (i : ι) × M i
i : ι
x : M i
⊢ (g.comp of) x = (g.comp (conGen (Rel M)).mk') (FreeMonoid.of ⟨i, x⟩)

tactic: rfl
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
f g : CoprodI M →* N
h : ∀ (i : ι), f.comp of = g.comp of
x✝ : (i : ι) × M i
i : ι
x : M i
⊢ (g.comp of) x = (g.comp (conGen (Rel M)).mk') (FreeMonoid.of ⟨i, x⟩)
state_after: no goals
Theorem: CategoryTheory.Limits.hasCoproducts_of_finite_and_filtered
File: Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean

tactic: classical exact ⟨fun F => HasColimit.mk (liftToFinsetColimitCocone F)⟩
state_before: C : Type u
inst✝² : Category.{v, u} C
α✝ : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
α : Type w
⊢ HasColimitsOfShape (Discrete α) C
state_after: no goals

tactic: exact ⟨fun F => HasColimit.mk (liftToFinsetColimitCocone F)⟩
state_before: C : Type u
inst✝² : Category.{v, u} C
α✝ : Type w
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasFilteredColimitsOfSize.{w, w, v, u} C
α : Type w
⊢ HasColimitsOfShape (Discrete α) C
state_after: no goals
Theorem: Real.one_lt_toNNReal
File: Mathlib/Data/NNReal/Basic.lean

tactic: simpa only [not_le] using toNNReal_le_one.not
state_before: r : ℝ
⊢ 1 < r.toNNReal ↔ 1 < r
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_rightUnitor_hom_fst
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: cases X
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (ρ_ X).hom.1 = (ρ_ X.1).hom
state_after: case mk
C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (ρ_ (fst✝, snd✝)).hom.1 = (ρ_ (fst✝, snd✝).1).hom

tactic: rfl
state_before: case mk
C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (ρ_ (fst✝, snd✝)).hom.1 = (ρ_ (fst✝, snd✝).1).hom
state_after: no goals
Theorem: SimpleGraph.girth_eq_top
File: Mathlib/Combinatorics/SimpleGraph/Girth.lean

tactic: simp [girth, IsAcyclic]
state_before: α : Type u_1
G : SimpleGraph α
n : ℕ∞
⊢ G.girth = ⊤ ↔ G.IsAcyclic
state_after: no goals
Theorem: CategoryTheory.eval_typesGlue
File: Mathlib/CategoryTheory/Sites/Types.lean

tactic: funext x
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj { unop := PUnit.{u + 1} }
⊢ eval S α (typesGlue S hs α f) = f
state_after: case h
S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj { unop := PUnit.{u + 1} }
x : α
⊢ eval S α (typesGlue S hs α f) x = f x

tactic: apply (IsSheafFor.valid_glue _ _ _ <| ⟨PUnit.unit, fun _ => Subsingleton.elim _ _⟩).trans
state_before: case h
S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj { unop := PUnit.{u + 1} }
x : α
⊢ eval S α (typesGlue S hs α f) x = f x
state_after: case h
S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj { unop := PUnit.{u + 1} }
x : α
⊢ S.map (↾fun x => PUnit.unit).op (f ((↾fun x_1 => x) (Classical.choose ⋯))) = f x

tactic: convert FunctorToTypes.map_id_apply S _
state_before: case h
S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj { unop := PUnit.{u + 1} }
x : α
⊢ S.map (↾fun x => PUnit.unit).op (f ((↾fun x_1 => x) (Classical.choose ⋯))) = f x
state_after: no goals
Theorem: BoxIntegral.Box.withBotCoe_inj
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: simp only [Subset.antisymm_iff, ← le_antisymm_iff, withBotCoe_subset_iff]
state_before: ι : Type u_1
I✝ J✝ : Box ι
x y : ι → ℝ
I J : WithBot (Box ι)
⊢ ↑I = ↑J ↔ I = J
state_after: no goals
Theorem: Fin.Ici_eq_finset_subtype
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: ext
state_before: n : ℕ
a b : Fin n
⊢ Ici a = Finset.fin n (Icc (↑a) n)
state_after: case a
n : ℕ
a b a✝ : Fin n
⊢ a✝ ∈ Ici a ↔ a✝ ∈ Finset.fin n (Icc (↑a) n)

tactic: simp
state_before: case a
n : ℕ
a b a✝ : Fin n
⊢ a✝ ∈ Ici a ↔ a✝ ∈ Finset.fin n (Icc (↑a) n)
state_after: no goals
Theorem: Option.map_map₂_distrib_left
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> simp [h_distrib]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
g : γ → δ
f' : α' → β → δ
g' : α → α'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g' a) b
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g' a) b
state_after: no goals
Theorem: MeasureTheory.memℒp_congr_ae
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: simp only [Memℒp, snorm_congr_ae hfg, aestronglyMeasurable_congr hfg]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hfg : f =ᶠ[ae μ] g
⊢ Memℒp f p μ ↔ Memℒp g p μ
state_after: no goals
Theorem: TendstoUniformlyOn.congr
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter] at hf ⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOn F f p s
hff' : ∀ᶠ (n : ι) in p, EqOn (F n) (F' n) s
⊢ TendstoUniformlyOn F' f p s
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : ∀ᶠ (n : ι) in p, EqOn (F n) (F' n) s
⊢ TendstoUniformlyOnFilter F' f p (𝓟 s)

tactic: refine hf.congr ?_
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : ∀ᶠ (n : ι) in p, EqOn (F n) (F' n) s
⊢ TendstoUniformlyOnFilter F' f p (𝓟 s)
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : ∀ᶠ (n : ι) in p, EqOn (F n) (F' n) s
⊢ ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, F n.1 n.2 = F' n.1 n.2

tactic: rw [eventually_iff] at hff' ⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : ∀ᶠ (n : ι) in p, EqOn (F n) (F' n) s
⊢ ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, F n.1 n.2 = F' n.1 n.2
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : {x | EqOn (F x) (F' x) s} ∈ p
⊢ {x | F x.1 x.2 = F' x.1 x.2} ∈ p ×ˢ 𝓟 s

tactic: simp only [Set.EqOn] at hff'
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : {x | EqOn (F x) (F' x) s} ∈ p
⊢ {x | F x.1 x.2 = F' x.1 x.2} ∈ p ×ˢ 𝓟 s
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : {x | ∀ ⦃x_1 : α⦄, x_1 ∈ s → F x x_1 = F' x x_1} ∈ p
⊢ {x | F x.1 x.2 = F' x.1 x.2} ∈ p ×ˢ 𝓟 s

tactic: simp only [mem_prod_principal, hff', mem_setOf_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : {x | ∀ ⦃x_1 : α⦄, x_1 ∈ s → F x x_1 = F' x x_1} ∈ p
⊢ {x | F x.1 x.2 = F' x.1 x.2} ∈ p ×ˢ 𝓟 s
state_after: no goals
Theorem: legendreSym.at_neg_two
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean

tactic: have : (-2 : ZMod p) = (-2 : ℤ) := by norm_cast
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ legendreSym p (-2) = χ₈' ↑p
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
this : -2 = ↑(-2)
⊢ legendreSym p (-2) = χ₈' ↑p

tactic: rw [legendreSym, ← this, quadraticChar_neg_two ((ringChar_zmod_n p).substr hp), card p]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
this : -2 = ↑(-2)
⊢ legendreSym p (-2) = χ₈' ↑p
state_after: no goals

tactic: norm_cast
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ -2 = ↑(-2)
state_after: no goals
Theorem: MeasureTheory.injective_dirac
File: Mathlib/MeasureTheory/Measure/Dirac.lean

tactic: rwa [← dirac_eq_dirac_iff]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s : Set α
a : α
inst✝ : MeasurableSpace.SeparatesPoints α
x y : α
x_ne_y : (fun x => dirac x) x = (fun x => dirac x) y
⊢ x = y
state_after: no goals