ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Mathlib.Vector.id_traverse
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
⊢ ∀ (x : Vector α n), Vector.traverse pure x = x
state_after: case mk
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : List α
⊢ Vector.traverse pure ⟨x, ⋯⟩ = ⟨x, ⋯⟩
tactic: rintro ⟨x, rfl⟩
state_before: case mk
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : List α
⊢ Vector.traverse pure ⟨x, ⋯⟩ = ⟨x, ⋯⟩
state_after: case mk
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : List α
⊢ Mathlib.Vector.traverseAux pure x = ⟨x, ⋯⟩
tactic: dsimp [Vector.traverse, cast]
state_before: case mk
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : List α
⊢ Mathlib.Vector.traverseAux pure x = ⟨x, ⋯⟩
state_after: case mk.nil
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
⊢ Mathlib.Vector.traverseAux pure [] = ⟨[], ⋯⟩

case mk.cons
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : α
xs : List α
IH : Mathlib.Vector.traverseAux pure xs = ⟨xs, ⋯⟩
⊢ Mathlib.Vector.traverseAux pure (x :: xs) = ⟨x :: xs, ⋯⟩
tactic: induction' x with x xs IH
state_before: case mk.cons
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : α
xs : List α
IH : Mathlib.Vector.traverseAux pure xs = ⟨xs, ⋯⟩
⊢ Mathlib.Vector.traverseAux pure (x :: xs) = ⟨x :: xs, ⋯⟩
state_after: case mk.cons
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : α
xs : List α
IH : Mathlib.Vector.traverseAux pure xs = ⟨xs, ⋯⟩
⊢ (Seq.seq (cons x) fun x => ⟨xs, ⋯⟩) = ⟨x :: xs, ⋯⟩
tactic: simp! [IH]
state_before: case mk.cons
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : α
xs : List α
IH : Mathlib.Vector.traverseAux pure xs = ⟨xs, ⋯⟩
⊢ (Seq.seq (cons x) fun x => ⟨xs, ⋯⟩) = ⟨x :: xs, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: uniformity_eq_comap_neg_add_nhds_zero_swapped
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ 𝓤 α = comap (fun x => x.2⁻¹ * x.1) (𝓝 1)
state_after: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ comap ((fun x => x.1⁻¹ * x.2) ∘ Prod.swap) (𝓝 1) = comap (fun x => x.2⁻¹ * x.1) (𝓝 1)
tactic: rw [← comap_swap_uniformity, uniformity_eq_comap_inv_mul_nhds_one, comap_comap]
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
⊢ comap ((fun x => x.1⁻¹ * x.2) ∘ Prod.swap) (𝓝 1) = comap (fun x => x.2⁻¹ * x.1) (𝓝 1)
state_after: no goals
tactic: rfl
Theorem: Nat.shiftLeft'_false
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n✝ n : ℕ
⊢ shiftLeft' false m (n + 1) = m <<< (n + 1)
state_after: m n✝ n : ℕ
this : 2 * (m * 2 ^ n) = 2 ^ (n + 1) * m
⊢ shiftLeft' false m (n + 1) = m <<< (n + 1)
tactic: have : 2 * (m * 2^n) = 2^(n+1)*m := by
      rw [Nat.mul_comm, Nat.mul_assoc, ← Nat.pow_succ]; simp
state_before: m n✝ n : ℕ
this : 2 * (m * 2 ^ n) = 2 ^ (n + 1) * m
⊢ shiftLeft' false m (n + 1) = m <<< (n + 1)
state_after: no goals
tactic: simp [shiftLeft_eq, shiftLeft', bit_val, shiftLeft'_false, this]
Theorem: multiset_sum_mem
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset M
hm : ∀ a ∈ m, a ∈ S
⊢ m.prod ∈ S
state_after: case intro
M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset ↥S
⊢ (Multiset.map Subtype.val m).prod ∈ S
tactic: lift m to Multiset S using hm
state_before: case intro
M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset ↥S
⊢ (Multiset.map Subtype.val m).prod ∈ S
state_after: case intro
M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset ↥S
⊢ ↑m.prod ∈ S
tactic: rw [← coe_multiset_prod]
state_before: case intro
M✝ : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : Monoid M✝
inst✝⁴ : SetLike B M✝
inst✝³ : SubmonoidClass B M✝
S : B
M : Type u_4
inst✝² : CommMonoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
m : Multiset ↥S
⊢ ↑m.prod ∈ S
state_after: no goals
tactic: exact m.prod.coe_prop
Theorem: RCLike.inv_I
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
⊢ I⁻¹ = -I
state_after: case pos
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
h : I = 0
⊢ I⁻¹ = -I

