ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HasDerivAtFilter.neg
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
h : HasDerivAtFilter f f' x L
⊢ HasDerivAtFilter (fun x => -f x) (-f') x L
state_after: no goals
tactic: simpa using h.neg.hasDerivAtFilter
Theorem: Order.Ioc_pred_left_of_not_isMin
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : PredOrder α
a b : α
ha : ¬IsMin a
⊢ Ioc (pred a) b = Icc a b
state_after: no goals
tactic: rw [← Ioi_inter_Iic, Ioi_pred_of_not_isMin ha, Ici_inter_Iic]
Theorem: MeasureTheory.IsAddFundamentalDomain.setIntegral_eq_tsum'
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹² : Group G
inst✝¹¹ : Group H
inst✝¹⁰ : MulAction G α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : MulAction H β
inst✝⁷ : MeasurableSpace β
inst✝⁶ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSMul G α
inst✝³ : SMulInvariantMeasure G α μ
inst✝² : Countable G
ν : Measure α
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
h : IsFundamentalDomain G s μ
f : α → E
t : Set α
hf : IntegrableOn f t μ
⊢ ∑' (g : G), ∫ (x : α) in t ∩ g⁻¹ • s, f x ∂μ = ∑' (g : G), ∫ (x : α) in g⁻¹ • (g • t ∩ s), f x ∂μ
state_after: no goals
tactic: simp only [smul_set_inter, inv_smul_smul]
Theorem: _private.Mathlib.GroupTheory.SchurZassenhaus.0.Subgroup.SchurZassenhausInduction.step0
File: Mathlib/GroupTheory/SchurZassenhaus.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Finite G
N : Subgroup G
inst✝ : N.Normal
h1 : (Nat.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
    Nat.card G' < Nat.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
⊢ N ≠ ⊥
state_after: G : Type u
inst✝² : Group G
inst✝¹ : Finite G
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
    Nat.card G' < Nat.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
inst✝ : ⊥.Normal
h1 : (Nat.card ↥⊥).Coprime ⊥.index
h3 : ∀ (H : Subgroup G), ¬⊥.IsComplement' H
⊢ False
tactic: rintro rfl
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Finite G
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
    Nat.card G' < Nat.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
inst✝ : ⊥.Normal
h1 : (Nat.card ↥⊥).Coprime ⊥.index
h3 : ∀ (H : Subgroup G), ¬⊥.IsComplement' H
⊢ False
state_after: no goals
tactic: exact h3 ⊤ isComplement'_bot_top
Theorem: Equiv.piUnique_symm_apply
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α : Sort u
β✝ : Sort v
γ : Sort w
inst✝ : Unique α
β : α → Sort u_1
f : (i : α) → β i
⊢ uniqueElim ((fun f => f default) f) = f
state_after: case h
α : Sort u
β✝ : Sort v
γ : Sort w
inst✝ : Unique α
β : α → Sort u_1
f : (i : α) → β i
i : α
⊢ uniqueElim ((fun f => f default) f) i = f i
tactic: ext i
state_before: case h
α : Sort u
β✝ : Sort v
γ : Sort w
inst✝ : Unique α
β : α → Sort u_1
f : (i : α) → β i
i : α
⊢ uniqueElim ((fun f => f default) f) i = f i
state_after: case h.refl
α : Sort u
β✝ : Sort v
γ : Sort w
inst✝ : Unique α
β : α → Sort u_1
f : (i : α) → β i
⊢ uniqueElim ((fun f => f default) f) default = f default
tactic: cases Unique.eq_default i
state_before: case h.refl
α : Sort u
β✝ : Sort v
γ : Sort w
inst✝ : Unique α
β : α → Sort u_1
f : (i : α) → β i
⊢ uniqueElim ((fun f => f default) f) default = f default
state_after: no goals
tactic: rfl
Theorem: FiniteDimensional.finrank_of_not_finite
File: Mathlib/LinearAlgebra/Dimension/Free.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : StrongRankCondition R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : Module.Free R M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
inst✝³ : Module.Free R M'
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M₁
inst✝ : Module.Free R M₁
h : ¬Module.Finite R M
⊢ finrank R M = 0
state_after: R : Type u
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : StrongRankCondition R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : Module.Free R M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
inst✝³ : Module.Free R M'
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M₁
inst✝ : Module.Free R M₁
h : ¬Module.Finite R M
⊢ Module.rank R M = 0 ∨ ¬Module.Finite R M
tactic: rw [finrank, toNat_eq_zero, ← not_lt, Module.rank_lt_alpeh0_iff]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : StrongRankCondition R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : Module.Free R M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
inst✝³ : Module.Free R M'
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M₁
inst✝ : Module.Free R M₁
h : ¬Module.Finite R M
⊢ Module.rank R M = 0 ∨ ¬Module.Finite R M
state_after: no goals
tactic: exact .inr h
Theorem: Finset.image_diag_union_image_offDiag
File: Mathlib/Data/Finset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ image Sym2.mk s.diag ∪ image Sym2.mk s.offDiag = s.sym2
state_after: no goals
tactic: rw [← image_union, diag_union_offDiag, sym2_eq_image]
Theorem: LinearMap.charpoly_natDegree
File: Mathlib/LinearAlgebra/Charpoly/Basic.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁶ : CommRing R
inst✝⁵ : Nontrivial R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Module.Free R M
inst✝¹ : Module.Finite R M
f : M →ₗ[R] M
inst✝ : StrongRankCondition R
⊢ f.charpoly.natDegree = finrank R M
state_after: no goals
tactic: rw [charpoly, Matrix.charpoly_natDegree_eq_dim, finrank_eq_card_chooseBasisIndex]
Theorem: AddSubsemigroup.closure_induction'
File: Mathlib/Algebra/Group/Subsemigroup/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
s : Set M
p : (x : M) → x ∈ closure s → Prop
mem : ∀ (x : M) (h : x ∈ s), p x ⋯
mul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
x : M
hx : x ∈ closure s
⊢ p x hx
state_after: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
s : Set M
p : (x : M) → x ∈ closure s → Prop
mem : ∀ (x : M) (h : x ∈ s), p x ⋯
mul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
x : M
hx : x ∈ closure s
⊢ ∃ (x_1 : x ∈ closure s), p x x_1
tactic: refine Exists.elim ?_ fun (hx : x ∈ closure s) (hc : p x hx) => hc
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
s : Set M
p : (x : M) → x ∈ closure s → Prop
mem : ∀ (x : M) (h : x ∈ s), p x ⋯
mul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
x : M
hx : x ∈ closure s
⊢ ∃ (x_1 : x ∈ closure s), p x x_1
state_after: no goals
tactic: exact
    closure_induction hx (fun x hx => ⟨_, mem x hx⟩) fun x y ⟨hx', hx⟩ ⟨hy', hy⟩ =>
      ⟨_, mul _ _ _ _ hx hy⟩
Theorem: Set.zero_smul_subset
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
s : Set α
t✝ t : Set β
⊢ 0 • t ⊆ 0
state_after: no goals
tactic: simp [subset_def, mem_smul]
Theorem: Polynomial.reflect_C
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
r : R
N : ℕ
⊢ reflect N (C r) = C r * X ^ N
state_after: no goals
tactic: conv_lhs => rw [← mul_one (C r), ← pow_zero X, reflect_C_mul_X_pow, revAt_zero]
Theorem: summable_iff_nat_tsum_vanishing
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℕ → G
⊢ Multipliable f ↔ ∀ e ∈ 𝓝 1, ∃ N, ∀ t ⊆ {n | N ≤ n}, ∏' (n : ↑t), f ↑n ∈ e
state_after: no goals
tactic: rw [multipliable_iff_cauchySeq_finset, cauchySeq_finset_iff_nat_tprod_vanishing]
Theorem: Nat.sqrt_add_eq'
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
h : a ≤ n + n
⊢ (n ^ 2 + a).sqrt = n
state_after: no goals
tactic: simpa [Nat.pow_two] using sqrt_add_eq n h
Theorem: isClosed_sInter
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set (Set X)
⊢ (∀ t ∈ s, IsClosed t) → IsClosed (⋂₀ s)
state_after: no goals
tactic: simpa only [← isOpen_compl_iff, compl_sInter, sUnion_image] using isOpen_biUnion
Theorem: ENNReal.mul_lt_mul
File: Mathlib/Data/ENNReal/Operations.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ac : a < c
bd : b < d
⊢ a * b < c * d
state_after: case intro.intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ac : a < c
bd : b < d
a' : ℝ≥0
aa' : a < ↑a'
a'c : ↑a' < c
⊢ a * b < c * d
tactic: rcases lt_iff_exists_nnreal_btwn.1 ac with ⟨a', aa', a'c⟩
state_before: case intro.intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ac : a < c
bd : b < d
a' : ℝ≥0
aa' : a < ↑a'
a'c : ↑a' < c
⊢ a * b < c * d
state_after: case intro.intro.intro
b c d : ℝ≥0∞
r p q : ℝ≥0
bd : b < d
a' : ℝ≥0
a'c : ↑a' < c
a : ℝ≥0
ac : ↑a < c
aa' : ↑a < ↑a'
⊢ ↑a * b < c * d
tactic: lift a to ℝ≥0 using ne_top_of_lt aa'
state_before: case intro.intro.intro
b c d : ℝ≥0∞
r p q : ℝ≥0
bd : b < d
a' : ℝ≥0
a'c : ↑a' < c
a : ℝ≥0
ac : ↑a < c
aa' : ↑a < ↑a'
⊢ ↑a * b < c * d
state_after: case intro.intro.intro.intro.intro
b c d : ℝ≥0∞
r p q : ℝ≥0
bd : b < d
a' : ℝ≥0
a'c : ↑a' < c
a : ℝ≥0
ac : ↑a < c
aa' : ↑a < ↑a'
b' : ℝ≥0
bb' : b < ↑b'
b'd : ↑b' < d
⊢ ↑a * b < c * d
tactic: rcases lt_iff_exists_nnreal_btwn.1 bd with ⟨b', bb', b'd⟩
state_before: case intro.intro.intro.intro.intro
b c d : ℝ≥0∞
r p q : ℝ≥0
bd : b < d
a' : ℝ≥0
a'c : ↑a' < c
a : ℝ≥0
ac : ↑a < c
aa' : ↑a < ↑a'
b' : ℝ≥0
bb' : b < ↑b'
b'd : ↑b' < d
⊢ ↑a * b < c * d
state_after: case intro.intro.intro.intro.intro.intro
c d : ℝ≥0∞
r p q a' : ℝ≥0
a'c : ↑a' < c
a : ℝ≥0
ac : ↑a < c
aa' : ↑a < ↑a'
b' : ℝ≥0
b'd : ↑b' < d
b : ℝ≥0
bd : ↑b < d
bb' : ↑b < ↑b'
⊢ ↑a * ↑b < c * d
tactic: lift b to ℝ≥0 using ne_top_of_lt bb'
state_before: case intro.intro.intro.intro.intro.intro
c d : ℝ≥0∞
r p q a' : ℝ≥0
a'c : ↑a' < c
a : ℝ≥0
ac : ↑a < c
aa' : ↑a < ↑a'
b' : ℝ≥0
b'd : ↑b' < d
b : ℝ≥0
bd : ↑b < d
bb' : ↑b < ↑b'
⊢ ↑a * ↑b < c * d
state_after: case intro.intro.intro.intro.intro.intro
c d : ℝ≥0∞
r p q a' : ℝ≥0
a'c : ↑a' < c
a : ℝ≥0
ac : ↑a < c
b' : ℝ≥0
b'd : ↑b' < d
b : ℝ≥0
bd : ↑b < d
aa' : a < a'
bb' : b < b'
⊢ ↑(a * b) < c * d
tactic: norm_cast at *
state_before: case intro.intro.intro.intro.intro.intro
c d : ℝ≥0∞
r p q a' : ℝ≥0
a'c : ↑a' < c
a : ℝ≥0
ac : ↑a < c
b' : ℝ≥0
b'd : ↑b' < d
b : ℝ≥0
bd : ↑b < d
aa' : a < a'
bb' : b < b'
⊢ ↑(a * b) < c * d
state_after: no goals
tactic: calc
    ↑(a * b) < ↑(a' * b') := coe_lt_coe.2 (mul_lt_mul₀ aa' bb')
    _ ≤ c * d := mul_le_mul' a'c.le b'd.le
Theorem: Sublattice.coe_iInf
File: Mathlib/Order/Sublattice.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f✝ : LatticeHom α β
s t : Set α
a : α
f : ι → Sublattice α
⊢ ↑(⨅ i, f i) = ⋂ i, ↑(f i)
state_after: no goals
tactic: simp [iInf]
Theorem: Nat.floor_lt_ceil_of_lt_of_pos
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a < b
h' : 0 < b
⊢ ⌊a⌋₊ < ⌈b⌉₊
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a < b
h' : 0 < b
ha : 0 ≤ a
⊢ ⌊a⌋₊ < ⌈b⌉₊

case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
h : a < b
h' : 0 < b
ha : a < 0
⊢ ⌊a⌋₊ < ⌈b⌉₊
tactic: rcases le_or_lt 0 a with (ha | ha)
Theorem: Equiv.Perm.IsCycle.orderOf
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : f.IsCycle
⊢ orderOf f = f.support.card
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : f.IsCycle
⊢ Fintype.card ↥(Subgroup.zpowers f) = Fintype.card { x // x ∈ f.support }
tactic: rw [← Fintype.card_zpowers, ← Fintype.card_coe]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : f.IsCycle
⊢ Fintype.card ↥(Subgroup.zpowers f) = Fintype.card { x // x ∈ f.support }
state_after: no goals
tactic: convert Fintype.card_congr (IsCycle.zpowersEquivSupport hf)
Theorem: Matrix.cons_val'
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
v : n' → α
B : Fin m → n' → α
i : Fin m.succ
j : n'
⊢ vecCons v B i j = vecCons (v j) (fun i => B i j) i
state_after: no goals
tactic: refine Fin.cases ?_ ?_ i <;> simp
Theorem: Set.encard_empty
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
⊢ ∅.encard = 0
state_after: no goals
tactic: rw [encard_eq_zero]
Theorem: summable_iff_vanishing
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : CompleteSpace α
⊢ Multipliable f ↔ ∀ e ∈ 𝓝 1, ∃ s, ∀ (t : Finset β), Disjoint t s → ∏ b ∈ t, f b ∈ e
state_after: no goals
tactic: rw [multipliable_iff_cauchySeq_finset, cauchySeq_finset_iff_prod_vanishing]
Theorem: hammingNorm_smul_le_hammingNorm
File: Mathlib/InformationTheory/Hamming.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝⁶ : Fintype ι
inst✝⁵ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝⁴ : (i : ι) → DecidableEq (γ i)
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → Zero (γ i)
inst✝¹ : Zero α
inst✝ : (i : ι) → SMulWithZero α (β i)
k : α
x : (i : ι) → β i
i : ι
⊢ (fun i c => k • c) i 0 = 0
state_after: no goals
tactic: simp_rw [smul_zero]
Theorem: mul_pow
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommMonoid M
x y z a b : M
⊢ (a * b) ^ 0 = a ^ 0 * b ^ 0
state_after: no goals
tactic: rw [pow_zero, pow_zero, pow_zero, one_mul]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommMonoid M
x y z a b : M
n : ℕ
⊢ (a * b) ^ (n + 1) = a ^ (n + 1) * b ^ (n + 1)
state_after: no goals
tactic: rw [pow_succ', pow_succ', pow_succ', mul_pow, mul_mul_mul_comm]
Theorem: Set.Ico.coe_eq_zero
File: Mathlib/Algebra/Order/Interval/Set/Instances.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : OrderedSemiring α
inst✝ : Nontrivial α
x : ↑(Ico 0 1)
⊢ ↑x = 0 ↔ x = 0
state_after: α : Type u_1
inst✝¹ : OrderedSemiring α
inst✝ : Nontrivial α
x : ↑(Ico 0 1)
⊢ x = 0 ↔ ↑x = 0
tactic: symm
state_before: α : Type u_1
inst✝¹ : OrderedSemiring α
inst✝ : Nontrivial α
x : ↑(Ico 0 1)
⊢ x = 0 ↔ ↑x = 0
state_after: no goals
tactic: exact Subtype.ext_iff
Theorem: Set.card_inv
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : InvolutiveInv α
s✝ t s : Set α
⊢ Nat.card ↑s⁻¹ = Nat.card ↑s
state_after: no goals
tactic: rw [← image_inv, Nat.card_image_of_injective inv_injective]
Theorem: Set.bounded_lt_inter_lt
File: Mathlib/Order/Bounded.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝¹ : LinearOrder α
inst✝ : NoMaxOrder α
a : α
⊢ Bounded (fun x x_1 => x < x_1) (s ∩ {b | a < b}) ↔ Bounded (fun x x_1 => x < x_1) s
state_after: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝¹ : LinearOrder α
inst✝ : NoMaxOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a < b}) ↔ Bounded (fun x x_1 => x ≤ x_1) s
tactic: rw [← bounded_le_iff_bounded_lt, ← bounded_le_iff_bounded_lt]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝¹ : LinearOrder α
inst✝ : NoMaxOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a < b}) ↔ Bounded (fun x x_1 => x ≤ x_1) s
state_after: no goals
tactic: exact bounded_le_inter_lt a
Theorem: MeasureTheory.smul_set_ae_eq
File: Mathlib/MeasureTheory/Group/Action.lean

Proof steps:
state_before: G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace G
inst✝² : Group G
inst✝¹ : MulAction G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
c : G
s t : Set α
⊢ c • s =ᶠ[ae μ] c • t ↔ s =ᶠ[ae μ] t
state_after: no goals
tactic: simp only [Filter.eventuallyLE_antisymm_iff, smul_set_ae_le]
Theorem: Complex.re_add_im
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ (↑z.re + ↑z.im * I).re = z.re ∧ (↑z.re + ↑z.im * I).im = z.im
state_after: no goals
tactic: simp [ofReal']
Theorem: Fintype.card_compl_set
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Fintype α
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑sᶜ
⊢ card ↑sᶜ = card α - card ↑s
state_after: no goals
tactic: classical rw [← Set.toFinset_card, ← Set.toFinset_card, ← Finset.card_compl, Set.toFinset_compl]
Theorem: Metric.thickening_empty
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x : α
δ : ℝ
⊢ thickening δ ∅ = ∅
state_after: no goals
tactic: simp only [thickening, setOf_false, infEdist_empty, not_top_lt]
Theorem: Affine.Simplex.mongePointVSubFaceCentroidWeightsWithCircumcenter_eq_sub
File: Mathlib/Geometry/Euclidean/MongePoint.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
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
⊢ mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ =
    mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ
state_after: case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : PointsWithCircumcenterIndex (n + 2)
⊢ mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ i =
    (mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ) i
tactic: ext i
state_before: case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : PointsWithCircumcenterIndex (n + 2)
⊢ mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ i =
    (mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ) i
state_after: case h.pointIndex
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : Fin (n + 2 + 1)
⊢ mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ (pointIndex i) =
    (mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ) (pointIndex i)

case h.circumcenterIndex
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
⊢ mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ circumcenterIndex =
    (mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ) circumcenterIndex
tactic: cases' i with i
Theorem: mem_extremePoints_iff_forall_segment
File: Mathlib/Analysis/Convex/Extreme.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
A B : Set E
x : E
⊢ x ∈ extremePoints 𝕜 A ↔ x ∈ A ∧ ∀ x₁ ∈ A, ∀ x₂ ∈ A, x ∈ segment 𝕜 x₁ x₂ → x₁ = x ∨ x₂ = x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
A B : Set E
x : E
hxA : x ∈ A
x₁ : E
h₁ : x₁ ∈ A
x₂ : E
h₂ : x₂ ∈ A
⊢ x ∈ openSegment 𝕜 x₁ x₂ → x₁ = x ∧ x₂ = x ↔ x ∈ segment 𝕜 x₁ x₂ → x₁ = x ∨ x₂ = x
tactic: refine and_congr_right fun hxA ↦ forall₄_congr fun x₁ h₁ x₂ h₂ ↦ ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
A B : Set E
x : E
hxA : x ∈ A
x₁ : E
h₁ : x₁ ∈ A
x₂ : E
h₂ : x₂ ∈ A
⊢ x ∈ openSegment 𝕜 x₁ x₂ → x₁ = x ∧ x₂ = x ↔ x ∈ segment 𝕜 x₁ x₂ → x₁ = x ∨ x₂ = x
state_after: case mp
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
A B : Set E
x : E
hxA : x ∈ A
x₁ : E
h₁ : x₁ ∈ A
x₂ : E
h₂ : x₂ ∈ A
⊢ (x ∈ openSegment 𝕜 x₁ x₂ → x₁ = x ∧ x₂ = x) → x ∈ segment 𝕜 x₁ x₂ → x₁ = x ∨ x₂ = x

case mpr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
A B : Set E
x : E
hxA : x ∈ A
x₁ : E
h₁ : x₁ ∈ A
x₂ : E
h₂ : x₂ ∈ A
⊢ (x ∈ segment 𝕜 x₁ x₂ → x₁ = x ∨ x₂ = x) → x ∈ openSegment 𝕜 x₁ x₂ → x₁ = x ∧ x₂ = x
tactic: constructor
Theorem: CoxeterSystem.isRightDescent_iff
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.IsRightDescent w i ↔ cs.length (w * cs.simple i) + 1 = cs.length w
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) < cs.length w ↔ cs.length (w * cs.simple i) + 1 = cs.length w
tactic: unfold IsRightDescent
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) < cs.length w ↔ cs.length (w * cs.simple i) + 1 = cs.length w
state_after: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) < cs.length w → cs.length (w * cs.simple i) + 1 = cs.length w

case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) + 1 = cs.length w → cs.length (w * cs.simple i) < cs.length w
tactic: constructor
Theorem: Nat.modEq_three_digits_sum
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ n : ℕ
⊢ 10 % 3 = 1
state_after: no goals
tactic: norm_num
Theorem: AddCircle.card_addOrderOf_eq_totient
File: Mathlib/Topology/Instances/AddCircle.lean

Proof steps:
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : 𝕜
hp : Fact (0 < p)
n : ℕ
⊢ Nat.card { u // addOrderOf u = n } = n.totient
state_after: case inl
𝕜 : Type u_1
B : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : 𝕜
hp : Fact (0 < p)
⊢ Nat.card { u // addOrderOf u = 0 } = Nat.totient 0

case inr
𝕜 : Type u_1
B : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : 𝕜
hp : Fact (0 < p)
n : ℕ
hn : n > 0
⊢ Nat.card { u // addOrderOf u = n } = n.totient
tactic: rcases n.eq_zero_or_pos with (rfl | hn)