1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SetTheory.PGame.mul_moveRight_inl
File: Mathlib/SetTheory/Game/Basic.lean

tactic: cases x
state_before: x y : PGame
i : x.LeftMoves
j : y.RightMoves
⊢ (x * y).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    x.moveLeft i * y + x * y.moveRight j - x.moveLeft i * y.moveRight j
state_after: case mk
y : PGame
j : y.RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝ β✝ a✝¹ a✝ * y).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    (mk α✝ β✝ a✝¹ a✝).moveLeft i * y + mk α✝ β✝ a✝¹ a✝ * y.moveRight j - (mk α✝ β✝ a✝¹ a✝).moveLeft i * y.moveRight j

tactic: cases y
state_before: case mk
y : PGame
j : y.RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝ β✝ a✝¹ a✝ * y).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    (mk α✝ β✝ a✝¹ a✝).moveLeft i * y + mk α✝ β✝ a✝¹ a✝ * y.moveRight j - (mk α✝ β✝ a✝¹ a✝).moveLeft i * y.moveRight j
state_after: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * (mk α✝ β✝ a✝¹ a✝).moveRight j -
      (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i * (mk α✝ β✝ a✝¹ a✝).moveRight j

tactic: rfl
state_before: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * (mk α✝ β✝ a✝¹ a✝).moveRight j -
      (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i * (mk α✝ β✝ a✝¹ a✝).moveRight j
state_after: no goals
Theorem: Matrix.det_vandermonde_add
File: Mathlib/LinearAlgebra/Vandermonde.lean

tactic: simp [Matrix.det_vandermonde]
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → R
a : R
⊢ (vandermonde fun i => v i + a).det = (vandermonde v).det
state_after: no goals
Theorem: PEquiv.trans_bot
File: Mathlib/Data/PEquiv.lean

tactic: ext
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
⊢ f.trans ⊥ = ⊥
state_after: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ (f.trans ⊥) x✝ ↔ a✝ ∈ ⊥ x✝

tactic: dsimp [PEquiv.trans]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ (f.trans ⊥) x✝ ↔ a✝ ∈ ⊥ x✝
state_after: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ (f x✝).bind ⇑⊥ ↔ a✝ ∈ none

tactic: simp
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ (f x✝).bind ⇑⊥ ↔ a✝ ∈ none
state_after: no goals
Theorem: Metric.infDist_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [infDist, infEdist_closure]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ infDist x (closure s) = infDist x s
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isFibAux_two_mul_add_one
File: Mathlib/Tactic/NormNum/NatFib.lean

tactic: rw [← hn, fib_two_mul_add_one, H.1, H.2, pow_two, pow_two, add_comm, h1]
state_before: n a b n' a' b' : ℕ
H : IsFibAux n a b
hn : 2 * n + 1 = n'
h1 : a * a + b * b = a'
h2 : b * (2 * a + b) = b'
⊢ fib n' = a'
state_after: no goals

tactic: rw [← hn, fib_two_mul_add_two, H.1, H.2, h2]
state_before: n a b n' a' b' : ℕ
H : IsFibAux n a b
hn : 2 * n + 1 = n'
h1 : a * a + b * b = a'
h2 : b * (2 * a + b) = b'
⊢ fib (n' + 1) = b'
state_after: no goals
Theorem: Bool.or_eq_false_eq_eq_false_and_eq_false
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: cases a <;> cases b <;> simp
state_before: a b : Bool
⊢ ((a || b) = false) = (a = false ∧ b = false)
state_after: no goals
Theorem: modEq_mersenne
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: rw [one_mul]
state_before: n k : ℕ
⊢ 1 * (k / 2 ^ n) + k % 2 ^ n = k / 2 ^ n + k % 2 ^ n
state_after: no goals
Theorem: ClosureOperator.setOf_isClosed_eq_range_closure
File: Mathlib/Order/Closure.lean

tactic: ext x
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝¹ inst✝ : PartialOrder α
c : ClosureOperator α
x y : α
⊢ {x | c.IsClosed x} = range ⇑c
state_after: case h
α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝¹ inst✝ : PartialOrder α
c : ClosureOperator α
x✝ y x : α
⊢ x ∈ {x | c.IsClosed x} ↔ x ∈ range ⇑c

tactic: exact ⟨fun hx ↦ ⟨x, hx.closure_eq⟩, by rintro ⟨y, rfl⟩; exact c.isClosed_closure _⟩
state_before: case h
α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝¹ inst✝ : PartialOrder α
c : ClosureOperator α
x✝ y x : α
⊢ x ∈ {x | c.IsClosed x} ↔ x ∈ range ⇑c
state_after: no goals

tactic: rintro ⟨y, rfl⟩
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝¹ inst✝ : PartialOrder α
c : ClosureOperator α
x✝ y x : α
⊢ x ∈ range ⇑c → x ∈ {x | c.IsClosed x}
state_after: case intro
α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝¹ inst✝ : PartialOrder α
c : ClosureOperator α
x y✝ y : α
⊢ c y ∈ {x | c.IsClosed x}

tactic: exact c.isClosed_closure _
state_before: case intro
α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝¹ inst✝ : PartialOrder α
c : ClosureOperator α
x y✝ y : α
⊢ c y ∈ {x | c.IsClosed x}
state_after: no goals
Theorem: Finpartition.IsEquipartition.average_le_card_part
File: Mathlib/Order/Partition/Equipartition.lean

tactic: rw [← P.sum_card_parts]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
⊢ s.card / P.parts.card ≤ t.card
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
⊢ (∑ i ∈ P.parts, i.card) / P.parts.card ≤ t.card

tactic: exact Finset.EquitableOn.le hP ht
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
ht : t ∈ P.parts
⊢ (∑ i ∈ P.parts, i.card) / P.parts.card ≤ t.card
state_after: no goals
Theorem: threeAPFree_iff_eq_right
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

tactic: refine forall₄_congr fun a _ha b hb => forall₃_congr fun c hc habc => ⟨?_, ?_⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
⊢ ThreeAPFree s ↔ ∀ ⦃a : ℕ⦄, a ∈ s → ∀ ⦃b : ℕ⦄, b ∈ s → ∀ ⦃c : ℕ⦄, c ∈ s → a + c = b + b → a = c
state_after: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
b : ℕ
hb : b ∈ s
c : ℕ
hc : c ∈ s
habc : a + c = b + b
⊢ a = b → a = c

case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
b : ℕ
hb : b ∈ s
c : ℕ
hc : c ∈ s
habc : a + c = b + b
⊢ a = c → a = b

tactic: rintro rfl
state_before: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
b : ℕ
hb : b ∈ s
c : ℕ
hc : c ∈ s
habc : a + c = b + b
⊢ a = b → a = c
state_after: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
c : ℕ
hc : c ∈ s
hb : a ∈ s
habc : a + c = a + a
⊢ a = c

tactic: exact (add_left_cancel habc).symm
state_before: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
c : ℕ
hc : c ∈ s
hb : a ∈ s
habc : a + c = a + a
⊢ a = c
state_after: no goals

tactic: rintro rfl
state_before: case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
b : ℕ
hb : b ∈ s
c : ℕ
hc : c ∈ s
habc : a + c = b + b
⊢ a = c → a = b
state_after: case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
b : ℕ
hb : b ∈ s
hc : a ∈ s
habc : a + a = b + b
⊢ a = b

tactic: simp_rw [← two_mul] at habc
state_before: case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
b : ℕ
hb : b ∈ s
hc : a ∈ s
habc : a + a = b + b
⊢ a = b
state_after: case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
b : ℕ
hb : b ∈ s
hc : a ∈ s
habc : 2 * a = 2 * b
⊢ a = b

tactic: exact mul_left_cancel₀ two_ne_zero habc
state_before: case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Set ℕ
a : ℕ
_ha : a ∈ s
b : ℕ
hb : b ∈ s
hc : a ∈ s
habc : 2 * a = 2 * b
⊢ a = b
state_after: no goals
Theorem: min_def'
File: Mathlib/Order/Basic.lean

tactic: rw [min_def]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
⊢ min a b = if b ≤ a then b else a
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a

tactic: rcases lt_trichotomy a b with (lt | eq | gt)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
lt : a < b
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a

case inr.inl
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
eq : a = b
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a

case inr.inr
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
gt : b < a
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a

tactic: rw [if_pos lt.le, if_neg (not_le.mpr lt)]
state_before: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
lt : a < b
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a
state_after: no goals

tactic: rw [if_pos eq.le, if_pos eq.ge, eq]
state_before: case inr.inl
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
eq : a = b
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a
state_after: no goals

tactic: rw [if_neg (not_le.mpr gt.gt), if_pos gt.le]
state_before: case inr.inr
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
gt : b < a
⊢ (if a ≤ b then a else b) = if b ≤ a then b else a
state_after: no goals
Theorem: FiniteField.pow_card_pow
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: induction' n with n ih
state_before: K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
n : ℕ
a : K
⊢ a ^ q ^ n = a
state_after: case zero
K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
⊢ a ^ q ^ 0 = a

case succ
K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
n : ℕ
ih : a ^ q ^ n = a
⊢ a ^ q ^ (n + 1) = a

tactic: simp
state_before: case zero
K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
⊢ a ^ q ^ 0 = a
state_after: no goals

tactic: simp [pow_succ, pow_mul, ih, pow_card]
state_before: case succ
K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
n : ℕ
ih : a ^ q ^ n = a
⊢ a ^ q ^ (n + 1) = a
state_after: no goals
Theorem: IsKleinFour.mul_self
File: Mathlib/GroupTheory/SpecificGroups/KleinFour.lean

tactic: rw [mul_eq_one_iff_eq_inv, inv_eq_self]
state_before: G : Type u_1
inst✝¹ : Group G
inst✝ : IsKleinFour G
x : G
⊢ x * x = 1
state_after: no goals
Theorem: List.filter_eq_foldr
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> simp [*, filter]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ p : α → Bool
l : List α
⊢ filter p l = foldr (fun a out => bif p a then a :: out else out) [] l
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ p : α → Bool
head✝ : α
tail✝ : List α
tail_ih✝ : filter p tail✝ = foldr (fun a out => bif p a then a :: out else out) [] tail✝
⊢ (match p head✝ with
    | true => head✝ :: foldr (fun a out => bif p a then a :: out else out) [] tail✝
    | false => foldr (fun a out => bif p a then a :: out else out) [] tail✝) =
    bif p head✝ then head✝ :: foldr (fun a out => bif p a then a :: out else out) [] tail✝
    else foldr (fun a out => bif p a then a :: out else out) [] tail✝

tactic: rfl
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ p : α → Bool
head✝ : α
tail✝ : List α
tail_ih✝ : filter p tail✝ = foldr (fun a out => bif p a then a :: out else out) [] tail✝
⊢ (match p head✝ with
    | true => head✝ :: foldr (fun a out => bif p a then a :: out else out) [] tail✝
    | false => foldr (fun a out => bif p a then a :: out else out) [] tail✝) =
    bif p head✝ then head✝ :: foldr (fun a out => bif p a then a :: out else out) [] tail✝
    else foldr (fun a out => bif p a then a :: out else out) [] tail✝
state_after: no goals
Theorem: HNNExtension.NormalWord.prod_cons
File: Mathlib/GroupTheory/HNNExtension.lean

tactic: simp [ReducedWord.prod, cons, smul_def, mul_assoc]
state_before: G : Type u_1
inst✝³ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝² : Group H
M : Type u_3
inst✝¹ : Monoid M
d : TransversalPair G A B
inst✝ : DecidableEq G
g : G
u : ℤˣ
w : NormalWord d
h1 : w.head ∈ d.set u
h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ toSubgroup A B u → u = u'
⊢ ReducedWord.prod φ (cons g u w h1 h2).toReducedWord = of g * (t ^ ↑u * ReducedWord.prod φ w.toReducedWord)
state_after: no goals
Theorem: WithTop.iInf_coe_lt_top
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [lt_top_iff_ne_top, Ne, iInf_coe_eq_top, not_isEmpty_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
f : ι → α
⊢ ⨅ i, ↑(f i) < ⊤ ↔ Nonempty ι
state_after: no goals
Theorem: Polynomial.taylor_mul
File: Mathlib/Algebra/Polynomial/Taylor.lean

tactic: simp only [taylor_apply, mul_comp]
state_before: R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f : R✝[X]
R : Type u_2
inst✝ : CommSemiring R
r : R
p q : R[X]
⊢ (taylor r) (p * q) = (taylor r) p * (taylor r) q
state_after: no goals
Theorem: Nat.factorial_eq_one
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: constructor
state_before: m n : ℕ
⊢ n ! = 1 ↔ n ≤ 1
state_after: case mp
m n : ℕ
⊢ n ! = 1 → n ≤ 1

case mpr
m n : ℕ
⊢ n ≤ 1 → n ! = 1

tactic: intro h
state_before: case mp
m n : ℕ
⊢ n ! = 1 → n ≤ 1
state_after: case mp
m n : ℕ
h : n ! = 1
⊢ n ≤ 1

tactic: rw [← not_lt, ← one_lt_factorial, h]
state_before: case mp
m n : ℕ
h : n ! = 1
⊢ n ≤ 1
state_after: case mp
m n : ℕ
h : n ! = 1
⊢ ¬1 < 1

tactic: apply lt_irrefl
state_before: case mp
m n : ℕ
h : n ! = 1
⊢ ¬1 < 1
state_after: no goals

tactic: rintro (_|_|_) <;> rfl
state_before: case mpr
m n : ℕ
⊢ n ≤ 1 → n ! = 1
state_after: no goals
Theorem: balancedCore_eq_iInter
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

tactic: refine balancedCore_subset_balancedCoreAux.antisymm ?_
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ balancedCore 𝕜 s = ⋂ r, ⋂ (_ : 1 ≤ ‖r‖), r • s
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ balancedCoreAux 𝕜 s ⊆ balancedCore 𝕜 s

tactic: refine (balancedCoreAux_balanced ?_).subset_balancedCore_of_subset (balancedCoreAux_subset s)
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ balancedCoreAux 𝕜 s ⊆ balancedCore 𝕜 s
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ 0 ∈ balancedCoreAux 𝕜 s

tactic: exact balancedCore_subset_balancedCoreAux (balancedCore_zero_mem hs)
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ 0 ∈ balancedCoreAux 𝕜 s
state_after: no goals
Theorem: AffineIndependent.affineSpan_eq_of_le_of_card_eq_finrank_add_one
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: classical
rw [← Finset.card_univ] at hc
rw [← Set.image_univ, ← Finset.coe_univ, ← Finset.coe_image] at hle ⊢
exact hi.affineSpan_image_finset_eq_of_le_of_card_eq_finrank_add_one hle hc
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁵ : DivisionRing k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
inst✝¹ : Fintype ι
p : ι → P
hi : AffineIndependent k p
sp : AffineSubspace k P
inst✝ : FiniteDimensional k ↥sp.direction
hle : affineSpan k (Set.range p) ≤ sp
hc : Fintype.card ι = finrank k ↥sp.direction + 1
⊢ affineSpan k (Set.range p) = sp
state_after: no goals

tactic: rw [← Finset.card_univ] at hc
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁵ : DivisionRing k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
inst✝¹ : Fintype ι
p : ι → P
hi : AffineIndependent k p
sp : AffineSubspace k P
inst✝ : FiniteDimensional k ↥sp.direction
hle : affineSpan k (Set.range p) ≤ sp
hc : Fintype.card ι = finrank k ↥sp.direction + 1
⊢ affineSpan k (Set.range p) = sp
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁵ : DivisionRing k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
inst✝¹ : Fintype ι
p : ι → P
hi : AffineIndependent k p
sp : AffineSubspace k P
inst✝ : FiniteDimensional k ↥sp.direction
hle : affineSpan k (Set.range p) ≤ sp
hc : Finset.univ.card = finrank k ↥sp.direction + 1
⊢ affineSpan k (Set.range p) = sp

tactic: rw [← Set.image_univ, ← Finset.coe_univ, ← Finset.coe_image] at hle ⊢
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁵ : DivisionRing k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
inst✝¹ : Fintype ι
p : ι → P
hi : AffineIndependent k p
sp : AffineSubspace k P
inst✝ : FiniteDimensional k ↥sp.direction
hle : affineSpan k (Set.range p) ≤ sp
hc : Finset.univ.card = finrank k ↥sp.direction + 1
⊢ affineSpan k (Set.range p) = sp
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁵ : DivisionRing k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
inst✝¹ : Fintype ι
p : ι → P
hi : AffineIndependent k p
sp : AffineSubspace k P
inst✝ : FiniteDimensional k ↥sp.direction
hle : affineSpan k ↑(Finset.image p Finset.univ) ≤ sp
hc : Finset.univ.card = finrank k ↥sp.direction + 1
⊢ affineSpan k ↑(Finset.image p Finset.univ) = sp

tactic: exact hi.affineSpan_image_finset_eq_of_le_of_card_eq_finrank_add_one hle hc
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁵ : DivisionRing k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
inst✝¹ : Fintype ι
p : ι → P
hi : AffineIndependent k p
sp : AffineSubspace k P
inst✝ : FiniteDimensional k ↥sp.direction
hle : affineSpan k ↑(Finset.image p Finset.univ) ≤ sp
hc : Finset.univ.card = finrank k ↥sp.direction + 1
⊢ affineSpan k ↑(Finset.image p Finset.univ) = sp
state_after: no goals
Theorem: MvPolynomial.coe_injective
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

tactic: ext
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ x y : MvPolynomial σ R
h : Coe.coe x = Coe.coe y
⊢ x = y
state_after: case a
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ x y : MvPolynomial σ R
h : Coe.coe x = Coe.coe y
m✝ : σ →₀ ℕ
⊢ coeff m✝ x = coeff m✝ y

tactic: simp_rw [← coeff_coe]
state_before: case a
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ x y : MvPolynomial σ R
h : Coe.coe x = Coe.coe y
m✝ : σ →₀ ℕ
⊢ coeff m✝ x = coeff m✝ y
state_after: case a
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ x y : MvPolynomial σ R
h : Coe.coe x = Coe.coe y
m✝ : σ →₀ ℕ
⊢ (MvPowerSeries.coeff R m✝) ↑x = (MvPowerSeries.coeff R m✝) ↑y

tactic: congr
state_before: case a
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ x y : MvPolynomial σ R
h : Coe.coe x = Coe.coe y
m✝ : σ →₀ ℕ
⊢ (MvPowerSeries.coeff R m✝) ↑x = (MvPowerSeries.coeff R m✝) ↑y
state_after: no goals
Theorem: MeasurableEmbedding.integrableAtFilter_iff_comap
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: simp_rw [← he.integrableAtFilter_map_iff, IntegrableAtFilter, he.map_comap]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
⊢ IntegrableAtFilter f (map e l) μ ↔ IntegrableAtFilter (f ∘ e) l (Measure.comap e μ)
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
⊢ (∃ s ∈ map e l, IntegrableOn f s μ) ↔ ∃ s ∈ map e l, IntegrableOn f s (μ.restrict (range e))

tactic: constructor <;> rintro ⟨s, hs, int⟩
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
⊢ (∃ s ∈ map e l, IntegrableOn f s μ) ↔ ∃ s ∈ map e l, IntegrableOn f s (μ.restrict (range e))
state_after: case mp.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
s : Set β
hs : s ∈ map e l
int : IntegrableOn f s μ
⊢ ∃ s ∈ map e l, IntegrableOn f s (μ.restrict (range e))

case mpr.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
s : Set β
hs : s ∈ map e l
int : IntegrableOn f s (μ.restrict (range e))
⊢ ∃ s ∈ map e l, IntegrableOn f s μ

tactic: exact ⟨s, hs, int.mono_measure <| μ.restrict_le_self⟩
state_before: case mp.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
s : Set β
hs : s ∈ map e l
int : IntegrableOn f s μ
⊢ ∃ s ∈ map e l, IntegrableOn f s (μ.restrict (range e))
state_after: no goals

tactic: exact ⟨_, inter_mem hs range_mem_map, int.inter_of_restrict⟩
state_before: case mpr.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
s : Set β
hs : s ∈ map e l
int : IntegrableOn f s (μ.restrict (range e))
⊢ ∃ s ∈ map e l, IntegrableOn f s μ
state_after: no goals
Theorem: List.unzip_right
File: Mathlib/Data/List/Zip.lean

tactic: simp only [unzip_eq_map]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l : List (α × β)
⊢ l.unzip.2 = map Prod.snd l
state_after: no goals
Theorem: MeasureTheory.trim_eq_self
File: Mathlib/MeasureTheory/Measure/Trim.lean

tactic: simp [Measure.trim]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
⊢ μ.trim ⋯ = μ
state_after: no goals
Theorem: Filter.tendsto_iInf
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Tendsto, iff_self_iff, le_iInf_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : α → β
x : Filter α
y : ι → Filter β
⊢ Tendsto f x (⨅ i, y i) ↔ ∀ (i : ι), Tendsto f x (y i)
state_after: no goals
Theorem: Sum.comp_traverse
File: Mathlib/Control/Traversable/Instances.lean

tactic: cases x <;> simp! [Sum.traverse, map_id, functor_norm] <;> rfl
state_before: σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β γ : Type u
f : β → F γ
g : α → G β
x : σ ⊕ α
⊢ Sum.traverse (Comp.mk ∘ (fun x => f <$> x) ∘ g) x = Comp.mk (Sum.traverse f <$> Sum.traverse g x)
state_after: no goals