case neg
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
h : ¬I = 0
⊢ I⁻¹ = -I
tactic: by_cases h : (I : K) = 0
Theorem: Set.neg_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : InvolutiveInv α
s t : Set α
a : α
⊢ s⁻¹ ⊆ t ↔ s ⊆ t⁻¹
state_after: no goals
tactic: rw [← inv_subset_inv, inv_inv]
Theorem: Urysohns.CU.continuous_lim
File: Mathlib/Topology/UrysohnsLemma.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
⊢ Continuous c.lim
state_after: case intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
h0 : 0 < 2⁻¹
h1234 : 2⁻¹ < 3 / 4
h1 : 3 / 4 < 1
⊢ Continuous c.lim
tactic: obtain ⟨h0, h1234, h1⟩ : 0 < (2⁻¹ : ℝ) ∧ (2⁻¹ : ℝ) < 3 / 4 ∧ (3 / 4 : ℝ) < 1 := by norm_num
state_before: case intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
h0 : 0 < 2⁻¹
h1234 : 2⁻¹ < 3 / 4
h1 : 3 / 4 < 1
⊢ Continuous c.lim
state_after: case intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
h0 : 0 < 2⁻¹
h1234 : 2⁻¹ < 3 / 4
h1 : 3 / 4 < 1
x : X
n : ℕ
x✝ : True
⊢ ∀ᶠ (x_1 : X) in 𝓝 x, c.lim x_1 ∈ Metric.closedBall (c.lim x) ((3 / 4) ^ n)
tactic: refine
    continuous_iff_continuousAt.2 fun x =>
      (Metric.nhds_basis_closedBall_pow (h0.trans h1234) h1).tendsto_right_iff.2 fun n _ => ?_
state_before: case intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
h0 : 0 < 2⁻¹
h1234 : 2⁻¹ < 3 / 4
h1 : 3 / 4 < 1
x : X
n : ℕ
x✝ : True
⊢ ∀ᶠ (x_1 : X) in 𝓝 x, c.lim x_1 ∈ Metric.closedBall (c.lim x) ((3 / 4) ^ n)
state_after: case intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
h0 : 0 < 2⁻¹
h1234 : 2⁻¹ < 3 / 4
h1 : 3 / 4 < 1
x : X
n : ℕ
x✝ : True
⊢ ∀ᶠ (x_1 : X) in 𝓝 x, dist (c.lim x_1) (c.lim x) ≤ (3 / 4) ^ n
tactic: simp only [Metric.mem_closedBall]
state_before: case intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
h0 : 0 < 2⁻¹
h1234 : 2⁻¹ < 3 / 4
h1 : 3 / 4 < 1
x : X
n : ℕ
x✝ : True
⊢ ∀ᶠ (x_1 : X) in 𝓝 x, dist (c.lim x_1) (c.lim x) ≤ (3 / 4) ^ n
state_after: case intro.intro.zero
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
h0 : 0 < 2⁻¹
h1234 : 2⁻¹ < 3 / 4
h1 : 3 / 4 < 1
x : X
x✝ : True
c : CU P
⊢ ∀ᶠ (x_1 : X) in 𝓝 x, dist (c.lim x_1) (c.lim x) ≤ (3 / 4) ^ 0

case intro.intro.succ
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
h0 : 0 < 2⁻¹
h1234 : 2⁻¹ < 3 / 4
h1 : 3 / 4 < 1
x : X
x✝ : True
n : ℕ
ihn : ∀ (c : CU P), ∀ᶠ (x_1 : X) in 𝓝 x, dist (c.lim x_1) (c.lim x) ≤ (3 / 4) ^ n
c : CU P
⊢ ∀ᶠ (x_1 : X) in 𝓝 x, dist (c.lim x_1) (c.lim x) ≤ (3 / 4) ^ (n + 1)
tactic: induction' n with n ihn generalizing c
Theorem: Polynomial.natDegree_removeFactor'
File: Mathlib/FieldTheory/SplittingField/Construction.lean

