style(benchmark): fix string literal newline in LaTeX output (#415)

- Fixed invalid newline character in benchmark_suite.zig string literal
- Reformatted affected files for Zig 0.15 compliance
- Build passes, tests pass

Author: Antigravity Agent

.ralph/state/wake_count

@@ -1 +1 @@
-31
+34

.trinity/mu/heartbeat.json

@@ -1 +1 @@
-{"agent":"mu","wake":938,"timestamp":1774536510,"errors_scanned":0,"fixes_applied":0,"build_ok":true,"test_ok":true}
+{"agent":"mu","wake":954,"timestamp":1774542018,"errors_scanned":0,"fixes_applied":0,"build_ok":true,"test_ok":true}

.trinity/mu/state/wake_count

@@ -1 +1 @@
-938
+954

.trinity/scholar/heartbeat.json

@@ -1 +1 @@
-{"agent":"scholar","wake":776,"timestamp":1774536460,"fails_found":0,"researched":0,"fed_mu":0}
+{"agent":"scholar","wake":785,"timestamp":1774541904,"fails_found":0,"researched":0,"fed_mu":0}

.trinity/scholar/state/wake_count

@@ -1 +1 @@
-776
+785

src/benchmark/runner.zig

@@ -140,10 +140,7 @@ pub const BenchmarkRunner = struct {
         const writer = file.writer();
 
         // Header
-        try writer.print(
-            "model,n_seeds,ppl_mean,ppl_std,ppl_ci_low,ppl_ci_high,tok_mean,tok_std,lat_mean,lat_std,mem_mean,flops,improvement\n",
-            .{}
-        );
+        try writer.print("model,n_seeds,ppl_mean,ppl_std,ppl_ci_low,ppl_ci_high,tok_mean,tok_std,lat_mean,lat_std,mem_mean,flops,improvement\n", .{});
 
         // Data rows
         for (results) |r| {
@@ -174,7 +171,7 @@ pub fn countFLOPs(config: FLOPsConfig) u64 {
 
 pub fn estimateTrainingFLOPs(params_m: u32, n_tokens: u32) f64 {
     const training_flops = @as(f64, @floatFromInt(params_m)) *
-                          @as(f64, @floatFromInt(n_tokens)) * 6.0;
+        @as(f64, @floatFromInt(n_tokens)) * 6.0;
     return training_flops;
 }
 

src/benchmark_suite.zig

@@ -235,10 +235,9 @@ pub const AggregatedResult = struct {
         const model_name = try self.baseline_model.format(allocator);
         defer allocator.free(model_name);
 
-        // Format: Model & PPL & tok/s & Latency (ms) & Params (M) \\
+        // Format: Model & PPL & tok/s & Latency (ms) & Params (M) \\ (LaTeX line break)
         return std.fmt.allocPrint(allocator,
-            "{s} & {d:.2} $\\pm$ {d:.2} & {d:.1} $\\pm$ {d:.1} & {d:.2} $\\pm$ {d:.2} & {d} \\\\
-        , .{
+            "{s} & {d:.2} $\\pm$ {d:.2} & {d:.1} $\\pm$ {d:.1} & {d:.2} $\\pm$ {d:.2} & {d} \\\\", .{
             model_name,
             self.perplexity_mean,
             self.perplexity_std,

src/energy.zig

@@ -128,11 +128,7 @@ pub const EnergyEngine = struct {
     }
 
     /// Measure energy consumption for a function
-    pub fn measure(
-        self: *const EnergyEngine,
-        name: []const u8,
-        n_tokens: u32
-    ) !EnergyResult {
+    pub fn measure(self: *const EnergyEngine, name: []const u8, n_tokens: u32) !EnergyResult {
         _ = name;
 
         const sample_interval_s = @as(f64, @floatFromInt(self.config.sample_interval_ms)) / 1000.0;
@@ -168,12 +164,7 @@ pub const EnergyEngine = struct {
     }
 
     /// Measure across multiple seeds
-    pub fn measureSeeds(
-        self: *const EnergyEngine,
-        name: []const u8,
-        seeds: []const u32,
-        n_tokens_per_seed: u32
-    ) !EnergySummary {
+    pub fn measureSeeds(self: *const EnergyEngine, name: []const u8, seeds: []const u32, n_tokens_per_seed: u32) !EnergySummary {
         const start_time = std.time.nanoTimestamp();
 
         std.debug.print("\n╔══════════════════════════════════════════════╗\n", .{});
@@ -246,10 +237,7 @@ pub const EnergyEngine = struct {
         const writer = file.writer();
 
         // Header
-        try writer.print(
-            "metric,value,unit\n",
-            .{}
-        );
+        try writer.print("metric,value,unit\n", .{});
 
         // Aggregate results
         try writer.print("mean_power_watts,{d:.6},W\n", .{summary.results.mean_power_watts});
@@ -289,20 +277,18 @@ pub const EnergyEngine = struct {
             \\## Efficiency Metrics
             \\- FLOPs per joule: {d:.0}
             \\- Power state: mostly active
-            ,
-            .{
-                summary.n_samples,
-                summary.results.duration_secs,
-                summary.results.mean_power_watts,
-                summary.results.peak_power_watts,
-                summary.results.total_energy_joules,
-                summary.results.total_energy_joules / 3.6e6,
-                summary.results.energy_per_token_joules,
-                summary.results.carbon_g_co2e,
-                summary.results.carbon_g_co2e / 120.0, // 120 g CO2e per km
-                summary.results.flops_per_joule,
-            }
-        );
+        , .{
+            summary.n_samples,
+            summary.results.duration_secs,
+            summary.results.mean_power_watts,
+            summary.results.peak_power_watts,
+            summary.results.total_energy_joules,
+            summary.results.total_energy_joules / 3.6e6,
+            summary.results.energy_per_token_joules,
+            summary.results.carbon_g_co2e,
+            summary.results.carbon_g_co2e / 120.0, // 120 g CO2e per km
+            summary.results.flops_per_joule,
+        });
 
         return buffer.toOwnedSlice();
     }

src/hyperparameter_analysis.zig

@@ -113,26 +113,19 @@ pub const AnalysisEngine = struct {
     }
 
     /// Run sensitivity analysis for single hyperparameter
-    pub fn analyzeParam(
-        self: *const AnalysisEngine,
-        config: SensitivityConfig,
-        param_range: HyperparamRange
-    ) !SensitivityResult {
+    pub fn analyzeParam(self: *const AnalysisEngine, config: SensitivityConfig, param_range: HyperparamRange) !SensitivityResult {
         // Allocate response surface array (owned by result, not freed here)
         const response = try self.allocator.alloc(f64, param_range.n_steps);
 
         // Generate values from min to max
         for (0..param_range.n_steps) |i| {
             const t = @as(f64, @floatFromInt(i)) /
-                      @as(f64, @floatFromInt(param_range.n_steps - 1));
+                @as(f64, @floatFromInt(param_range.n_steps - 1));
 
             const value = switch (param_range.scale) {
                 .linear => param_range.min_value +
-                           t * (param_range.max_value - param_range.min_value),
-                .logarithmic => param_range.min_value * std.math.pow(f64,
-                    param_range.max_value / param_range.min_value,
-                    t
-                ),
+                    t * (param_range.max_value - param_range.min_value),
+                .logarithmic => param_range.min_value * std.math.pow(f64, param_range.max_value / param_range.min_value, t),
             };
 
             response[i] = value;
@@ -189,10 +182,7 @@ pub const AnalysisEngine = struct {
     }
 
     /// Run full sensitivity analysis across all hyperparameters
-    pub fn analyzeAll(
-        self: *const AnalysisEngine,
-        config: SensitivityConfig
-    ) !SensitivitySummary {
+    pub fn analyzeAll(self: *const AnalysisEngine, config: SensitivityConfig) !SensitivitySummary {
         // Allocate results array
         const results = try self.allocator.alloc(SensitivityResult, config.base_config.len);
         defer self.allocator.free(results);
@@ -230,10 +220,7 @@ pub const AnalysisEngine = struct {
     }
 
     /// Generate recommendations based on sensitivity results
-    fn generateRecommendations(
-        self: *const AnalysisEngine,
-        results: []const SensitivityResult
-    ) ![]const Recommendation {
+    fn generateRecommendations(self: *const AnalysisEngine, results: []const SensitivityResult) ![]const Recommendation {
         const recs = try self.allocator.alloc(Recommendation, results.len);
         errdefer self.allocator.free(recs);
 
@@ -264,22 +251,15 @@ pub const AnalysisEngine = struct {
     }
 
     /// Export results to CSV
-    pub fn exportCsv(
-        self: *const AnalysisEngine,
-        results: []const SensitivityResult,
-        path: []const u8
-    ) !void {
+    pub fn exportCsv(self: *const AnalysisEngine, results: []const SensitivityResult, path: []const u8) !void {
         _ = self;
         const file = try std.fs.cwd().createFile(path, .{});
         defer file.close();
 
         const writer = file.writer();
 
         // Header
-        try writer.print(
-            "param,min_value,max_value,best_value,sensitivity_score\n",
-            .{}
-        );
+        try writer.print("param,min_value,max_value,best_value,sensitivity_score\n", .{});
 
         // Data rows
         for (results) |r| {
@@ -294,10 +274,7 @@ pub const AnalysisEngine = struct {
     }
 
     /// Generate sensitivity report (human-readable)
-    pub fn generateReport(
-        self: *const AnalysisEngine,
-        summary: SensitivitySummary
-    ) ![]const u8 {
+    pub fn generateReport(self: *const AnalysisEngine, summary: SensitivitySummary) ![]const u8 {
         var buffer = std.ArrayList(u8).init(self.allocator);
         defer buffer.deinit();
 
@@ -310,13 +287,11 @@ pub const AnalysisEngine = struct {
             \\- Least sensitive: {s}
             \\
             \\## Recommendations
-            ,
-            .{
-                summary.n_params_analyzed,
-                @tagName(summary.most_sensitive),
-                @tagName(summary.least_sensitive),
-            }
-        );
+        , .{
+            summary.n_params_analyzed,
+            @tagName(summary.most_sensitive),
+            @tagName(summary.least_sensitive),
+        });
 
         for (summary.recommendations) |rec| {
             try buffer.writer().print(
@@ -325,14 +300,12 @@ pub const AnalysisEngine = struct {
                 \\- Confidence: {d:.0%}
                 \\- Reason: {s}
                 \\
-                ,
-                .{
-                    @tagName(rec.param),
-                    rec.suggested_value,
-                    rec.confidence * 100.0,
-                    rec.reason,
-                }
-            );
+            , .{
+                @tagName(rec.param),
+                rec.suggested_value,
+                rec.confidence * 100.0,
+                rec.reason,
+            });
         }
 
         return buffer.toOwnedSlice();
@@ -368,7 +341,7 @@ test "HyperparameterAnalysis - linear parameter range" {
     const config = SensitivityConfig{
         .name = "test",
         .base_config = &[_]HyperparamRange{range},
-        .seeds = &[_]u32{ 42 },
+        .seeds = &[_]u32{42},
         .dataset = .tinystories,
         .epochs = 10,
         .output_path = "/tmp/test.csv",
@@ -397,7 +370,7 @@ test "HyperparameterAnalysis - logarithmic parameter range" {
     const config = SensitivityConfig{
         .name = "test",
         .base_config = &[_]HyperparamRange{range},
-        .seeds = &[_]u32{ 42 },
+        .seeds = &[_]u32{42},
         .dataset = .tinystories,
         .epochs = 10,
         .output_path = "/tmp/test.csv",

src/profiling.zig

@@ -77,11 +77,7 @@ pub const ProfilingEngine = struct {
         std.debug.print("  Arch: {s}\n", .{@tagName(builtin.cpu.arch)});
     }
 
-    pub fn profileSeeds(
-        self: *const ProfilingEngine,
-        name: []const u8,
-        seeds: []const u32
-    ) !ProfileSummary {
+    pub fn profileSeeds(self: *const ProfilingEngine, name: []const u8, seeds: []const u32) !ProfileSummary {
         const start_time = std.time.nanoTimestamp();
 
         std.debug.print("\n╔════════════════════════════════════════════╗\n", .{});
@@ -126,10 +122,7 @@ pub const ProfilingEngine = struct {
         const writer = file.writer();
 
         // Header
-        try writer.print(
-            "metric,mean,std_dev,min,max,ci_95_low,ci_95_high,unit\n",
-            .{}
-        );
+        try writer.print("metric,mean,std_dev,min,max,ci_95_low,ci_95_high,unit\n", .{});
 
         // Data rows
         for (summary.results) |r| {
@@ -162,12 +155,10 @@ pub const ProfilingEngine = struct {
             \\- Total time: {d:.2}s
             \\
             \\## Results by Metric
-            ,
-            .{
-                summary.n_metrics,
-                summary.total_time_secs,
-            }
-        );
+        , .{
+            summary.n_metrics,
+            summary.total_time_secs,
+        });
 
         for (summary.results) |r| {
             try writer.print(
@@ -177,18 +168,16 @@ pub const ProfilingEngine = struct {
                 \\- Range: {d:.2} - {d:.2} {s}
                 \\- 95% CI: [{d:.2}, {d:.2}]
                 \\
-                ,
-                .{
-                    @tagName(r.metric),
-                    r.mean,
-                    r.std_dev,
-                    r.min,
-                    r.max,
-                    r.ci_95.low,
-                    r.ci_95.high,
-                    r.unit,
-                }
-            );
+            , .{
+                @tagName(r.metric),
+                r.mean,
+                r.std_dev,
+                r.min,
+                r.max,
+                r.ci_95.low,
+                r.ci_95.high,
+                r.unit,
+            });
         }
 
         return buffer.toOwnedSlice();