Proof steps:
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
n : ℕ
hfn : f.natDegree = n + 1
⊢ f.removeFactor.natDegree = n
state_after: no goals
tactic: rw [natDegree_removeFactor, hfn, n.add_sub_cancel]
Theorem: Filter.mul_top_of_one_le
File: Mathlib/Order/Filter/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hf : 1 ≤ f
⊢ f * ⊤ = ⊤
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s : Set α
⊢ s ∈ f * ⊤ → s ∈ ⊤
tactic: refine top_le_iff.1 fun s => ?_
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s : Set α
⊢ s ∈ f * ⊤ → s ∈ ⊤
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s : Set α
⊢ (∃ t₁ ∈ f, t₁ * univ ⊆ s) → s = univ
tactic: simp only [mem_mul, mem_top, exists_and_left, exists_eq_left]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s : Set α
⊢ (∃ t₁ ∈ f, t₁ * univ ⊆ s) → s = univ
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s t : Set α
ht : t ∈ f
hs : t * univ ⊆ s
⊢ s = univ
tactic: rintro ⟨t, ht, hs⟩
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s t : Set α
ht : t ∈ f
hs : t * univ ⊆ s
⊢ s = univ
state_after: no goals
tactic: rwa [mul_univ_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs
Theorem: Filter.mem_traverse_iff
File: Mathlib/Order/Filter/ListTraverse.lean

Proof steps:
state_before: α β γ : Type u
f : β → Filter α
s : γ → Set α
fs : List β
t : Set (List α)
⊢ t ∈ traverse f fs ↔ ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
state_after: case mp
α β γ : Type u
f : β → Filter α
s : γ → Set α
fs : List β
t : Set (List α)
⊢ t ∈ traverse f fs → ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t

case mpr
α β γ : Type u
f : β → Filter α
s : γ → Set α
fs : List β
t : Set (List α)
⊢ (∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t) → t ∈ traverse f fs
tactic: constructor
Theorem: MvQPF.Cofix.ext
File: Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean

Proof steps:
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x y : Cofix F α
h : x.dest = y.dest
⊢ x = y
state_after: no goals
tactic: rw [← Cofix.mk_dest x, h, Cofix.mk_dest]
Theorem: SignType.map_cast'
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : Zero α
inst✝⁴ : One α
inst✝³ : Neg α
β : Type u_2
inst✝² : One β
inst✝¹ : Neg β
inst✝ : Zero β
f : α → β
h₁ : f 1 = 1
h₂ : f 0 = 0
h₃ : f (-1) = -1
s : SignType
⊢ f ↑s = ↑s
state_after: no goals
tactic: cases s <;> simp only [SignType.cast, h₁, h₂, h₃]
Theorem: Ring.toNonAssocRing_injective
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
⊢ Function.Injective (@toNonAssocRing R)
state_after: R : Type u
a₁✝ a₂✝ : Ring R
a✝ : toNonAssocRing = toNonAssocRing
⊢ a₁✝ = a₂✝
tactic: intro _ _ _
state_before: R : Type u
a₁✝ a₂✝ : Ring R
a✝ : toNonAssocRing = toNonAssocRing
⊢ a₁✝ = a₂✝
state_after: no goals
tactic: ext <;> congr
Theorem: AffineSubspace.affineSpan_eq_top_iff_vectorSpan_eq_top_of_nontrivial
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
inst✝ : Nontrivial P
⊢ affineSpan k s = ⊤ ↔ vectorSpan k s = ⊤
state_after: case inl
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
inst✝ : Nontrivial P
hs : s = ∅
⊢ affineSpan k s = ⊤ ↔ vectorSpan k s = ⊤

case inr
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
inst✝ : Nontrivial P
hs : s.Nonempty
⊢ affineSpan k s = ⊤ ↔ vectorSpan k s = ⊤
tactic: rcases s.eq_empty_or_nonempty with hs | hs
Theorem: TopologicalSpace.Clopens.countable_iff_second_countable
File: Mathlib/Topology/ClopenBox.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : CompactSpace Y
inst✝² : CompactSpace X
inst✝¹ : T2Space X
inst✝ : TotallyDisconnectedSpace X
⊢ Countable (Clopens X) ↔ SecondCountableTopology X
state_after: case refine_1
X : Type u_1
Y : Type u_2
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : CompactSpace Y
inst✝² : CompactSpace X
inst✝¹ : T2Space X
inst✝ : TotallyDisconnectedSpace X
h : Countable (Clopens X)
⊢ {s | IsClopen s}.Countable

case refine_2
X : Type u_1
Y : Type u_2
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : CompactSpace Y
inst✝² : CompactSpace X
inst✝¹ : T2Space X
inst✝ : TotallyDisconnectedSpace X
h : Countable (Clopens X)
⊢ inst✝⁵ = generateFrom {s | IsClopen s}

case refine_3
X : Type u_1
Y : Type u_2
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : CompactSpace Y
inst✝² : CompactSpace X
inst✝¹ : T2Space X
inst✝ : TotallyDisconnectedSpace X
h : SecondCountableTopology X
⊢ Countable (Clopens X)
tactic: refine ⟨fun h ↦ ⟨{s : Set X | IsClopen s}, ?_, ?_⟩, fun h ↦ ?_⟩
Theorem: CategoryTheory.Pretriangulated.shiftFunctorZero_op_hom_app
File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
⊢ (shiftFunctorZero Cᵒᵖ ℤ).hom.app X =
    (shiftFunctorOpIso C 0 0 ⋯).hom.app X ≫ ((shiftFunctorZero C ℤ).inv.app (Opposite.unop X)).op
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) 0 0
              ⋯).hom.app
        X ≫
      ((shiftFunctorZero C ℤ).inv.app (Opposite.unop X)).op =
    (shiftFunctorOpIso C 0 0 ⋯).hom.app X ≫ ((shiftFunctorZero C ℤ).inv.app (Opposite.unop X)).op
tactic: erw [@pullbackShiftFunctorZero_hom_app (OppositeShift C ℤ), oppositeShiftFunctorZero_hom_app]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) 0 0
              ⋯).hom.app
        X ≫
      ((shiftFunctorZero C ℤ).inv.app (Opposite.unop X)).op =
    (shiftFunctorOpIso C 0 0 ⋯).hom.app X ≫ ((shiftFunctorZero C ℤ).inv.app (Opposite.unop X)).op
state_after: no goals
tactic: rfl
Theorem: finsum_mem_union_inter'
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ t), f i =
    (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ t ∩ mulSupport f), f i =
    (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i
tactic: rw [← finprod_mem_inter_mulSupport f s, ← finprod_mem_inter_mulSupport f t, ←
    finprod_mem_union_inter hs ht, ← union_inter_distrib_right, finprod_mem_inter_mulSupport, ←
    finprod_mem_inter_mulSupport f (s ∩ t)]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ t ∩ mulSupport f), f i =
    (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i
state_after: case e_a.e_f
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (fun i => ∏ᶠ (_ : i ∈ s ∩ t ∩ mulSupport f), f i) = fun i => ∏ᶠ (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i
tactic: congr 2
state_before: case e_a.e_f
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (fun i => ∏ᶠ (_ : i ∈ s ∩ t ∩ mulSupport f), f i) = fun i => ∏ᶠ (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i
state_after: no goals
tactic: rw [inter_left_comm, inter_assoc, inter_assoc, inter_self, inter_left_comm]
Theorem: lp.norm_le_of_forall_le
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : ↥(lp E ⊤)
C : ℝ
hC : 0 ≤ C
hCf : ∀ (i : α), ‖↑f i‖ ≤ C
⊢ ‖f‖ ≤ C
state_after: case inl
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : ↥(lp E ⊤)
C : ℝ
hC : 0 ≤ C
hCf : ∀ (i : α), ‖↑f i‖ ≤ C
h✝ : IsEmpty α
⊢ ‖f‖ ≤ C

case inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : ↥(lp E ⊤)
C : ℝ
hC : 0 ≤ C
hCf : ∀ (i : α), ‖↑f i‖ ≤ C
h✝ : Nonempty α
⊢ ‖f‖ ≤ C
tactic: cases isEmpty_or_nonempty α
Theorem: EuclideanGeometry.cos_oangle_right_mul_dist_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ (∡ p₂ p₃ p₁).cos * dist p₁ p₃ = dist p₃ p₂
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ (∡ p₂ p₃ p₁).cos * dist p₁ p₃ = dist p₃ p₂
tactic: have hs : (∡ p₂ p₃ p₁).sign = 1 := by rw [oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ (∡ p₂ p₃ p₁).cos * dist p₁ p₃ = dist p₃ p₂
state_after: no goals
tactic: rw [oangle_eq_angle_of_sign_eq_one hs, Real.Angle.cos_coe,
    cos_angle_mul_dist_of_angle_eq_pi_div_two (angle_eq_pi_div_two_of_oangle_eq_pi_div_two h)]
Theorem: Polynomial.adjoin_rootSet_eq_range
File: Mathlib/Algebra/Polynomial/Splits.lean

Proof steps:
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
i : K →+* L
inst✝¹ : Algebra R K
inst✝ : Algebra R L
p : R[X]
h : Splits (algebraMap R K) p
f : K →ₐ[R] L
⊢ Algebra.adjoin R (p.rootSet L) = f.range ↔ Algebra.adjoin R (p.rootSet K) = ⊤
state_after: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
i : K →+* L
inst✝¹ : Algebra R K
inst✝ : Algebra R L
p : R[X]
h : Splits (algebraMap R K) p
f : K →ₐ[R] L
⊢ Subalgebra.map f (Algebra.adjoin R (p.rootSet K)) = Subalgebra.map f ⊤ ↔ Algebra.adjoin R (p.rootSet K) = ⊤
tactic: rw [← image_rootSet h f, Algebra.adjoin_image, ← Algebra.map_top]
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
i : K →+* L
inst✝¹ : Algebra R K
inst✝ : Algebra R L
p : R[X]
h : Splits (algebraMap R K) p
f : K →ₐ[R] L
⊢ Subalgebra.map f (Algebra.adjoin R (p.rootSet K)) = Subalgebra.map f ⊤ ↔ Algebra.adjoin R (p.rootSet K) = ⊤
state_after: no goals
tactic: exact (Subalgebra.map_injective f.toRingHom.injective).eq_iff
Theorem: Configuration.HasLines.exists_bijective_of_card_eq
File: Mathlib/Combinatorics/Configuration.lean

Proof steps:
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : HasLines P L
inst✝¹ : Fintype P
inst✝ : Fintype L
h : Fintype.card P = Fintype.card L
⊢ ∃ f, Function.Bijective f ∧ ∀ (l : L), pointCount P l = lineCount L (f l)
state_after: no goals
tactic: classical
    obtain ⟨f, hf1, hf2⟩ := Nondegenerate.exists_injective_of_card_le (ge_of_eq h)
    have hf3 := (Fintype.bijective_iff_injective_and_card f).mpr ⟨hf1, h.symm⟩
    exact ⟨f, hf3, fun l ↦ (sum_eq_sum_iff_of_le fun l _ ↦ pointCount_le_lineCount (hf2 l)).1
          ((hf3.sum_comp _).trans (sum_lineCount_eq_sum_pointCount P L)).symm _ <| mem_univ _⟩
Theorem: Real.isConjExponent_iff_eq_conjExponent
File: Mathlib/Data/Real/ConjExponents.lean

Proof steps:
state_before: a b p q : ℝ
h✝ : p.IsConjExponent q
hp : 1 < p
h : q = p / (p - 1)
⊢ p⁻¹ + q⁻¹ = 1
state_after: no goals
tactic: field_simp [h]
Theorem: Nat.le_one_iff_eq_zero_or_eq_one
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ ∀ {n : ℕ}, n ≤ 1 ↔ n = 0 ∨ n = 1
state_after: no goals
tactic: simp [le_succ_iff]
Theorem: Multiset.nodup_iff_count_le_one
File: Mathlib/Data/Multiset/Nodup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ t : Multiset α
a : α
inst✝ : DecidableEq α
s : Multiset α
_l : List α
⊢ Nodup (Quot.mk Setoid.r _l) ↔ ∀ (a : α), count a (Quot.mk Setoid.r _l) ≤ 1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ t : Multiset α
a : α
inst✝ : DecidableEq α
s : Multiset α
_l : List α
⊢ _l.Nodup ↔ ∀ (a : α), List.count a _l ≤ 1
tactic: simp only [quot_mk_to_coe'', coe_nodup, mem_coe, coe_count]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ t : Multiset α
a : α
inst✝ : DecidableEq α
s : Multiset α
_l : List α
⊢ _l.Nodup ↔ ∀ (a : α), List.count a _l ≤ 1
state_after: no goals
tactic: exact List.nodup_iff_count_le_one
Theorem: Polynomial.degree_list_sum_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
l : List S[X]
⊢ l.sum.degree ≤ (List.map natDegree l).maximum
state_after: case pos
R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
l : List S[X]
h : l.sum = 0
⊢ l.sum.degree ≤ (List.map natDegree l).maximum

case neg
R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
l : List S[X]
h : ¬l.sum = 0
⊢ l.sum.degree ≤ (List.map natDegree l).maximum
tactic: by_cases h : l.sum = 0